fix

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/audio_core/device/device_session.cpp

@@ -22,9 +22,11 @@ using namespace std::literals;
 constexpr auto INCREMENT_TIME{5ms};
 
 DeviceSession::DeviceSession(Core::System& system_)
-    : system{system_}, thread_event{Core::Timing::CreateEvent(
+    : system{system_}
-                           "AudioOutSampleTick",
+    , thread_event{system_.CreateTimingEvent("AudioOutSampleTick", [this](s64 time, std::chrono::nanoseconds) {
-                           [this](s64 time, std::chrono::nanoseconds) { return ThreadFunc(); })} {}
+        return ThreadFunc();
+    })}
+{}
 
 DeviceSession::~DeviceSession() {
     Finalize();

src/core/core.cpp

@@ -969,4 +969,8 @@ void System::ApplySettings() {
     }
 }
 
+std::shared_ptr<Core::Timing::EventType> System::CreateTimingEvent(std::string name, Core::Timing::TimedCallback&& callback) {
+    return std::make_shared<Core::Timing::EventType>(std::move(callback), std::move(name));
+}
+
 } // namespace Core

src/core/core.h

@@ -19,6 +19,7 @@
 #include "core/file_sys/vfs/vfs_types.h"
 #include "core/hle/service/os/event.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/core_timing.h"
 
 namespace Core::Frontend {
 class EmuWindow;
@@ -438,6 +439,9 @@ public:
     /// Applies any changes to settings to this core instance.
     void ApplySettings();
 
+    std::shared_ptr<Core::Timing::EventType> CreateTimingEvent(std::string name, Core::Timing::TimedCallback&& callback);
+
+private:
     struct Impl;
     std::unique_ptr<Impl> impl;
 };

src/core/core_timing.cpp

@@ -23,10 +23,6 @@ namespace Core::Timing {
 
 constexpr s64 MAX_SLICE_LENGTH = 10000;
 
-std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback) {
-    return std::make_shared<EventType>(std::move(callback), std::move(name));
-}
-
 struct CoreTiming::Event {
     s64 time;
     u64 fifo_order;
@@ -36,11 +32,10 @@ struct CoreTiming::Event {
 
     // Sort by time, unless the times are the same, in which case sort by
     // the order added to the queue
-    friend bool operator>(const Event& left, const Event& right) {
+    friend bool operator>(const Event& left, const Event& right) noexcept {
         return std::tie(left.time, left.fifo_order) > std::tie(right.time, right.fifo_order);
     }
-
+    friend bool operator<(const Event& left, const Event& right) noexcept {
-    friend bool operator<(const Event& left, const Event& right) {
         return std::tie(left.time, left.fifo_order) < std::tie(right.time, right.fifo_order);
     }
 };
@@ -60,8 +55,6 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
             Common::SetCurrentThreadName("HostTiming");
             Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
             on_thread_init();
-            has_started = true;
-
             // base frequency in MHz: 1ns (10^-9) = 1GHz (10^9)
             while (!stop_token.stop_requested()) {
                 while (!paused && !stop_token.stop_requested()) {
@@ -77,8 +70,8 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
                         // continue.
                         wait_set = true;
                         event.Wait();
+                        wait_set = false;
                     }
-                    wait_set = false;
                 }
                 paused_set = true;
                 pause_event.Wait();
@@ -144,39 +137,28 @@ void CoreTiming::ScheduleEvent(std::chrono::nanoseconds ns_into_future,
     event.Set();
 }
 
-void CoreTiming::ScheduleLoopingEvent(std::chrono::nanoseconds start_time,
+void CoreTiming::ScheduleLoopingEvent(std::chrono::nanoseconds start_time, std::chrono::nanoseconds resched_time, const std::shared_ptr<EventType>& event_type, bool absolute_time) {
-                                      std::chrono::nanoseconds resched_time,
-                                      const std::shared_ptr<EventType>& event_type,
-                                      bool absolute_time) {
     {
         std::scoped_lock scope{basic_lock};
         const auto next_time{absolute_time ? start_time : GetGlobalTimeNs() + start_time};
-
+        auto h = event_queue.emplace(Event{next_time.count(), event_fifo_id++, event_type, resched_time.count()});
-        auto h{event_queue.emplace(
-            Event{next_time.count(), event_fifo_id++, event_type, resched_time.count()})};
         (*h).handle = h;
     }
-
     event.Set();
 }
 
-void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
+void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type, UnscheduleEventType type) {
-                                 UnscheduleEventType type) {
     {
         std::scoped_lock lk{basic_lock};
-
         std::vector<heap_t::handle_type> to_remove;
-        for (auto itr = event_queue.begin(); itr != event_queue.end(); itr++) {
+        for (auto it = event_queue.begin(); it != event_queue.end(); it++) {
-            const Event& e = *itr;
+            auto const& e = *it;
             if (e.type.lock().get() == event_type.get()) {
-                to_remove.push_back(itr->handle);
+                to_remove.push_back(it->handle);
             }
         }
-
+        for (auto& h : to_remove)
-        for (auto& h : to_remove) {
             event_queue.erase(h);
-        }
-
         event_type->sequence_number++;
     }
 
@@ -187,16 +169,15 @@ void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
 }
 
 static u64 GetNextTickCount(u64 next_ticks) {
-    if (Settings::values.use_custom_cpu_ticks.GetValue()) {
+    if (Settings::values.use_custom_cpu_ticks.GetValue())
         return Settings::values.cpu_ticks.GetValue();
-    }
     return next_ticks;
 }
 
 void CoreTiming::AddTicks(u64 ticks_to_add) {
     const u64 ticks = GetNextTickCount(ticks_to_add);
     cpu_ticks += ticks;
-    downcount -= static_cast<s64>(ticks);
+    downcount -= s64(ticks);
 }
 
 void CoreTiming::Idle() {
@@ -270,19 +251,14 @@ std::optional<s64> CoreTiming::Advance() {
                     next_time = pause_end_time + next_schedule_time;
                 }
 
-                event_queue.update(evt.handle, Event{next_time, event_fifo_id++, evt.type,
+                event_queue.update(evt.handle, Event{next_time, event_fifo_id++, evt.type, next_schedule_time, evt.handle});
-                                                     next_schedule_time, evt.handle});
             }
         }
 
         global_timer = GetGlobalTimeNs().count();
     }
 
-    if (!event_queue.empty()) {
+    return event_queue.empty() ? std::optional<s64>{} : event_queue.top().time;
-        return event_queue.top().time;
-    } else {
-        return std::nullopt;
-    }
 }
 
 void CoreTiming::Reset() {
@@ -293,7 +269,6 @@ void CoreTiming::Reset() {
         timer_thread.request_stop();
         timer_thread.join();
     }
-    has_started = false;
 }
 
 /// @brief Returns current time in nanoseconds.
@@ -310,10 +285,4 @@ std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const noexcept {
         : std::chrono::microseconds{Common::WallClock::CPUTickToUS(cpu_ticks)};
 }
 
-#ifdef _WIN32
-void CoreTiming::SetTimerResolutionNs(std::chrono::nanoseconds ns) {
-    timer_resolution_ns = ns.count();
-}
-#endif
-
 } // namespace Core::Timing

src/core/core_timing.h

@@ -29,8 +29,7 @@ using TimedCallback = std::function<std::optional<std::chrono::nanoseconds>(
 
 /// Contains the characteristics of a particular event.
 struct EventType {
-    explicit EventType(TimedCallback&& callback_, std::string&& name_)
+    explicit EventType(TimedCallback&& callback_, std::string&& name_) : callback{std::move(callback_)}, name{std::move(name_)}, sequence_number{0} {}
-        : callback{std::move(callback_)}, name{std::move(name_)}, sequence_number{0} {}
 
     /// The event's callback function.
     TimedCallback callback;
@@ -90,11 +89,6 @@ public:
     /// Checks if core timing is running.
     bool IsRunning() const;
 
-    /// Checks if the timer thread has started.
-    bool HasStarted() const {
-        return has_started;
-    }
-
     /// Checks if there are any pending time events.
     bool HasPendingEvents() const;
 
@@ -134,45 +128,29 @@ public:
     /// Checks for events manually and returns time in nanoseconds for next event, threadsafe.
     std::optional<s64> Advance();
 
-#ifdef _WIN32
-    void SetTimerResolutionNs(std::chrono::nanoseconds ns);
-#endif
-
     struct Event;
 
     void Reset();
 
     using heap_t = boost::heap::fibonacci_heap<CoreTiming::Event, boost::heap::compare<std::greater<>>>;
+    Common::Event event{};
+    Common::Event pause_event{};
+
+    alignas(64) mutable std::mutex basic_lock;
+    alignas(64) std::mutex advance_lock;
+    alignas(64) std::atomic<bool> paused{};
+    alignas(64) std::atomic<bool> paused_set{};
+    alignas(64) std::atomic<bool> wait_set{};
+    std::function<void()> on_thread_init{};
     heap_t event_queue;
+    std::jthread timer_thread;
     s64 global_timer = 0;
-#ifdef _WIN32
-    s64 timer_resolution_ns;
-#endif
     u64 event_fifo_id = 0;
     s64 pause_end_time{};
     /// Cycle timing
     u64 cpu_ticks{};
     s64 downcount{};
-    Common::Event event{};
-    Common::Event pause_event{};
-    std::function<void()> on_thread_init{};
-    std::jthread timer_thread;
-    mutable std::mutex basic_lock;
-    std::mutex advance_lock;
-    std::atomic<bool> paused{};
-    std::atomic<bool> paused_set{};
-    std::atomic<bool> wait_set{};
-    std::atomic<bool> has_started{};
     bool is_multicore{};
 };
 
-/// Creates a core timing event with the given name and callback.
-///
-/// @param name     The name of the core timing event to create.
-/// @param callback The callback to execute for the event.
-///
-/// @returns An EventType instance representing the created event.
-///
-std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback);
-
 } // namespace Core::Timing

src/core/hle/kernel/k_hardware_timer.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -13,11 +13,10 @@ namespace Kernel {
 
 void KHardwareTimer::Initialize() {
     // Create the timing callback to register with CoreTiming.
-    m_event_type = Core::Timing::CreateEvent("KHardwareTimer::Callback",
+    m_event_type = m_kernel.System().CreateTimingEvent("KHardwareTimer::Callback", [this](s64, std::chrono::nanoseconds) {
-                                             [this](s64, std::chrono::nanoseconds) {
+        this->DoTask();
-                                                 this->DoTask();
+        return std::nullopt;
-                                                 return std::nullopt;
+    });
-                                             });
 }
 
 void KHardwareTimer::Finalize() {

src/core/hle/kernel/kernel.cpp

@@ -255,7 +255,7 @@ struct KernelCore::Impl {
     }
 
     void InitializePreemption(KernelCore& kernel) {
-        preemption_event = Core::Timing::CreateEvent("PreemptionCallback", [this, &kernel](s64 time, std::chrono::nanoseconds) -> std::optional<std::chrono::nanoseconds> {
+        preemption_event = system.CreateTimingEvent("PreemptionCallback", [this, &kernel](s64 time, std::chrono::nanoseconds) -> std::optional<std::chrono::nanoseconds> {
             {
                 KScopedSchedulerLock lock(kernel);
                 global_scheduler_context->PreemptThreads(kernel);

src/core/hle/service/glue/time/alarm_worker.cpp

@@ -25,16 +25,11 @@ AlarmWorker::~AlarmWorker() {
 
 void AlarmWorker::Initialize(std::shared_ptr<Service::PSC::Time::ServiceManager> time_m) {
     m_time_m = std::move(time_m);
-
     m_timer_event = m_ctx.CreateEvent("Glue:AlarmWorker:TimerEvent");
-    m_timer_timing_event = Core::Timing::CreateEvent(
+    m_timer_timing_event = m_system.CreateTimingEvent("Glue:AlarmWorker::AlarmTimer", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-        "Glue:AlarmWorker::AlarmTimer",
+        m_timer_event->Signal(m_system.Kernel());
-        [this](s64 time,
+        return std::nullopt;
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+    });
-            m_timer_event->Signal(m_system.Kernel());
-            return std::nullopt;
-        });
-
     AttachToClosestAlarmEvent();
 }
 

src/core/hle/service/glue/time/worker.cpp

@@ -22,28 +22,19 @@ namespace Service::Glue::Time {
 
 TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
                        FileTimestampWorker& file_timestamp_worker)
-    : m_system{system}, m_ctx{m_system, "Glue:TimeWorker"}, m_event{m_ctx.CreateEvent(
+    : m_system{system}, m_ctx{m_system, "Glue:TimeWorker"}, m_event{m_ctx.CreateEvent("Glue:TimeWorker:Event")},
-                                                                "Glue:TimeWorker:Event")},
       m_steady_clock_resource{steady_clock_resource},
-      m_file_timestamp_worker{file_timestamp_worker}, m_timer_steady_clock{m_ctx.CreateEvent(
+      m_file_timestamp_worker{file_timestamp_worker}, m_timer_steady_clock{m_ctx.CreateEvent("Glue:TimeWorker:SteadyClockTimerEvent")},
-                                                          "Glue:TimeWorker:SteadyClockTimerEvent")},
       m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")},
       m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} {
-    m_timer_steady_clock_timing_event = Core::Timing::CreateEvent(
+    m_timer_steady_clock_timing_event = m_system.CreateTimingEvent("Time::SteadyClockEvent", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-        "Time::SteadyClockEvent",
+        m_timer_steady_clock->Signal(m_system.Kernel());
-        [this](s64 time,
+        return std::nullopt;
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+    });
-            m_timer_steady_clock->Signal(m_system.Kernel());
+    m_timer_file_system_timing_event = m_system.CreateTimingEvent("Time::SteadyClockEvent", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            return std::nullopt;
+        m_timer_file_system->Signal(m_system.Kernel());
-        });
+        return std::nullopt;
-
+    });
-    m_timer_file_system_timing_event = Core::Timing::CreateEvent(
-        "Time::SteadyClockEvent",
-        [this](s64 time,
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            m_timer_file_system->Signal(m_system.Kernel());
-            return std::nullopt;
-        });
 }
 
 TimeWorker::~TimeWorker() {

src/core/hle/service/hid/hidbus.cpp

@@ -51,17 +51,12 @@ Hidbus::Hidbus(Core::System& system_)
     RegisterHandlers(functions);
 
     // Register update callbacks
-    hidbus_update_event = Core::Timing::CreateEvent(
+    hidbus_update_event = system_.CreateTimingEvent("Hidbus::UpdateCallback", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-        "Hidbus::UpdateCallback",
+        const auto guard = LockService();
-        [this](s64 time,
+        UpdateHidbus(ns_late);
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+        return std::nullopt;
-            const auto guard = LockService();
+    });
-            UpdateHidbus(ns_late);
+    system_.CoreTiming().ScheduleLoopingEvent(hidbus_update_ns, hidbus_update_ns, hidbus_update_event);
-            return std::nullopt;
-        });
-
-    system_.CoreTiming().ScheduleLoopingEvent(hidbus_update_ns, hidbus_update_ns,
-                                              hidbus_update_event);
 }
 
 Hidbus::~Hidbus() {

src/core/hle/service/vi/conductor.cpp

@@ -23,25 +23,17 @@ Conductor::Conductor(Core::System& system, Container& container, DisplayList& di
     });
 
     if (system.IsMulticore()) {
-        m_event = Core::Timing::CreateEvent(
+        m_event = system.CreateTimingEvent("ScreenComposition", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            "ScreenComposition",
+            m_signal.Set();
-            [this](s64 time,
+            return std::chrono::nanoseconds(this->GetNextTicks());
-                   std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+        });
-                m_signal.Set();
-                return std::chrono::nanoseconds(this->GetNextTicks());
-            });
-
         system.CoreTiming().ScheduleLoopingEvent(FrameNs, FrameNs, m_event);
         m_thread = std::jthread([this](std::stop_token token) { this->VsyncThread(token); });
     } else {
-        m_event = Core::Timing::CreateEvent(
+        m_event = system.CreateTimingEvent("ScreenComposition", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            "ScreenComposition",
+            this->ProcessVsync();
-            [this](s64 time,
+            return std::chrono::nanoseconds(this->GetNextTicks());
-                   std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+        });
-                this->ProcessVsync();
-                return std::chrono::nanoseconds(this->GetNextTicks());
-            });
-
         system.CoreTiming().ScheduleLoopingEvent(FrameNs, FrameNs, m_event);
     }
 }

src/core/memory/cheat_engine.cpp

@@ -231,12 +231,10 @@ CheatEngine::~CheatEngine() {
 }
 
 void CheatEngine::Initialize() {
-    event = Core::Timing::CreateEvent(
+    event = system.CreateTimingEvent("CheatEngine::FrameCallback::" + Common::HexToString(metadata.main_nso_build_id), [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-        "CheatEngine::FrameCallback::" + Common::HexToString(metadata.main_nso_build_id),
+        FrameCallback(ns_late);
-        [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+        return std::nullopt;
-            FrameCallback(ns_late);
+    });
-            return std::nullopt;
-        });
     core_timing.ScheduleLoopingEvent(CHEAT_ENGINE_NS, CHEAT_ENGINE_NS, event);
 
     metadata.process_id = system.ApplicationProcess()->GetProcessId();

src/core/tools/freezer.cpp

@@ -52,14 +52,12 @@ void MemoryWriteWidth(Core::Memory::Memory& memory, u32 width, VAddr addr, u64 v
 
 } // Anonymous namespace
 
-Freezer::Freezer(Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_)
+Freezer::Freezer(Core::System& system_, Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_)
     : core_timing{core_timing_}, memory{memory_} {
-    event = Core::Timing::CreateEvent("MemoryFreezer::FrameCallback",
+    event = system_.CreateTimingEvent("MemoryFreezer::FrameCallback", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-                                      [this](s64 time, std::chrono::nanoseconds ns_late)
+        FrameCallback(ns_late);
-                                          -> std::optional<std::chrono::nanoseconds> {
+        return std::nullopt;
-                                          FrameCallback(ns_late);
+    });
-                                          return std::nullopt;
-                                      });
     core_timing.ScheduleEvent(memory_freezer_ns, event);
 }
 

src/core/tools/freezer.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -11,14 +14,16 @@
 #include <vector>
 #include "common/common_types.h"
 
-namespace Core::Timing {
+namespace Core {
+class System;
+namespace Timing {
 class CoreTiming;
 struct EventType;
 } // namespace Core::Timing
-
+namespace Memory {
-namespace Core::Memory {
 class Memory;
-}
+} //namespace Core::Memory
+} //namespace Core
 
 namespace Tools {
 
@@ -38,7 +43,7 @@ public:
         u64 value;
     };
 
-    explicit Freezer(Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_);
+    explicit Freezer(Core::System& system_, Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_);
     ~Freezer();
 
     // Enables or disables the entire memory freezer.

src/hid_core/resource_manager.cpp

@@ -56,33 +56,22 @@ ResourceManager::ResourceManager(Core::System& system_,
     applet_resource = std::make_shared<AppletResource>(system);
 
     // Register update callbacks
-    npad_update_event = Core::Timing::CreateEvent("HID::UpdatePadCallback",
+    npad_update_event = system.CreateTimingEvent("HID::UpdatePadCallback", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-                                                  [this](s64 time, std::chrono::nanoseconds ns_late)
+        UpdateNpad(ns_late);
-                                                      -> std::optional<std::chrono::nanoseconds> {
+        return std::nullopt;
-                                                      UpdateNpad(ns_late);
+    });
-                                                      return std::nullopt;
+    default_update_event = system.CreateTimingEvent("HID::UpdateDefaultCallback", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-                                                  });
+        UpdateControllers(ns_late);
-    default_update_event = Core::Timing::CreateEvent(
+        return std::nullopt;
-        "HID::UpdateDefaultCallback",
+    });
-        [this](s64 time,
+    mouse_keyboard_update_event = system.CreateTimingEvent("HID::UpdateMouseKeyboardCallback", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+        UpdateMouseKeyboard(ns_late);
-            UpdateControllers(ns_late);
+        return std::nullopt;
-            return std::nullopt;
+    });
-        });
+    motion_update_event = system.CreateTimingEvent("HID::UpdateMotionCallback", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-    mouse_keyboard_update_event = Core::Timing::CreateEvent(
+        UpdateMotion(ns_late);
-        "HID::UpdateMouseKeyboardCallback",
+        return std::nullopt;
-        [this](s64 time,
+    });
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            UpdateMouseKeyboard(ns_late);
-            return std::nullopt;
-        });
-    motion_update_event = Core::Timing::CreateEvent(
-        "HID::UpdateMotionCallback",
-        [this](s64 time,
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            UpdateMotion(ns_late);
-            return std::nullopt;
-        });
 }
 
 ResourceManager::~ResourceManager() {
@@ -267,13 +256,10 @@ void ResourceManager::InitializeTouchScreenSampler() {
     touch_screen = std::make_shared<TouchScreen>(touch_resource);
     gesture = std::make_shared<Gesture>(touch_resource);
 
-    touch_update_event = Core::Timing::CreateEvent(
+    touch_update_event = system.CreateTimingEvent("HID::TouchUpdateCallback", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-        "HID::TouchUpdateCallback",
+        touch_resource->OnTouchUpdate(time);
-        [this](s64 time,
+        return std::nullopt;
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+    });
-            touch_resource->OnTouchUpdate(time);
-            return std::nullopt;
-        });
 
     touch_resource->SetTouchDriver(touch_driver);
     touch_resource->SetAppletResource(applet_resource, &shared_mutex);

src/qt_common/qt_common.cpp

@@ -266,12 +266,7 @@ void Init(QWidget* root) {
              Common::GetMemInfo().TotalPhysicalMemory / f64{1_GiB});
     LOG_INFO(Frontend, "Host Swap: {:.2f} GiB", Common::GetMemInfo().TotalSwapMemory / f64{1_GiB});
 #ifdef _WIN32
-    LOG_INFO(Frontend, "Host Timer Resolution: {:.4f} ms",
+    LOG_INFO(Frontend, "Host Timer Resolution: {:.4f} ms", std::chrono::duration_cast<std::chrono::duration<f64, std::milli>>(Common::Windows::SetCurrentTimerResolutionToMaximum()).count());
-             std::chrono::duration_cast<std::chrono::duration<f64, std::milli>>(
-                 Common::Windows::SetCurrentTimerResolutionToMaximum())
-                 .count());
-    QtCommon::system->CoreTiming().SetTimerResolutionNs(
-        Common::Windows::GetCurrentTimerResolution());
 #endif
 
     // Remove cached contents generated during the previous session

src/tests/core/core_timing.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2016 Dolphin Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -53,14 +56,15 @@ u64 TestTimerSpeed(Core::Timing::CoreTiming& core_timing) {
 } // Anonymous namespace
 
 TEST_CASE("CoreTiming[BasicOrder]", "[core]") {
+    Core::System system{};
     ScopeInit guard;
     auto& core_timing = guard.core_timing;
     std::vector<std::shared_ptr<Core::Timing::EventType>> events{
-        Core::Timing::CreateEvent("callbackA", HostCallbackTemplate<0>),
+        system.CreateTimingEvent("callbackA", HostCallbackTemplate<0>),
-        Core::Timing::CreateEvent("callbackB", HostCallbackTemplate<1>),
+        system.CreateTimingEvent("callbackB", HostCallbackTemplate<1>),
-        Core::Timing::CreateEvent("callbackC", HostCallbackTemplate<2>),
+        system.CreateTimingEvent("callbackC", HostCallbackTemplate<2>),
-        Core::Timing::CreateEvent("callbackD", HostCallbackTemplate<3>),
+        system.CreateTimingEvent("callbackD", HostCallbackTemplate<3>),
-        Core::Timing::CreateEvent("callbackE", HostCallbackTemplate<4>),
+        system.CreateTimingEvent("callbackE", HostCallbackTemplate<4>),
     };
 
     expected_callback = 0;
@@ -93,14 +97,15 @@ TEST_CASE("CoreTiming[BasicOrder]", "[core]") {
 }
 
 TEST_CASE("CoreTiming[BasicOrderNoPausing]", "[core]") {
+    Core::System system{};
     ScopeInit guard;
     auto& core_timing = guard.core_timing;
     std::vector<std::shared_ptr<Core::Timing::EventType>> events{
-        Core::Timing::CreateEvent("callbackA", HostCallbackTemplate<0>),
+        system.CreateTimingEvent("callbackA", HostCallbackTemplate<0>),
-        Core::Timing::CreateEvent("callbackB", HostCallbackTemplate<1>),
+        system.CreateTimingEvent("callbackB", HostCallbackTemplate<1>),
-        Core::Timing::CreateEvent("callbackC", HostCallbackTemplate<2>),
+        system.CreateTimingEvent("callbackC", HostCallbackTemplate<2>),
-        Core::Timing::CreateEvent("callbackD", HostCallbackTemplate<3>),
+        system.CreateTimingEvent("callbackD", HostCallbackTemplate<3>),
-        Core::Timing::CreateEvent("callbackE", HostCallbackTemplate<4>),
+        system.CreateTimingEvent("callbackE", HostCallbackTemplate<4>),
     };
 
     core_timing.SyncPause(true);

src/video_core/host_shaders/block_linear_unswizzle_2d.comp

@@ -11,9 +11,8 @@
 #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
 #define END_PUSH_CONSTANTS };
 #define UNIFORM(n)
-#define BINDING_SWIZZLE_BUFFER 0
+#define BINDING_INPUT_BUFFER 0
-#define BINDING_INPUT_BUFFER 1
+#define BINDING_OUTPUT_IMAGE 1
-#define BINDING_OUTPUT_IMAGE 2
 
 #else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
 
@@ -26,8 +25,7 @@
 #define BEGIN_PUSH_CONSTANTS
 #define END_PUSH_CONSTANTS
 #define UNIFORM(n) layout (location = n) uniform
-#define BINDING_SWIZZLE_BUFFER 0
+#define BINDING_INPUT_BUFFER 0
-#define BINDING_INPUT_BUFFER 1
 #define BINDING_OUTPUT_IMAGE 0
 
 #endif
@@ -43,10 +41,6 @@ UNIFORM(6) uint block_height;
 UNIFORM(7) uint block_height_mask;
 END_PUSH_CONSTANTS
 
-layout(binding = BINDING_SWIZZLE_BUFFER, std430) readonly buffer SwizzleTable {
-    uint swizzle_table[];
-};
-
 #if HAS_EXTENDED_TYPES
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8 { uint8_t u8data[]; };
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16 { uint16_t u16data[]; };
@@ -71,9 +65,19 @@ const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHI
 
 const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1, GOB_SIZE_Y - 1);
 
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
 uint SwizzleOffset(uvec2 pos) {
     pos = pos & SWIZZLE_MASK;
-    return swizzle_table[pos.y * 64 + pos.x];
+    return SwizzleTable(pos.y * 64 + pos.x);
 }
 
 uvec4 ReadTexel(uint offset) {

src/video_core/host_shaders/block_linear_unswizzle_3d.comp

@@ -11,9 +11,8 @@
 #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
 #define END_PUSH_CONSTANTS };
 #define UNIFORM(n)
-#define BINDING_SWIZZLE_BUFFER 0
+#define BINDING_INPUT_BUFFER 0
-#define BINDING_INPUT_BUFFER 1
+#define BINDING_OUTPUT_IMAGE 1
-#define BINDING_OUTPUT_IMAGE 2
 
 #else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
 
@@ -26,8 +25,7 @@
 #define BEGIN_PUSH_CONSTANTS
 #define END_PUSH_CONSTANTS
 #define UNIFORM(n) layout (location = n) uniform
-#define BINDING_SWIZZLE_BUFFER 0
+#define BINDING_INPUT_BUFFER 0
-#define BINDING_INPUT_BUFFER 1
 #define BINDING_OUTPUT_IMAGE 0
 
 #endif
@@ -45,10 +43,6 @@ UNIFORM(8) uint block_depth;
 UNIFORM(9) uint block_depth_mask;
 END_PUSH_CONSTANTS
 
-layout(binding = BINDING_SWIZZLE_BUFFER, std430) readonly buffer SwizzleTable {
-    uint swizzle_table[];
-};
-
 #if HAS_EXTENDED_TYPES
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8 { uint8_t u8data[]; };
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16 { uint16_t u16data[]; };
@@ -73,9 +67,19 @@ const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHI
 
 const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1, GOB_SIZE_Y - 1);
 
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
 uint SwizzleOffset(uvec2 pos) {
     pos = pos & SWIZZLE_MASK;
-    return swizzle_table[pos.y * 64 + pos.x];
+    return SwizzleTable(pos.y * 64 + pos.x);
 }
 
 uvec4 ReadTexel(uint offset) {

src/video_core/host_shaders/block_linear_unswizzle_3d_bcn.comp

@@ -10,9 +10,8 @@
     #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
     #define END_PUSH_CONSTANTS };
     #define UNIFORM(n)
-    #define BINDING_SWIZZLE_BUFFER 0
+    #define BINDING_INPUT_BUFFER   0
-    #define BINDING_INPUT_BUFFER   1
+    #define BINDING_OUTPUT_BUFFER  1
-    #define BINDING_OUTPUT_BUFFER  2
 #else
     #extension GL_NV_gpu_shader5 : enable
     #ifdef GL_NV_gpu_shader5
@@ -23,7 +22,6 @@
     #define BEGIN_PUSH_CONSTANTS
     #define END_PUSH_CONSTANTS
     #define UNIFORM(n) layout(location = n) uniform
-    #define BINDING_SWIZZLE_BUFFER 0
     #define BINDING_INPUT_BUFFER   1
     #define BINDING_OUTPUT_BUFFER  0
 #endif
@@ -66,13 +64,9 @@ END_PUSH_CONSTANTS
 #endif
 
 // --- Buffers ---
-layout(binding = BINDING_SWIZZLE_BUFFER, std430) readonly buffer SwizzleTable {
-    uint swizzle_table[];
-};
-
 #if HAS_EXTENDED_TYPES
-    layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8   { uint8_t  u8data[];  };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8   { uint8_t  u8data[];  };
-    layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16  { uint16_t u16data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16  { uint16_t u16data[]; };
 #endif
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU32  { uint   u32data[];  };
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU64  { uvec2  u64data[];  };
@@ -96,10 +90,20 @@ const uint GOB_SIZE_Z_SHIFT = 0;
 const uint GOB_SIZE_SHIFT   = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHIFT;
 const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
 
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
 // --- Helpers ---
 uint SwizzleOffset(uvec2 pos) {
     pos &= SWIZZLE_MASK;
-    return swizzle_table[pos.y * 64u + pos.x];
+    return SwizzleTable(pos.y * 64u + pos.x);
 }
 
 uvec4 ReadTexel(uint offset) {

src/video_core/renderer_opengl/util_shaders.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -56,10 +59,8 @@ UtilShaders::UtilShaders(ProgramManager& program_manager_)
       copy_bc4_program(MakeProgram(OPENGL_COPY_BC4_COMP)),
       convert_s8d24_program(MakeProgram(OPENGL_CONVERT_S8D24_COMP)),
       convert_ms_to_nonms_program(MakeProgram(CONVERT_MSAA_TO_NON_MSAA_COMP)),
-      convert_nonms_to_ms_program(MakeProgram(CONVERT_NON_MSAA_TO_MSAA_COMP)) {
+      convert_nonms_to_ms_program(MakeProgram(CONVERT_NON_MSAA_TO_MSAA_COMP))
-    const auto swizzle_table = Tegra::Texture::MakeSwizzleTable();
+{
-    swizzle_table_buffer.Create();
-    glNamedBufferStorage(swizzle_table_buffer.handle, sizeof(swizzle_table), &swizzle_table, 0);
 }
 
 UtilShaders::~UtilShaders() = default;
@@ -116,13 +117,11 @@ void UtilShaders::ASTCDecode(Image& image, const StagingBufferMap& map,
 void UtilShaders::BlockLinearUpload2D(Image& image, const StagingBufferMap& map,
                                       std::span<const SwizzleParameters> swizzles) {
     static constexpr Extent3D WORKGROUP_SIZE{32, 32, 1};
-    static constexpr GLuint BINDING_SWIZZLE_BUFFER = 0;
+    static constexpr GLuint BINDING_INPUT_BUFFER = 0;
-    static constexpr GLuint BINDING_INPUT_BUFFER = 1;
     static constexpr GLuint BINDING_OUTPUT_IMAGE = 0;
 
     program_manager.BindComputeProgram(block_linear_unswizzle_2d_program.handle);
     glFlushMappedNamedBufferRange(map.buffer, map.offset, image.guest_size_bytes);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_SWIZZLE_BUFFER, swizzle_table_buffer.handle);
 
     const GLenum store_format = StoreFormat(BytesPerBlock(image.info.format));
     for (const SwizzleParameters& swizzle : swizzles) {
@@ -153,14 +152,11 @@ void UtilShaders::BlockLinearUpload2D(Image& image, const StagingBufferMap& map,
 void UtilShaders::BlockLinearUpload3D(Image& image, const StagingBufferMap& map,
                                       std::span<const SwizzleParameters> swizzles) {
     static constexpr Extent3D WORKGROUP_SIZE{16, 8, 8};
-
+    static constexpr GLuint BINDING_INPUT_BUFFER = 0;
-    static constexpr GLuint BINDING_SWIZZLE_BUFFER = 0;
-    static constexpr GLuint BINDING_INPUT_BUFFER = 1;
     static constexpr GLuint BINDING_OUTPUT_IMAGE = 0;
 
     glFlushMappedNamedBufferRange(map.buffer, map.offset, image.guest_size_bytes);
     program_manager.BindComputeProgram(block_linear_unswizzle_3d_program.handle);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_SWIZZLE_BUFFER, swizzle_table_buffer.handle);
 
     const GLenum store_format = StoreFormat(BytesPerBlock(image.info.format));
     for (const SwizzleParameters& swizzle : swizzles) {

src/video_core/renderer_opengl/util_shaders.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -45,9 +48,6 @@ public:
 
 private:
     ProgramManager& program_manager;
-
-    OGLBuffer swizzle_table_buffer;
-
     OGLProgram astc_decoder_program;
     OGLProgram block_linear_unswizzle_2d_program;
     OGLProgram block_linear_unswizzle_3d_program;

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -653,71 +653,8 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
     scheduler.Finish();
 }
 
-constexpr u32 BL3D_BINDING_SWIZZLE_TABLE = 0;
+constexpr u32 BL3D_BINDING_INPUT_BUFFER  = 0;
-constexpr u32 BL3D_BINDING_INPUT_BUFFER  = 1;
+constexpr u32 BL3D_BINDING_OUTPUT_BUFFER = 1;
-constexpr u32 BL3D_BINDING_OUTPUT_BUFFER = 2;
-
-constexpr std::array<VkDescriptorSetLayoutBinding, 3> BL3D_DESCRIPTOR_SET_BINDINGS{{
-    {
-        .binding = BL3D_BINDING_SWIZZLE_TABLE,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // swizzle_table[]
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-    {
-        .binding = BL3D_BINDING_INPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // block-linear input
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-    {
-        .binding = BL3D_BINDING_OUTPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-}};
-
-constexpr DescriptorBankInfo BL3D_BANK_INFO{
-    .uniform_buffers = 0,
-    .storage_buffers = 3,
-    .texture_buffers = 0,
-    .image_buffers = 0,
-    .textures = 0,
-    .images = 0,
-    .score = 3,
-};
-
-constexpr std::array<VkDescriptorUpdateTemplateEntry, 3>
-    BL3D_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY{{
-        {
-            .dstBinding = BL3D_BINDING_SWIZZLE_TABLE,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = BL3D_BINDING_SWIZZLE_TABLE * sizeof(DescriptorUpdateEntry),
-            .stride = sizeof(DescriptorUpdateEntry),
-        },
-        {
-            .dstBinding = BL3D_BINDING_INPUT_BUFFER,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = BL3D_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-            .stride = sizeof(DescriptorUpdateEntry),
-        },
-        {
-            .dstBinding = BL3D_BINDING_OUTPUT_BUFFER,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = BL3D_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-            .stride = sizeof(DescriptorUpdateEntry),
-        }
-    }};
 
 struct alignas(16) BlockLinearUnswizzle3DPushConstants {
     u32 blocks_dim[3];           // Offset 0
@@ -745,11 +682,50 @@ BlockLinearUnswizzle3DPass::BlockLinearUnswizzle3DPass(
     DescriptorPool& descriptor_pool_,
     StagingBufferPool& staging_buffer_pool_,
     ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
-    : ComputePass(
+    : ComputePass(device_, scheduler_, descriptor_pool_,
-          device_, scheduler_, descriptor_pool_,
+        std::array<VkDescriptorSetLayoutBinding, 2>{{
-          BL3D_DESCRIPTOR_SET_BINDINGS,
+    {
-          BL3D_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY,
+        .binding = BL3D_BINDING_INPUT_BUFFER,
-          BL3D_BANK_INFO,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // block-linear input
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+    {
+        .binding = BL3D_BINDING_OUTPUT_BUFFER,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+        }},
+        std::array<VkDescriptorUpdateTemplateEntry, 2>{{
+        {
+            .dstBinding = BL3D_BINDING_INPUT_BUFFER,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .offset = BL3D_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+            .stride = sizeof(DescriptorUpdateEntry),
+        },
+        {
+            .dstBinding = BL3D_BINDING_OUTPUT_BUFFER,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .offset = BL3D_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+            .stride = sizeof(DescriptorUpdateEntry),
+        }
+        }},
+        DescriptorBankInfo{
+            .uniform_buffers = 0,
+            .storage_buffers = 2,
+            .texture_buffers = 0,
+            .image_buffers = 0,
+            .textures = 0,
+            .images = 0,
+            .score = 2,
+        },
           COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinearUnswizzle3DPushConstants)>,
           BLOCK_LINEAR_UNSWIZZLE_3D_BCN_COMP_SPV),
       scheduler{scheduler_},
@@ -822,8 +798,6 @@ void BlockLinearUnswizzle3DPass::UnswizzleChunk(
     pc.blocks_dim[2] = z_count; // Only process the count
 
     compute_pass_descriptor_queue.Acquire(scheduler, 3);
-    compute_pass_descriptor_queue.AddBuffer(*image.runtime->swizzle_table_buffer, 0,
-                                           image.runtime->swizzle_table_size);
     compute_pass_descriptor_queue.AddBuffer(swizzled.buffer,
                                            sw.buffer_offset + swizzled.offset,
                                            image.guest_size_bytes - sw.buffer_offset);

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -909,40 +909,6 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& sched
         bl3d_unswizzle_pass.emplace(device, scheduler, descriptor_pool,
                                    staging_buffer_pool, compute_pass_descriptor_queue);
     }
-
-    // --- Create swizzle table buffer ---
-    {
-        auto table = Tegra::Texture::MakeSwizzleTable();
-
-        swizzle_table_size = static_cast<VkDeviceSize>(table.size() * sizeof(table[0]));
-
-        auto staging = staging_buffer_pool.Request(swizzle_table_size, MemoryUsage::Upload);
-        std::memcpy(staging.mapped_span.data(), table.data(), static_cast<size_t>(swizzle_table_size));
-
-        VkBufferCreateInfo ci{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .size = swizzle_table_size,
-            .usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
-                     VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                     VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
-            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        };
-        swizzle_table_buffer = memory_allocator.CreateBuffer(ci, MemoryUsage::DeviceLocal);
-
-        scheduler.RequestOutsideRenderPassOperationContext();
-        scheduler.Record([staging_buf = staging.buffer,
-                          dst_buf = *swizzle_table_buffer,
-                          size = swizzle_table_size,
-                          src_off = staging.offset](vk::CommandBuffer cmdbuf) {
-
-            const VkBufferCopy region{
-                .srcOffset = src_off,
-                .dstOffset = 0,
-                .size = size,
-            };
-            cmdbuf.CopyBuffer(staging_buf, dst_buf, region);
-        });
-    }
 }
 
 void TextureCacheRuntime::Finish() {
@@ -2484,18 +2450,13 @@ void TextureCacheRuntime::AccelerateImageUpload(
 
     if (!Settings::values.gpu_unswizzle_enabled.GetValue() || !bl3d_unswizzle_pass) {
         if (IsPixelFormatBCn(image.info.format) && image.info.type == ImageType::e3D) {
-            ASSERT_MSG(false, "GPU unswizzle is disabled for BCn 3D texture");
+            ASSERT(false && "GPU unswizzle is disabled for BCn 3D texture");
         }
         ASSERT(false);
         return;
     }
 
-    if (bl3d_unswizzle_pass &&
+    if (bl3d_unswizzle_pass && IsPixelFormatBCn(image.info.format) && image.info.type == ImageType::e3D && image.info.resources.levels == 1 && image.info.resources.layers == 1) {
-        IsPixelFormatBCn(image.info.format) &&
-        image.info.type == ImageType::e3D &&
-        image.info.resources.levels == 1 &&
-        image.info.resources.layers == 1) {
-
         return bl3d_unswizzle_pass->Unswizzle(image, map, swizzles, z_start, z_count);
     }
 

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -130,9 +130,6 @@ public:
     std::optional<ASTCDecoderPass> astc_decoder_pass;
 
     std::optional<BlockLinearUnswizzle3DPass> bl3d_unswizzle_pass;
-    vk::Buffer swizzle_table_buffer;
-    VkDeviceSize swizzle_table_size = 0;
-
     std::optional<MSAACopyPass> msaa_copy_pass;
     const Settings::ResolutionScalingInfo& resolution;
     std::array<std::vector<VkFormat>, VideoCore::Surface::MaxPixelFormat> view_formats;

src/video_core/textures/decoders.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -23,24 +26,6 @@ constexpr u32 GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_
 constexpr u32 SWIZZLE_X_BITS = 0b100101111;
 constexpr u32 SWIZZLE_Y_BITS = 0b011010000;
 
-using SwizzleTable = std::array<std::array<u32, GOB_SIZE_X>, GOB_SIZE_Y>;
-
-/**
- * This table represents the internal swizzle of a gob, in format 16 bytes x 2 sector packing.
- * Calculates the offset of an (x, y) position within a swizzled texture.
- * Taken from the Tegra X1 Technical Reference Manual. pages 1187-1188
- */
-constexpr SwizzleTable MakeSwizzleTable() {
-    SwizzleTable table{};
-    for (u32 y = 0; y < table.size(); ++y) {
-        for (u32 x = 0; x < table[0].size(); ++x) {
-            table[y][x] = ((x % 64) / 32) * 256 + ((y % 8) / 2) * 64 + ((x % 32) / 16) * 32 +
-                          (y % 2) * 16 + (x % 16);
-        }
-    }
-    return table;
-}
-
 /// Unswizzles a block linear texture into linear memory.
 void UnswizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel,
                       u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth,

src/yuzu_cmd/yuzu.cpp

@@ -371,7 +371,6 @@ int main(int argc, char** argv) {
 
 #ifdef _WIN32
     Common::Windows::SetCurrentTimerResolutionToMaximum();
-    system.CoreTiming().SetTimerResolutionNs(Common::Windows::GetCurrentTimerResolution());
 #endif
 
     system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());