Fast CPU Time & Improved Fast GPU Time (#109)

needs android setting

Signed-off-by: swurl <swurl@swurl.xyz>

Co-authored-by: Aleksandr Popovich <alekpopo@pm.me>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/109
Co-authored-by: swurl <swurl@swurl.xyz>
Co-committed-by: swurl <swurl@swurl.xyz>

src/android/app/build.gradle.kts

@@ -170,7 +170,7 @@ android {
                     "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
                 )
 
-                abiFilters("arm64-v8a", "x86_64")
+                abiFilters("arm64-v8a")
             }
         }
     }

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -12,6 +12,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     FASTMEM_EXCLUSIVES("cpuopt_fastmem_exclusives"),
     CORE_SYNC_CORE_SPEED("sync_core_speed"),
     RENDERER_USE_SPEED_LIMIT("use_speed_limit"),
+    USE_FAST_CPU_TIME("use_fast_cpu_time"),
     USE_DOCKED_MODE("use_docked_mode"),
     USE_AUTO_STUB("use_auto_stub"),
     RENDERER_USE_DISK_SHADER_CACHE("use_disk_shader_cache"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/IntSetting.kt

@@ -35,6 +35,9 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {
     PERF_OVERLAY_POSITION("perf_overlay_position"),
     MEMORY_LAYOUT("memory_layout_mode"),
     FSR_SHARPENING_SLIDER("fsr_sharpening_slider"),
+    FAST_CPU_TIME("fast_cpu_time"),
+    FAST_GPU_TIME("fast_gpu_time"),
+
     CABINET_APPLET("cabinet_applet_mode"),
     CONTROLLER_APPLET("controller_applet_mode"),
     DATA_ERASE_APPLET("data_erase_applet_mode"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -496,6 +496,31 @@ abstract class SettingsItem(
                     descriptionId = R.string.use_fast_gpu_time_description
                 )
             )
+            put(
+                SingleChoiceSetting(
+                    IntSetting.FAST_GPU_TIME,
+                    titleId = R.string.fast_gpu_time,
+                    descriptionId = R.string.fast_gpu_time_description,
+                    choicesId = R.array.gpuEntries,
+                    valuesId = R.array.gpuValues
+                )
+            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.USE_FAST_CPU_TIME,
+                    titleId = R.string.use_fast_cpu_time,
+                    descriptionId = R.string.use_fast_cpu_time_description
+                )
+            )
+            put(
+                SingleChoiceSetting(
+                    IntSetting.FAST_CPU_TIME,
+                    titleId = R.string.fast_cpu_time,
+                    descriptionId = R.string.fast_cpu_time_description,
+                    choicesId = R.array.clockNames,
+                    valuesId = R.array.clockValues
+                )
+            )
             put(
                 SwitchSetting(
                     BooleanSetting.RENDERER_REACTIVE_FLUSHING,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -403,6 +403,7 @@ class SettingsFragmentPresenter(
             add(HeaderSetting(R.string.veil_renderer))
             add(BooleanSetting.FRAME_INTERPOLATION.key)
             add(BooleanSetting.RENDERER_FAST_GPU.key)
+            add(IntSetting.FAST_GPU_TIME.key)
             add(IntSetting.RENDERER_SHADER_BACKEND.key)
             add(IntSetting.RENDERER_NVDEC_EMULATION.key)
             add(IntSetting.RENDERER_ASTC_DECODE_METHOD.key)
@@ -411,6 +412,8 @@ class SettingsFragmentPresenter(
             add(IntSetting.RENDERER_OPTIMIZE_SPIRV_OUTPUT.key)
 
             add(HeaderSetting(R.string.veil_misc))
+            add(BooleanSetting.USE_FAST_CPU_TIME.key)
+            add(IntSetting.FAST_CPU_TIME.key)
             add(BooleanSetting.USE_LRU_CACHE.key)
             add(BooleanSetting.CORE_SYNC_CORE_SPEED.key)
             add(IntSetting.MEMORY_LAYOUT.key)

src/android/app/src/main/res/values/arrays.xml

@@ -33,6 +33,18 @@
         <item>2</item>
     </integer-array>
 
+    <string-array name="clockNames">
+        <item>@string/clock_base</item>
+        <item>@string/clock_boost</item>
+        <item>@string/clock_fast</item>
+    </string-array>
+
+    <integer-array name="clockValues">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+    </integer-array>
+
     <string-array name="languageNames">
         <item>@string/language_brazilian_portuguese</item>
         <item>@string/language_british_english</item>
@@ -441,4 +453,16 @@
         <item>0</item>
         <item>1</item>
     </integer-array>
+
+    <string-array name="gpuEntries">
+        <item>@string/gpu_low</item>
+        <item>@string/gpu_medium</item>
+        <item>@string/gpu_high</item>
+    </string-array>
+
+    <integer-array name="gpuValues">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+    </integer-array>
 </resources>

src/android/app/src/main/res/values/strings.xml

@@ -74,6 +74,10 @@
     <string name="use_sync_core_description">Synchronize the core tick speed to the maximum speed percentage to improve performance without altering the game\'s actual speed.</string>
     <string name="use_lru_cache">Enable LRU Cache</string>
     <string name="use_lru_cache_description">Enable or disable the Least Recently Used (LRU) cache, increasing performance by saving CPU process usage. Some games have issue with it, notably TotK 1.2.1, so disable if the game doesn\'t boot or crashes randomly.</string>
+    <string name="use_fast_cpu_time">Fast CPU Time</string>
+    <string name="use_fast_cpu_time_description">Forces the emulated CPU to run at a higher clock, reducing certain FPS limiters. This option is hacky and may cause issues, and weaker CPUs may see reduced performance.</string>
+    <string name="fast_cpu_time">CPU Clock</string>
+    <string name="fast_cpu_time_description">Use Boost (1700MHz) to run at the Switch\'s highest native clock, or Fast (2000MHz) to run at 2x clock.</string>
     <string name="memory_layout">Memory Layout</string>
     <string name="memory_layout_description">(EXPERIMENTAL) Change the emulated memory layout. This setting will not increase performance, but may help with games utilizing high resolutions via mods. Do not use on phones with 8GB of RAM or less.</string>
 
@@ -408,6 +412,8 @@
     <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
     <string name="use_fast_gpu_time">Use Fast GPU Time</string>
     <string name="use_fast_gpu_time_description">Forces most games to run at their highest native resolution. This option is hacky and may cause issues.</string>
+    <string name="fast_gpu_time">GPU Overclock Factor</string>
+    <string name="fast_gpu_time_description">Use 128 for maximal performance and 512 for maximal graphics fidelity.</string>
     <string name="renderer_reactive_flushing">Use reactive flushing</string>
     <string name="renderer_reactive_flushing_description">Improves rendering accuracy in some games at the cost of performance.</string>
     <string name="use_disk_shader_cache">Disk shader cache</string>
@@ -704,6 +710,16 @@
     <string name="memory_6gb">6GB (Unsafe)</string>
     <string name="memory_8gb">8GB (Unsafe)</string>
 
+<!--    CPU clock speeds-->
+    <string name="clock_base">Base (1000MHz)</string>
+    <string name="clock_boost">Boost (1700MHz)</string>
+    <string name="clock_fast">Fast (2000MHz)</string>
+
+    <!-- GPU overclock factors -->
+    <string name="gpu_low">Low (128)</string>
+    <string name="gpu_medium">Medium (256)</string>
+    <string name="gpu_high">High (512)</string>
+
     <!-- Language Names -->
     <string name="language_japanese" translatable="false">日本語</string>
     <string name="language_english" translatable="false">English</string>

src/common/settings.h

@@ -238,6 +238,23 @@ struct Values {
     SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage,           CpuAccuracy::Auto,
                                                       CpuAccuracy::Auto, CpuAccuracy::Paranoid,
                                                       "cpu_accuracy",    Category::Cpu};
+
+    SwitchableSetting<bool> use_fast_cpu_time{linkage,
+                                              false,
+                                              "use_fast_cpu_time",
+                                              Category::Cpu,
+                                              Specialization::Paired,
+                                              true,
+                                              true};
+    SwitchableSetting<CpuClock> fast_cpu_time{linkage,
+                                              CpuClock::Boost,
+                                              "fast_cpu_time",
+                                              Category::Cpu,
+                                              Specialization::Default,
+                                              true,
+                                              true,
+                                              &use_fast_cpu_time};
+
     SwitchableSetting<bool> cpu_debug_mode{linkage, false, "cpu_debug_mode", Category::CpuDebug};
 
     Setting<bool> cpuopt_page_tables{linkage, true, "cpuopt_page_tables", Category::CpuDebug};
@@ -428,9 +445,23 @@ struct Values {
                                                   Category::RendererAdvanced};
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererAdvanced};
-    SwitchableSetting<bool> use_fast_gpu_time{
-                                              linkage, true, "use_fast_gpu_time", Category::RendererAdvanced, Specialization::Default,
-                                              true,    true};
+    SwitchableSetting<bool> use_fast_gpu_time{linkage,
+                                              true,
+                                              "use_fast_gpu_time",
+                                              Category::RendererAdvanced,
+                                              Specialization::Paired,
+                                              true,
+                                              true};
+
+    SwitchableSetting<GpuOverclock> fast_gpu_time{linkage,
+                                                  GpuOverclock::Medium,
+                                                  "fast_gpu_time",
+                                                  Category::RendererAdvanced,
+                                                  Specialization::Default,
+                                                  true,
+                                                  true,
+                                                  &use_fast_gpu_time};
+
     SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{linkage,
                                                              true,
                                                              "use_vulkan_driver_pipeline_cache",

src/common/settings_enums.h

@@ -134,6 +134,8 @@ ENUM(CpuBackend, Dynarmic, Nce);
 
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid);
 
+ENUM(CpuClock, Boost, Fast)
+
 ENUM(MemoryLayout, Memory_4Gb, Memory_6Gb, Memory_8Gb, Memory_10Gb, Memory_12Gb);
 
 ENUM(ConfirmStop, Ask_Always, Ask_Based_On_Game, Ask_Never);
@@ -157,6 +159,8 @@ ENUM(AppletMode, HLE, LLE);
 
 ENUM(SpirvOptimizeMode, Never, OnLoad, Always);
 
+ENUM(GpuOverclock, Low, Medium, High)
+
 template <typename Type>
 inline std::string CanonicalizeEnum(Type id) {
     const auto group = EnumMetadata<Type>::Canonicalizations();

src/core/core_timing.cpp

@@ -192,13 +192,18 @@ u64 CoreTiming::GetClockTicks() const {
          fres = Common::WallClock::CPUTickToCNTPCT(cpu_ticks);
      }
 
+     if (Settings::values.use_fast_cpu_time) {
+         fres = (u64) ((double) fres
+                       * (1.7 + 0.3 * (u32) Settings::values.fast_cpu_time.GetValue()));
+     }
+
      if (Settings::values.sync_core_speed.GetValue()) {
          const double ticks = static_cast<double>(fres);
          const double speed_limit = static_cast<double>(Settings::values.speed_limit.GetValue())*0.01;
          return static_cast<u64>(ticks/speed_limit);
      } else {
          return fres;
-    }
+     }
 }
 
 u64 CoreTiming::GetGPUTicks() const {

src/video_core/gpu.cpp

@@ -200,7 +200,10 @@ struct GPU::Impl {
         u64 gpu_tick = system.CoreTiming().GetGPUTicks();
 
         if (Settings::values.use_fast_gpu_time.GetValue()) {
-            gpu_tick /= 256;
+            gpu_tick /= (u64) (128
+                               * std::pow(2,
+                                          static_cast<u32>(
+                                              Settings::values.fast_gpu_time.GetValue())));
         }
 
         return gpu_tick;

src/yuzu/configuration/configure_cpu.cpp

@@ -73,6 +73,9 @@ void ConfigureCpu::Setup(const ConfigurationShared::Builder& builder) {
         } else if (setting->Id() == Settings::values.cpu_backend.Id()) {
             backend_layout->addWidget(widget);
             backend_combobox = widget->combobox;
+        } else if (setting->Id() == Settings::values.fast_cpu_time.Id()
+                   || setting->Id() == Settings::values.use_fast_cpu_time.Id()) {
+            ui->general_layout->addWidget(widget);
         } else {
             // Presently, all other settings here are unsafe checkboxes
             unsafe_hold.insert({setting->Id(), widget});

src/yuzu/configuration/configure_cpu.ui

@@ -27,7 +27,7 @@
        <property name="title">
         <string>General</string>
        </property>
-       <layout class="QVBoxLayout">
+       <layout class="QVBoxLayout" name="general_layout">
         <item>
          <widget class="QWidget" name="widget_accuracy" native="true">
           <layout class="QVBoxLayout" name="verticalLayout">
@@ -61,6 +61,9 @@
      </item>
      <item>
       <widget class="QGroupBox" name="backend_group">
+       <property name="visible">
+        <bool>false</bool>
+       </property>
        <property name="title">
         <string>CPU Backend</string>
        </property>
@@ -84,9 +87,6 @@
          </widget>
         </item>
        </layout>
-       <property name="visible">
-        <bool>false</bool>
-       </property>
       </widget>
      </item>
      <item>
@@ -129,10 +129,10 @@
      <item>
       <spacer name="verticalSpacer">
        <property name="orientation">
-        <enum>Qt::Vertical</enum>
+        <enum>Qt::Orientation::Vertical</enum>
        </property>
        <property name="sizeType">
-        <enum>QSizePolicy::Expanding</enum>
+        <enum>QSizePolicy::Policy::Expanding</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>

src/yuzu/configuration/shared_translation.cpp

@@ -3,10 +3,6 @@
 
 #include "yuzu/configuration/shared_translation.h"
 
-#include <map>
-#include <memory>
-#include <tuple>
-#include <utility>
 #include <QCoreApplication>
 #include <QWidget>
 #include "common/settings.h"
@@ -14,14 +10,19 @@
 #include "common/settings_setting.h"
 #include "common/time_zone.h"
 #include "yuzu/uisettings.h"
+#include <map>
+#include <memory>
+#include <tuple>
+#include <utility>
 
 namespace ConfigurationShared {
 
-std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
+std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent)
+{
     std::unique_ptr<TranslationMap> translations = std::make_unique<TranslationMap>();
     const auto& tr = [parent](const char* text) -> QString { return parent->tr(text); };
 
-#define INSERT(SETTINGS, ID, NAME, TOOLTIP)                                                        \
+#define INSERT(SETTINGS, ID, NAME, TOOLTIP) \
     translations->insert(std::pair{SETTINGS::values.ID.Id(), std::pair{(NAME), (TOOLTIP)}})
 
     // A setting can be ignored by giving it a blank name
@@ -54,110 +55,166 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
 
     // Core
     INSERT(
-        Settings, use_multi_core, tr("Multicore CPU Emulation"),
+        Settings,
+        use_multi_core,
+        tr("Multicore CPU Emulation"),
         tr("This option increases CPU emulation thread use from 1 to the Switch’s maximum of 4.\n"
            "This is mainly a debug option and shouldn’t be disabled."));
     INSERT(
-        Settings, memory_layout_mode, tr("Memory Layout"),
+        Settings,
+        memory_layout_mode,
+        tr("Memory Layout"),
         tr("Increases the amount of emulated RAM from the stock 4GB of the retail Switch to the "
            "developer kit's 8/6GB.\nIt’s doesn’t improve stability or performance and is intended "
            "to let big texture mods fit in emulated RAM.\nEnabling it will increase memory "
            "use. It is not recommended to enable unless a specific game with a texture mod needs "
            "it."));
     INSERT(Settings, use_speed_limit, QString(), QString());
-    INSERT(Settings, speed_limit, tr("Limit Speed Percent"),
+    INSERT(Settings,
+           speed_limit,
+           tr("Limit Speed Percent"),
            tr("Controls the game's maximum rendering speed, but it’s up to each game if it runs "
               "faster or not.\n200% for a 30 FPS game is 60 FPS, and for a "
               "60 FPS game it will be 120 FPS.\nDisabling it means unlocking the framerate to the "
               "maximum your PC can reach."));
-    INSERT(Settings, sync_core_speed, tr("Synchronize Core Speed"),
-            tr("Synchronizes CPU core speed with the game's maximum rendering speed to boost FPS without affecting game speed (animations, physics, etc.).\n"
-                 "Compatibility varies by game; many (especially older ones) may not respond well.\n"
-               "Can help reduce stuttering at lower framerates."));
+    INSERT(Settings,
+           sync_core_speed,
+           tr("Synchronize Core Speed"),
+           tr("Synchronizes CPU core speed with the game's maximum rendering speed to boost FPS "
+              "without affecting game speed (animations, physics, etc.).\n"
+              "Compatibility varies by game; many (especially older ones) may not respond well.\n"
+              "Can help reduce stuttering at lower framerates."));
 
     // Cpu
-    INSERT(Settings, cpu_accuracy, tr("Accuracy:"),
+    INSERT(Settings,
+           cpu_accuracy,
+           tr("Accuracy:"),
            tr("This setting controls the accuracy of the emulated CPU.\nDon't change this unless "
               "you know what you are doing."));
     INSERT(Settings, cpu_backend, tr("Backend:"), QString());
 
+    INSERT(Settings, use_fast_cpu_time, QString(), QString());
+    INSERT(Settings,
+           fast_cpu_time,
+           tr("Fast CPU Time"),
+           tr("Overclocks the emulated CPU to remove some FPS limiters. Weaker CPUs may see reduced performance, "
+              "and certain games may behave improperly.\nUse Boost (1700MHz) to run at the Switch's highest native "
+              "clock, or Fast (2000MHz) to run at 2x clock."));
+    INSERT(Settings, cpu_backend, tr("Backend:"), QString());
+
     // Cpu Debug
 
     // Cpu Unsafe
     INSERT(
-        Settings, cpuopt_unsafe_unfuse_fma,
+        Settings,
+        cpuopt_unsafe_unfuse_fma,
         tr("Unfuse FMA (improve performance on CPUs without FMA)"),
         tr("This option improves speed by reducing accuracy of fused-multiply-add instructions on "
            "CPUs without native FMA support."));
     INSERT(
-        Settings, cpuopt_unsafe_reduce_fp_error, tr("Faster FRSQRTE and FRECPE"),
+        Settings,
+        cpuopt_unsafe_reduce_fp_error,
+        tr("Faster FRSQRTE and FRECPE"),
         tr("This option improves the speed of some approximate floating-point functions by using "
            "less accurate native approximations."));
-    INSERT(Settings, cpuopt_unsafe_ignore_standard_fpcr,
+    INSERT(Settings,
+           cpuopt_unsafe_ignore_standard_fpcr,
            tr("Faster ASIMD instructions (32 bits only)"),
            tr("This option improves the speed of 32 bits ASIMD floating-point functions by running "
               "with incorrect rounding modes."));
-    INSERT(Settings, cpuopt_unsafe_inaccurate_nan, tr("Inaccurate NaN handling"),
+    INSERT(Settings,
+           cpuopt_unsafe_inaccurate_nan,
+           tr("Inaccurate NaN handling"),
            tr("This option improves speed by removing NaN checking.\nPlease note this also reduces "
               "accuracy of certain floating-point instructions."));
-    INSERT(Settings, cpuopt_unsafe_fastmem_check, tr("Disable address space checks"),
+    INSERT(Settings,
+           cpuopt_unsafe_fastmem_check,
+           tr("Disable address space checks"),
            tr("This option improves speed by eliminating a safety check before every memory "
               "read/write in guest.\nDisabling it may allow a game to read/write the emulator's "
               "memory."));
     INSERT(
-        Settings, cpuopt_unsafe_ignore_global_monitor, tr("Ignore global monitor"),
+        Settings,
+        cpuopt_unsafe_ignore_global_monitor,
+        tr("Ignore global monitor"),
         tr("This option improves speed by relying only on the semantics of cmpxchg to ensure "
            "safety of exclusive access instructions.\nPlease note this may result in deadlocks and "
            "other race conditions."));
 
     // Renderer
     INSERT(
-        Settings, renderer_backend, tr("API:"),
+        Settings,
+        renderer_backend,
+        tr("API:"),
         tr("Switches between the available graphics APIs.\nVulkan is recommended in most cases."));
-    INSERT(Settings, vulkan_device, tr("Device:"),
+    INSERT(Settings,
+           vulkan_device,
+           tr("Device:"),
            tr("This setting selects the GPU to use with the Vulkan backend."));
-    INSERT(Settings, shader_backend, tr("Shader Backend:"),
+    INSERT(Settings,
+           shader_backend,
+           tr("Shader Backend:"),
            tr("The shader backend to use for the OpenGL renderer.\nGLSL is the fastest in "
               "performance and the best in rendering accuracy.\n"
               "GLASM is a deprecated NVIDIA-only backend that offers much better shader building "
               "performance at the cost of FPS and rendering accuracy.\n"
               "SPIR-V compiles the fastest, but yields poor results on most GPU drivers."));
-    INSERT(Settings, resolution_setup, tr("Resolution:"),
+    INSERT(Settings,
+           resolution_setup,
+           tr("Resolution:"),
            tr("Forces the game to render at a different resolution.\nHigher resolutions require "
               "much more VRAM and bandwidth.\n"
               "Options lower than 1X can cause rendering issues."));
     INSERT(Settings, scaling_filter, tr("Window Adapting Filter:"), QString());
-    INSERT(Settings, fsr_sharpening_slider, tr("FSR Sharpness:"),
+    INSERT(Settings,
+           fsr_sharpening_slider,
+           tr("FSR Sharpness:"),
            tr("Determines how sharpened the image will look while using FSR’s dynamic contrast."));
-    INSERT(Settings, anti_aliasing, tr("Anti-Aliasing Method:"),
+    INSERT(Settings,
+           anti_aliasing,
+           tr("Anti-Aliasing Method:"),
            tr("The anti-aliasing method to use.\nSMAA offers the best quality.\nFXAA has a "
               "lower performance impact and can produce a better and more stable picture under "
               "very low resolutions."));
-    INSERT(Settings, fullscreen_mode, tr("Fullscreen Mode:"),
+    INSERT(Settings,
+           fullscreen_mode,
+           tr("Fullscreen Mode:"),
            tr("The method used to render the window in fullscreen.\nBorderless offers the best "
               "compatibility with the on-screen keyboard that some games request for "
               "input.\nExclusive "
               "fullscreen may offer better performance and better Freesync/Gsync support."));
-    INSERT(Settings, aspect_ratio, tr("Aspect Ratio:"),
+    INSERT(Settings,
+           aspect_ratio,
+           tr("Aspect Ratio:"),
            tr("Stretches the game to fit the specified aspect ratio.\nSwitch games only support "
               "16:9, so custom game mods are required to get other ratios.\nAlso controls the "
               "aspect ratio of captured screenshots."));
-    INSERT(Settings, use_disk_shader_cache, tr("Use disk pipeline cache"),
+    INSERT(Settings,
+           use_disk_shader_cache,
+           tr("Use disk pipeline cache"),
            tr("Allows saving shaders to storage for faster loading on following game "
               "boots.\nDisabling "
               "it is only intended for debugging."));
-    INSERT(Settings, optimize_spirv_output, tr("Optimize SPIRV output shader"),
-            tr("Runs an additional optimization pass over generated SPIRV shaders.\n"
-                 "Will increase time required for shader compilation.\nMay slightly improve "
-                 "performance.\nThis feature is experimental."));
+    INSERT(Settings,
+           optimize_spirv_output,
+           tr("Optimize SPIRV output shader"),
+           tr("Runs an additional optimization pass over generated SPIRV shaders.\n"
+              "Will increase time required for shader compilation.\nMay slightly improve "
+              "performance.\nThis feature is experimental."));
     INSERT(
-        Settings, use_asynchronous_gpu_emulation, tr("Use asynchronous GPU emulation"),
+        Settings,
+        use_asynchronous_gpu_emulation,
+        tr("Use asynchronous GPU emulation"),
         tr("Uses an extra CPU thread for rendering.\nThis option should always remain enabled."));
-    INSERT(Settings, nvdec_emulation, tr("NVDEC emulation:"),
+    INSERT(Settings,
+           nvdec_emulation,
+           tr("NVDEC emulation:"),
            tr("Specifies how videos should be decoded.\nIt can either use the CPU or the GPU for "
               "decoding, or perform no decoding at all (black screen on videos).\n"
               "In most cases, GPU decoding provides the best performance."));
-    INSERT(Settings, accelerate_astc, tr("ASTC Decoding Method:"),
+    INSERT(Settings,
+           accelerate_astc,
+           tr("ASTC Decoding Method:"),
            tr("This option controls how ASTC textures should be decoded.\n"
               "CPU: Use the CPU for decoding, slowest but safest method.\n"
               "GPU: Use the GPU's compute shaders to decode ASTC textures, recommended for most "
@@ -166,18 +223,24 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
               "eliminates ASTC decoding\nstuttering at the cost of rendering issues while the "
               "texture is being decoded."));
     INSERT(
-        Settings, astc_recompression, tr("ASTC Recompression Method:"),
+        Settings,
+        astc_recompression,
+        tr("ASTC Recompression Method:"),
         tr("Almost all desktop and laptop dedicated GPUs lack support for ASTC textures, forcing "
            "the emulator to decompress to an intermediate format any card supports, RGBA8.\n"
            "This option recompresses RGBA8 to either the BC1 or BC3 format, saving VRAM but "
            "negatively affecting image quality."));
-    INSERT(Settings, vram_usage_mode, tr("VRAM Usage Mode:"),
+    INSERT(Settings,
+           vram_usage_mode,
+           tr("VRAM Usage Mode:"),
            tr("Selects whether the emulator should prefer to conserve memory or make maximum usage "
               "of available video memory for performance. Has no effect on integrated graphics. "
               "Aggressive mode may severely impact the performance of other applications such as "
               "recording software."));
     INSERT(
-        Settings, vsync_mode, tr("VSync Mode:"),
+        Settings,
+        vsync_mode,
+        tr("VSync Mode:"),
         tr("FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen "
            "refresh rate.\nFIFO Relaxed is similar to FIFO but allows tearing as it recovers from "
            "a slow down.\nMailbox can have lower latency than FIFO and does not tear but may drop "
@@ -188,81 +251,121 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
     INSERT(Settings, bg_blue, QString(), QString());
 
     // Renderer (Advanced Graphics)
-    INSERT(Settings, async_presentation, tr("Enable asynchronous presentation (Vulkan only)"),
+    INSERT(Settings,
+           async_presentation,
+           tr("Enable asynchronous presentation (Vulkan only)"),
            tr("Slightly improves performance by moving presentation to a separate CPU thread."));
     INSERT(
-        Settings, renderer_force_max_clock, tr("Force maximum clocks (Vulkan only)"),
+        Settings,
+        renderer_force_max_clock,
+        tr("Force maximum clocks (Vulkan only)"),
         tr("Runs work in the background while waiting for graphics commands to keep the GPU from "
            "lowering its clock speed."));
-    INSERT(Settings, max_anisotropy, tr("Anisotropic Filtering:"),
+    INSERT(Settings,
+           max_anisotropy,
+           tr("Anisotropic Filtering:"),
            tr("Controls the quality of texture rendering at oblique angles.\nIt’s a light setting "
               "and safe to set at 16x on most GPUs."));
-    INSERT(Settings, gpu_accuracy, tr("Accuracy Level:"),
+    INSERT(Settings,
+           gpu_accuracy,
+           tr("Accuracy Level:"),
            tr("GPU emulation accuracy.\nMost games render fine with Normal, but High is still "
               "required for some.\nParticles tend to only render correctly with High "
               "accuracy.\nExtreme should only be used for debugging.\nThis option can "
               "be changed while playing.\nSome games may require booting on high to render "
               "properly."));
-    INSERT(Settings, use_asynchronous_shaders, tr("Use asynchronous shader building (Hack)"),
+    INSERT(Settings,
+           use_asynchronous_shaders,
+           tr("Use asynchronous shader building (Hack)"),
            tr("Enables asynchronous shader compilation, which may reduce shader stutter.\nThis "
               "feature "
               "is experimental."));
-    INSERT(Settings, use_fast_gpu_time, tr("Use Fast GPU Time (Hack)"),
-           tr("Enables Fast GPU Time. This option will force most games to run at their highest "
-              "native resolution."));
-    INSERT(Settings, use_vulkan_driver_pipeline_cache, tr("Use Vulkan pipeline cache"),
+    INSERT(Settings, use_fast_gpu_time, QString(), QString());
+    INSERT(Settings,
+           fast_gpu_time,
+           tr("Fast GPU Time (Hack)"),
+           tr("Overclocks the emulated GPU to increase dynamic resolution and render "
+              "distance.\nUse 128 for maximal performance and 512 for maximal graphics fidelity."));
+
+    INSERT(Settings,
+           use_vulkan_driver_pipeline_cache,
+           tr("Use Vulkan pipeline cache"),
            tr("Enables GPU vendor-specific pipeline cache.\nThis option can improve shader loading "
               "time significantly in cases where the Vulkan driver does not store pipeline cache "
               "files internally."));
     INSERT(
-        Settings, enable_compute_pipelines, tr("Enable Compute Pipelines (Intel Vulkan Only)"),
+        Settings,
+        enable_compute_pipelines,
+        tr("Enable Compute Pipelines (Intel Vulkan Only)"),
         tr("Enable compute pipelines, required by some games.\nThis setting only exists for Intel "
            "proprietary drivers, and may crash if enabled.\nCompute pipelines are always enabled "
            "on all other drivers."));
     INSERT(
-        Settings, use_reactive_flushing, tr("Enable Reactive Flushing"),
+        Settings,
+        use_reactive_flushing,
+        tr("Enable Reactive Flushing"),
         tr("Uses reactive flushing instead of predictive flushing, allowing more accurate memory "
            "syncing."));
-    INSERT(Settings, use_video_framerate, tr("Sync to framerate of video playback"),
+    INSERT(Settings,
+           use_video_framerate,
+           tr("Sync to framerate of video playback"),
            tr("Run the game at normal speed during video playback, even when the framerate is "
               "unlocked."));
-    INSERT(Settings, barrier_feedback_loops, tr("Barrier feedback loops"),
+    INSERT(Settings,
+           barrier_feedback_loops,
+           tr("Barrier feedback loops"),
            tr("Improves rendering of transparency effects in specific games."));
 
     // Renderer (Extensions)
-    INSERT(Settings, dyna_state, tr("Extended Dynamic State"),
-           tr("Enables the VkExtendedDynamicState* extensions.\nHigher dynamic states will generally improve "
+    INSERT(Settings,
+           dyna_state,
+           tr("Extended Dynamic State"),
+           tr("Enables the VkExtendedDynamicState* extensions.\nHigher dynamic states will "
+              "generally improve "
               "performance, but may cause issues on certain games or devices."));
 
-    INSERT(Settings, provoking_vertex, tr("Provoking Vertex"),
+    INSERT(Settings,
+           provoking_vertex,
+           tr("Provoking Vertex"),
            tr("Improves lighting and vertex handling in certain games.\n"
               "Only Vulkan 1.0+ devices support this extension."));
 
-    INSERT(Settings, descriptor_indexing, tr("Descriptor Indexing"),
+    INSERT(Settings,
+           descriptor_indexing,
+           tr("Descriptor Indexing"),
            tr("Improves texture & buffer handling and the Maxwell translation layer.\n"
               "Some Vulkan 1.1+ and all 1.2+ devices support this extension."));
 
     // Renderer (Debug)
 
     // System
-    INSERT(Settings, rng_seed, tr("RNG Seed"),
+    INSERT(Settings,
+           rng_seed,
+           tr("RNG Seed"),
            tr("Controls the seed of the random number generator.\nMainly used for speedrunning "
               "purposes."));
     INSERT(Settings, rng_seed_enabled, QString(), QString());
     INSERT(Settings, device_name, tr("Device Name"), tr("The name of the emulated Switch."));
-    INSERT(Settings, custom_rtc, tr("Custom RTC Date:"),
+    INSERT(Settings,
+           custom_rtc,
+           tr("Custom RTC Date:"),
            tr("This option allows to change the emulated clock of the Switch.\n"
               "Can be used to manipulate time in games."));
     INSERT(Settings, custom_rtc_enabled, QString(), QString());
-    INSERT(Settings, custom_rtc_offset, QStringLiteral(" "),
+    INSERT(Settings,
+           custom_rtc_offset,
+           QStringLiteral(" "),
            QStringLiteral("The number of seconds from the current unix time"));
-    INSERT(Settings, language_index, tr("Language:"),
+    INSERT(Settings,
+           language_index,
+           tr("Language:"),
            tr("Note: this can be overridden when region setting is auto-select"));
     INSERT(Settings, region_index, tr("Region:"), tr("The region of the emulated Switch."));
-    INSERT(Settings, time_zone_index, tr("Time Zone:"),
-           tr("The time zone of the emulated Switch."));
+    INSERT(Settings, time_zone_index, tr("Time Zone:"), tr("The time zone of the emulated Switch."));
     INSERT(Settings, sound_index, tr("Sound Output Mode:"), QString());
-    INSERT(Settings, use_docked_mode, tr("Console Mode:"),
+    INSERT(Settings,
+           use_docked_mode,
+           tr("Console Mode:"),
            tr("Selects if the console is emulated in Docked or Handheld mode.\nGames will change "
               "their resolution, details and supported controllers and depending on this setting.\n"
               "Setting to Handheld can help improve performance for low end systems."));
@@ -283,17 +386,27 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
     // Ui
 
     // Ui General
-    INSERT(UISettings, select_user_on_boot, tr("Prompt for user on game boot"),
+    INSERT(UISettings,
+           select_user_on_boot,
+           tr("Prompt for user on game boot"),
            tr("Ask to select a user profile on each boot, useful if multiple people use eden on "
               "the same PC."));
-    INSERT(UISettings, pause_when_in_background, tr("Pause emulation when in background"),
+    INSERT(UISettings,
+           pause_when_in_background,
+           tr("Pause emulation when in background"),
            tr("This setting pauses eden when focusing other windows."));
-    INSERT(UISettings, confirm_before_stopping, tr("Confirm before stopping emulation"),
+    INSERT(UISettings,
+           confirm_before_stopping,
+           tr("Confirm before stopping emulation"),
            tr("This setting overrides game prompts asking to confirm stopping the game.\nEnabling "
               "it bypasses such prompts and directly exits the emulation."));
-    INSERT(UISettings, hide_mouse, tr("Hide mouse on inactivity"),
+    INSERT(UISettings,
+           hide_mouse,
+           tr("Hide mouse on inactivity"),
            tr("This setting hides the mouse after 2.5s of inactivity."));
-    INSERT(UISettings, controller_applet_disabled, tr("Disable controller applet"),
+    INSERT(UISettings,
+           controller_applet_disabled,
+           tr("Disable controller applet"),
            tr("Forcibly disables the use of the controller applet by guests.\nWhen a guest "
               "attempts to open the controller applet, it is immediately closed."));
     INSERT(UISettings,
@@ -315,9 +428,9 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
     return translations;
 }
 
-std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent) {
-    std::unique_ptr<ComboboxTranslationMap> translations =
-        std::make_unique<ComboboxTranslationMap>();
+std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent)
+{
+    std::unique_ptr<ComboboxTranslationMap> translations = std::make_unique<ComboboxTranslationMap>();
     const auto& tr = [&](const char* text, const char* context = "") {
         return parent->tr(text, context);
     };
@@ -331,11 +444,11 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent) {
                               PAIR(AppletMode, LLE, tr("Real applet")),
                           }});
     translations->insert({Settings::EnumMetadata<Settings::SpirvOptimizeMode>::Index(),
-                           {
-                               PAIR(SpirvOptimizeMode, Never, tr("Never")),
-                               PAIR(SpirvOptimizeMode, OnLoad, tr("On Load")),
-                               PAIR(SpirvOptimizeMode, Always, tr("Always")),
-                           }});
+                          {
+                              PAIR(SpirvOptimizeMode, Never, tr("Never")),
+                              PAIR(SpirvOptimizeMode, OnLoad, tr("On Load")),
+                              PAIR(SpirvOptimizeMode, Always, tr("Always")),
+                          }});
     translations->insert({Settings::EnumMetadata<Settings::AstcDecodeMode>::Index(),
                           {
                               PAIR(AstcDecodeMode, Cpu, tr("CPU")),
@@ -552,6 +665,11 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent) {
                               PAIR(ConsoleMode, Docked, tr("Docked")),
                               PAIR(ConsoleMode, Handheld, tr("Handheld")),
                           }});
+    translations->insert({Settings::EnumMetadata<Settings::CpuClock>::Index(),
+                          {
+                              PAIR(CpuClock, Boost, tr("Boost (1700MHz")),
+                              PAIR(CpuClock, Fast, tr("Fast (2000MHz)")),
+                          }});
     translations->insert(
         {Settings::EnumMetadata<Settings::ConfirmStop>::Index(),
          {
@@ -559,6 +677,12 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent) {
              PAIR(ConfirmStop, Ask_Based_On_Game, tr("Only if game specifies not to stop")),
              PAIR(ConfirmStop, Ask_Never, tr("Never ask")),
          }});
+    translations->insert({Settings::EnumMetadata<Settings::GpuOverclock>::Index(),
+                          {
+                              PAIR(GpuOverclock, Low, tr("Low (128)")),
+                              PAIR(GpuOverclock, Medium, tr("Medium (256)")),
+                              PAIR(GpuOverclock, High, tr("High (512)")),
+                          }});
 
 #undef PAIR
 #undef CTX_PAIR