diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp
index 28a8a5ff..b5dd65d1 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp
@@ -35,10 +35,8 @@ volatile CustomizeTable C = {
 /* Disables RAM powerdown */
 .hpMode = DISABLED,
 
-.commonEmcMemVolt   = 1175000, /* LPDDR4(X) JEDEC Specification */
-.eristaEmcMaxClock  = 1600000, /* Maximum HB-MGCH ram rating */
-.eristaEmcMaxClock1 = 1600000,
-.eristaEmcMaxClock2 = 1600000,
+.commonEmcMemVolt  = 1175000, /* LPDDR4(X) JEDEC Specification */
+.eristaEmcMaxClock = 1600000, /* Maximum HB-MGCH ram rating */
 
 /* Available: 66MHz step rate, 100MHz step rate, 133MHz step rate and jedec. */
 /* Jedec freqs are 1333MHz, 1600MHz, 1866MHz, 2133MHz, 2400MHz, 2666MHz, 2933MHz, 3200MHz. */
@@ -84,24 +82,6 @@ volatile CustomizeTable C = {
     /* 2133 */ 0,
 },
 
-/* You can mix and match different latencies if needed */
-/*
- * Read:
- *  2133RL = 40
- *  1866RL = 36
- *  1600RL = 32
- *  1331RL = 28
- * Write:
- *  2133WL = 18
- *  1866WL = 16
- *  1600WL = 14
- *  1331WL = 12
- */
-
-/* Erista only. */
-.mem_burst_read_latency  = RL_1600,
-.mem_burst_write_latency = WL_1600,
-
 .eristaCpuUV      = 0,
 .eristaCpuVmin    = 800,
 .eristaCpuMaxVolt = 1200,
@@ -140,9 +120,6 @@ volatile CustomizeTable C = {
 
 .commonGpuVoltOffset = 0,
 
-/* Speedo is automatically set by hoc-clk on first boot */
-.gpuSpeedo = 1450,
-
 /* Setting DEACTIVATED_GPU_FREQ on any freq will disable it and all freqs greater than it. (the latter is a bug :/) */
 /* AUTO: Voltage is optimally chosen; with commonGpuVoltOffset applied. */
 /* AUTO only works up to 1305 GPU on Mariko and 998 GPU on Erista (it is reccomended to manually set your 998MHz voltage though) */
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp b/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp
index 83ad1600..4775c3f9 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp
@@ -70,8 +70,7 @@ struct CustomizeTable {
 
     u32 commonEmcMemVolt;
     u32 eristaEmcMaxClock;
-    u32 eristaEmcMaxClock1;
-    u32 eristaEmcMaxClock2;
+    u32 reserved1[2];
 
     StepMode stepMode;
     u32 marikoEmcMaxClock;
@@ -97,8 +96,7 @@ struct CustomizeTable {
     u32 readLatency[4];
     u32 writeLatency[4];
 
-    u32 mem_burst_read_latency;
-    u32 mem_burst_write_latency;
+    u32 reserved2[2];
 
     u32 eristaCpuUV;
     u32 eristaCpuVmin;
@@ -125,7 +123,7 @@ struct CustomizeTable {
 
     u32 commonGpuVoltOffset;
 
-    u32 gpuSpeedo;
+    u32 reserved3;
 
     u32 eristaGpuVoltArray[27];
     u32 marikoGpuVoltArray[24];
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/erista/calculate_timings_erista.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/erista/calculate_timings_erista.cpp
index f83186ee..74e0cb91 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/erista/calculate_timings_erista.cpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/erista/calculate_timings_erista.cpp
@@ -18,8 +18,80 @@
 
 namespace ams::ldr::hoc::pcv::erista {
 
-    void CalculateTimings(double tCK_avg) {
-        tR2W    = FLOOR(FLOOR((5.0 / tCK_avg) + ((FLOOR(48.0 / WL) - 0.478) * 3.0)) / 1.501) + RL - (C.t6_tRTW * 3) + finetRTW;
+    void SwitchLatency(volatile u32 &latency, u32 index, u32 latencyStep) {
+        latency += index * latencyStep;
+    }
+
+    static s32 GetMaxLatencyIndex(volatile u32 *latencyArray, u32 latencySize) {
+        s32 maxIndex = -1;
+        for (u32 i = 0; i < latencySize; ++i) {
+            if (latencyArray[i]) {
+                maxIndex = i;
+            }
+        }
+
+        return maxIndex;
+    }
+
+    void AutoLatency(volatile u32 &latency, u32 freq, u32 latencyStep) {
+        if (freq > 1600'000 && freq <= 1866'000) { /* 1866tRWL */
+            latency += latencyStep * 2;
+        } else { /* 2133tRWL */
+            latency += latencyStep * 3;
+        }
+    }
+
+    void HandleLatency(u32 freq, volatile u32 &latency, volatile u32 *latencyArray, u32 indexMax, u32 latencyStep) {
+        for (u32 i = 0; i <= indexMax; ++i) {
+            if (latencyArray[i] != 0 && freq <= latencyArray[i]) {
+                SwitchLatency(latency, i, latencyStep);
+                return;
+            }
+        }
+
+        SwitchLatency(latency, indexMax, latencyStep);
+    }
+
+    void HandleLatency(u32 freq) {
+        static s32 rlIndexMax = GetMaxLatencyIndex(C.readLatency, std::size(C.readLatency));
+        static s32 wlIndexMax = GetMaxLatencyIndex(C.writeLatency, std::size(C.writeLatency));
+        constexpr u32 ReadLatencyStep  = 4;
+        constexpr u32 WriteLatencyStep = 2;
+        bool autoLatencyRead = false, autoLatencyWrite = false;
+
+        if (rlIndexMax == -1) {
+            AutoLatency(RL, freq, ReadLatencyStep);
+            autoLatencyRead = true;
+        }
+
+        if (wlIndexMax == -1) {
+            AutoLatency(WL, freq, WriteLatencyStep);
+            autoLatencyWrite = true;
+        }
+
+        if (autoLatencyRead && autoLatencyWrite) {
+            return;
+        }
+
+        if (!autoLatencyRead) {
+            HandleLatency(freq, RL, C.readLatency, rlIndexMax, ReadLatencyStep);
+        }
+
+        if (!autoLatencyWrite) {
+            HandleLatency(freq, WL, C.writeLatency, wlIndexMax, WriteLatencyStep);
+        }
+    }
+
+    void CalculateTimings(double tCK_avg, u32 freq) {
+        RL = RL_1331;
+        WL = WL_1331;
+
+        HandleLatency(freq);
+
+        tR2P = CEIL((RL * 0.426) - 2.0);
+        tR2W = FLOOR(FLOOR((5.0 / tCK_avg) + ((FLOOR(48.0 / WL) - 0.478) * 3.0)) / 1.501) + RL - (C.t6_tRTW * 3) + finetRTW;
+
+        tW2P    = (CEIL(WL * 1.7303) * 2) - 5;
         tWTPDEN = CEIL(((1.803 / tCK_avg) + MAX(RL + (2.694 / tCK_avg), static_cast<double>(tW2P))) + (BL / 2));
         tW2R    = FLOOR(MAX((5.020 / tCK_avg) + 1.130, WL - MAX(-CEIL(0.258 * (WL - RL)), 1.964)) * 1.964) + WL - CEIL(tWTR / tCK_avg) + finetWTR;
 
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/erista/calculate_timings_erista.hpp b/Source/Atmosphere/stratosphere/loader/source/oc/erista/calculate_timings_erista.hpp
index 3a58c83a..7a61386d 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/erista/calculate_timings_erista.hpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/erista/calculate_timings_erista.hpp
@@ -18,6 +18,6 @@
 
 namespace ams::ldr::hoc::pcv::erista {
 
-    void CalculateTimings(double tCK_avg);
+    void CalculateTimings(double tCK_avg, u32 freq);
 
 }
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/mariko/calculate_timings.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/mariko/calculate_timings.cpp
index fca368d8..d03feafa 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/mariko/calculate_timings.cpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/mariko/calculate_timings.cpp
@@ -46,7 +46,7 @@ namespace ams::ldr::hoc::pcv::mariko {
     }
 
     void AutoLatency(volatile u32 &latency, u32 freq, u32 latencyStep) {
-        if (freq > 1600'000 && freq <= 1866'000) { /* 1866tRWL */
+        if (freq > 1600'000 && freq <= 1862'400) { /* 1866tRWL */
             latency += latencyStep * 2;
         } else { /* 2133tRWL */
             latency += latencyStep * 3;
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/mtc_timing_value.hpp b/Source/Atmosphere/stratosphere/loader/source/oc/mtc_timing_value.hpp
index 1b592f0e..15da084e 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/mtc_timing_value.hpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/mtc_timing_value.hpp
@@ -33,10 +33,6 @@ namespace ams::ldr::hoc {
     /* Burst latency, not to be confused with base latency (tWRL). */
     const u32 BL = 16;
 
-    /* Base latency for read and write (tWRL). */
-    const u32 RL = C.mem_burst_read_latency;
-    const u32 WL = C.mem_burst_write_latency;
-
     /* Precharge to Precharge Delay. (tCK) */
     const u32 tPPD = 4;
 
@@ -87,11 +83,14 @@ namespace ams::ldr::hoc {
         const u32 tFAW     = static_cast<u32>(tRRD * 4.0);
         const double tRPab = tRPpb + 3;
 
-        const u32 tR2P   = CEIL((RL * 0.426) - 2.0);
+        inline u32 RL;
+        inline u32 WL;
+
+        inline u32 tR2P;
         inline u32 tR2W;
         inline u32 rext;
 
-        const u32 tW2P = (CEIL(WL * 1.7303) * 2) - 5;
+        inline u32 tW2P;
         inline u32 tWTPDEN;
         inline u32 tW2R;
 
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp
index a34c2dd6..8e8ae163 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp
@@ -147,7 +147,7 @@ namespace ams::ldr::hoc::pcv {
             { eristaCpuDvfsMaxFreq,                 1785'000, 2397'000, panic::Cpu,      },
             { marikoCpuDvfsMaxFreq,                 1785'000, 2703'000, panic::Cpu,      },
             { C.commonEmcMemVolt,                    912'500, 1350'000, panic::Emc,      }, /* Official vmax for the RAMs is 1400-1500mV */
-            { GET_MAX_OF_ARR(erista::maxEmcClocks), 1600'000, 2600'000, panic::Emc,      },
+            { C.eristaEmcMaxClock,                  1600'000, 2600'000, panic::Emc,      },
             { C.marikoEmcMaxClock,                  1600'000, 3500'000, panic::Emc,      },
             { C.marikoEmcVddqVolt,                   400'000,  750'000, panic::Emc,      },
             { C.marikoSocVmax,                          1000,     1200, panic::Emc,      },
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.cpp
index 85ef4de2..4c0e9a0e 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.cpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.cpp
@@ -18,6 +18,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <vector>
 #include "pcv.hpp"
 #include "../mtc_timing_value.hpp"
 #include "../erista/calculate_timings_erista.hpp"
@@ -215,7 +216,7 @@ namespace ams::ldr::hoc::pcv::erista {
 
         const u32 dyn_self_ref_control = (static_cast<u32>(7605.0 / tCK_avg) + 260) | (table->burst_regs.emc_dyn_self_ref_control & 0xffff0000);
 
-        CalculateTimings(tCK_avg);
+        CalculateTimings(tCK_avg, table->rate_khz);
 
         WRITE_PARAM_ALL_REG(table, emc_rd_rcd, GET_CYCLE_CEIL(tRCD));
         WRITE_PARAM_ALL_REG(table, emc_wr_rcd, GET_CYCLE_CEIL(tRCD));
@@ -360,65 +361,176 @@ namespace ams::ldr::hoc::pcv::erista {
         table->min_volt           = std::clamp(900 + (C.emcDvbShift * 25), 900, 1050);
     }
 
-    /* Probably more intuitive to point to 40800 rather than 1600000, but oh well. */
-    Result MemFreqMtcTable(u32 *ptr) {
-        u32 khz_list[] = { 40800, 68000, 102000, 204000, 408000, 665600, 800000, 1065600, 1331200, 1600000 };
-        std::sort(maxEmcClocks, maxEmcClocks + std::size(maxEmcClocks));
-        u32 khz_list_size = std::size(khz_list);
+    namespace {
+        std::vector<u32> newEmcList;
+        u32 *nsoStart;
+    }
 
-        // Generate list for mtc table pointers
-        EristaMtcTable *table_list[khz_list_size];
-        for (u32 i = 0; i < khz_list_size; i++) {
-            u32 mtcIndex = khz_list_size - 1 - i;
-            u8 *table = reinterpret_cast<u8 *>(ptr) - offsetof(EristaMtcTable, rate_khz) - i * sizeof(EristaMtcTable);
-            table_list[mtcIndex] = reinterpret_cast<EristaMtcTable *>(table);
-            R_UNLESS(table_list[mtcIndex]->rate_khz == khz_list[mtcIndex], ldr::ResultInvalidMtcTable());
-            R_UNLESS(table_list[mtcIndex]->rev == MTC_TABLE_REV, ldr::ResultInvalidMtcTable());
+    /* The silicon instructs; the children obey... */
+    void MtcGenerateFreqTables() {
+        newEmcList.clear();
+        newEmcList.reserve(DvfsTableEntryCount);
+        newEmcList.insert(newEmcList.end(), std::begin(EmcListDefault), std::end(EmcListDefault));
+
+        if (C.eristaEmcMaxClock <= EmcClkOSLimit) {
+            return;
         }
 
-        if (GET_MAX_OF_ARR(maxEmcClocks) <= EmcClkOSLimit) {
+        /* This is scuffed, but Eristas step rate is... weird? */
+        /* 1766MHz seems to cause crashes with other freqs near it... why is anyones guess... */
+        u32 freqsLow[]                = { 1633000, 1666000, 1700000, 1733000, 1800000, 1833000, 1862400, };
+        constexpr size_t freqsLowSize = std::size(freqsLow);
+
+        for (size_t i = 0; i < freqsLowSize; ++i) {
+            if (freqsLow[i] <= C.eristaEmcMaxClock) {
+                newEmcList.push_back(freqsLow[i]);
+            } else {
+                break;
+            }
+        }
+
+        if (C.eristaEmcMaxClock <= freqsLow[freqsLowSize - 1]) {
+            return;
+        }
+
+        /* High range. */
+        constexpr u32 StepRate = 38400;
+        while (newEmcList.back() + StepRate < C.eristaEmcMaxClock) {
+            newEmcList.push_back(newEmcList.back() + StepRate);
+        }
+
+        if (newEmcList.back() != C.eristaEmcMaxClock) {
+            newEmcList.push_back(static_cast<u32>(C.eristaEmcMaxClock));
+        }
+
+        constexpr u32 PllmToggleFrequency = 19200;
+
+        /* A step of 19.2khz will cause hangs, crashes and other weirdness. */
+        /* Why? ¯\_(ツ)_/¯ */
+        if (C.eristaEmcMaxClock - newEmcList[newEmcList.size() - 2] <= PllmToggleFrequency) {
+            newEmcList.erase(newEmcList.begin() + newEmcList.size() - 2);
+        }
+
+        newEmcList.resize(std::min(newEmcList.size(), DvfsTableEntryLimit));
+    }
+
+    /* TODO: Template this */
+    Result VerifyMtcTable(EristaMtcTable *tableStart, u32 expectedFreq) {
+        R_UNLESS(tableStart->rate_khz == expectedFreq,  ldr::ResultInvalidMtcTable());
+        R_UNLESS(tableStart->rev      == MTC_TABLE_REV, ldr::ResultInvalidMtcTable());
+
+        R_SUCCEED();
+    }
+
+    /* TODO: Template this */
+    Result MtcValidateAllTables(EristaMtcTable *tableStart, const u32 *validationList, u32 tableCount) {
+        for (u32 i = 0; i < tableCount; ++i) {
+            R_TRY(VerifyMtcTable(&tableStart[i], validationList[i]));
+        }
+
+        R_SUCCEED();
+    }
+
+    /* TODO: Put this into common. */
+    DramId GetDramId() {
+        u64 id64;
+        splGetConfig(SplConfigItem_DramId, &id64);
+        return static_cast<DramId>(id64);
+    }
+
+    MtcTableIndex GetMtcDramIndex(DramId dramId) {
+        for (u32 i = 0; i < std::size(mtcIndexTable); ++i) {
+            if (mtcIndexTable[i].dramId == dramId) {
+                return mtcIndexTable[i].index;
+            }
+        }
+
+        return MtcTableIndex_Invalid;
+    }
+
+    NORETURN void AbortInvalidMtc(const char *crashMsg) {
+        panic::SmcError(panic::Emc);
+        CRASH(crashMsg);
+    }
+
+    u32 GetMtcOffset(MtcTableIndex index) {
+        if (index < T210SdevEmcDvfsTableS6gb01) {
+            return index * erista::MtcFullTableSize;
+        }
+
+        /* Account for the weird in between mariko table. */
+        return index * erista::MtcFullTableSize + mariko::MtcFullTableSize;
+    }
+
+    void PrepareMtcMemoryRegion(u8 *firstTable, EristaMtcTable *usedTable) {
+        memmove(firstTable, usedTable, erista::MtcFullTableSize);
+
+        /* Clear all other tables. */
+        /* The used table is excluded. */
+        constexpr size_t RemainingRegionSize = (mariko::MtcFullTableSize) * (mariko::MtcFullTableCount) + (erista::MtcFullTableSize * (erista::MtcFullTableCount - 1));
+        memset(firstTable + erista::MtcFullTableSize, 0, RemainingRegionSize);
+    }
+
+    void MtcExtendTables(EristaMtcTable *table) {
+        for (u32 i = erista::MtcTableCountDefault; i < newEmcList.size(); ++i) {
+            std::memcpy(&table[i], &table[i - 1], sizeof(EristaMtcTable));
+            table[i].rate_khz = newEmcList[i];
+        }
+    }
+
+    Result MemFreqMtcTable(u32 *ptr) {
+        static const DramId dramId = [] {
+            DramId id = GetDramId();
+            return id;
+        }();
+
+        static const MtcTableIndex mtcIndex = [] {
+            MtcTableIndex idx = GetMtcDramIndex(dramId);
+            /* If for some reason this happens, there is no chance of recovering this. */
+            if (idx == MtcTableIndex_Invalid) {
+                AbortInvalidMtc("Invalid dramId");
+            }
+            return idx;
+        }();
+
+        static const u32 mtcOffset = GetMtcOffset(mtcIndex);
+
+        constexpr u32 StartAdjustment = offsetof(EristaMtcTable, rate_khz) + sizeof(EristaMtcTable) * (erista::MtcTableCountDefault - 1);
+        u8 *startPtr = reinterpret_cast<u8 *>(ptr) - StartAdjustment;
+
+        EristaMtcTable *table = reinterpret_cast<EristaMtcTable *>(startPtr + mtcOffset);
+        R_TRY(MtcValidateAllTables(table, EmcListDefault, EmcListSizeDefault));
+
+        PrepareMtcMemoryRegion(startPtr, table);
+        table = reinterpret_cast<EristaMtcTable *>(startPtr);
+
+        if (R_FAILED(MtcValidateAllTables(table, EmcListDefault, EmcListSizeDefault))) {
+            AbortInvalidMtc("Failed mtc validation");
+        }
+
+        if (C.eristaEmcMaxClock <= EmcClkOSLimit) {
             R_SKIP();
         }
 
-        /* If we oc ram at all, tables are always shifted by at least 1. */
-        u32 tableShifts = 1;
-        for (u32 i = 0; i < std::size(maxEmcClocks) - 1; ++i) {
-            /* Duplicated mtc tables may cause pcv to not select frequencies properly, causing issues. */
-            if (maxEmcClocks[i] != maxEmcClocks[i + 1] && maxEmcClocks[i] > EmcClkOSLimit) {
-                ++tableShifts;
-            } else {
-                maxEmcClocks[i] = 0;
-            }
+        MtcExtendTables(table);
+
+        if (R_FAILED(MtcValidateAllTables(table, newEmcList.data(), newEmcList.size()))) {
+            AbortInvalidMtc("Failed mtc validation");
         }
 
-        /* Erista has extra, useless mtc tables, such as 40.8 Mhz, overwrite them to make room for oc freqs. */
-        /* More than 3 tables can be overwritten, but 3 is plenty. */
-        std::memmove(table_list[0], table_list[tableShifts], sizeof(EristaMtcTable) * (khz_list_size - tableShifts));
-
-        /* Since we're not scaling r/w latency properly on Erista, we first overwrite the tables with the 1600 MHz table before scaling it. */
-        for (u32 i = 0; i < tableShifts; ++i) {
-            std::memcpy(table_list[khz_list_size - i - 1], table_list[khz_list_size - tableShifts - 1], sizeof(EristaMtcTable));
-        }
-
-        for (u32 i = tableShifts, j = 0; i > 0 && j < std::size(maxEmcClocks); ++j) {
-            if (!maxEmcClocks[j]) {
-                continue;
-            }
-
-            table_list[khz_list_size - i]->rate_khz = maxEmcClocks[j];
-            MemMtcTableAutoAdjust(table_list[khz_list_size - i]);
-            --i;
+        for (u32 i = erista::MtcTableCountDefault; i < newEmcList.size(); ++i) {
+            MemMtcTableAutoAdjust(&table[i]);
         }
 
         R_SUCCEED();
     }
 
     Result MemFreqMax(u32 *ptr) {
-        if (GET_MAX_OF_ARR(maxEmcClocks) <= EmcClkOSLimit) {
+        if (C.eristaEmcMaxClock <= EmcClkOSLimit) {
             R_SKIP();
         }
 
-        PATCH_OFFSET(ptr, GET_MAX_OF_ARR(maxEmcClocks));
+        PATCH_OFFSET(ptr, C.eristaEmcMaxClock);
 
         R_SUCCEED();
     }
@@ -450,7 +562,42 @@ namespace ams::ldr::hoc::pcv::erista {
     //     R_SUCCEED();
     // }
 
+
+    Result MemMtcTableAsm(u32 *ptr) {
+        constexpr u32 AddpOffset = 1;
+        constexpr u32 BrOffset   = 9;
+        constexpr u32 MovOffset  = 7;
+
+        /* Ensure we don't dereference memory before nso start. */
+        R_UNLESS(ptr - BrOffset >= nsoStart, ldr::ResultInvalidMtcTablePattern());
+
+        u32 adrp = *(ptr - AddpOffset);
+        R_UNLESS(AsmCompareAdrpNoImm(adrp, MtcAdrpAsm), ldr::ResultInvalidMtcTablePattern());
+
+        /* We don't check for matching register because both registers must be x0 in order to pass the previous checks. */
+        /* The correct instructions will always be x0 since the mtcTable pointer is returned. */
+
+        /* Pray this does not break. */
+        u32 br = *(ptr - BrOffset);
+        R_UNLESS(AsmCompareBrNoRd(br, MtcBrAsm), ldr::ResultInvalidMtcTablePattern());
+
+        /* Pray this does not break either. */
+        u32 mov = *(ptr - MovOffset);
+        R_UNLESS(asm_compare_no_rd(mov, MtcMovAsm), ldr::ResultInvalidMtcTablePattern());
+
+        u8  movRd         = asm_get_rd(mov);
+        u32 movCountPatch = asm_set_rd(asm_set_imm16(MtcMovAsm, newEmcList.size()), movRd);
+
+        PATCH_OFFSET(ptr - BrOffset,  NopIns);
+        PATCH_OFFSET(ptr - MovOffset, movCountPatch);
+
+        R_SUCCEED();
+    }
+
     void Patch(uintptr_t mapped_nso, size_t nso_size) {
+        nsoStart = reinterpret_cast<u32 *>(mapped_nso);
+        MtcGenerateFreqTables();
+
         u32 CpuCvbDefaultMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(CpuCvbTableDefault)->freq);
         u32 GpuCvbDefaultMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(GpuCvbTableDefault)->freq);
 
@@ -465,10 +612,11 @@ namespace ams::ldr::hoc::pcv::erista {
             {"GPU Freq Asm",      &GpuFreqMaxAsm,          2,          &GpuMaxClockPatternFn },
             {"GPU PLL Max", &      GpuFreqPllMax,          1, nullptr,  GpuClkPllMax         },
             // {"GPU PLL Limit",  &GpuFreqPllLimit,        4, nullptr,  GpuClkPllLimit       },
-            {"MEM Freq Mtc",      &MemFreqMtcTable,        0, nullptr,  EmcClkOSLimit        },
+            {"MEM Freq Mtc",      &MemFreqMtcTable,        1, nullptr,  EmcClkOSLimit        },
             {"MEM Freq Max",      &MemFreqMax,             0, nullptr,  EmcClkOSLimit        },
             {"MEM Freq PLLM",     &MemFreqPllmLimit,       2, nullptr,  EmcClkPllmLimit      },
             {"MEM Volt",          &MemVoltHandler,         2, nullptr,  MemVoltHOS           },
+            {"MEM Table Asm",     &MemMtcTableAsm,         1,           &MemMtcGetGetTablePatternFn },
         };
 
         for (uintptr_t ptr = mapped_nso; ptr <= mapped_nso + nso_size - sizeof(EristaMtcTable); ptr += sizeof(u32)) {
@@ -481,7 +629,7 @@ namespace ams::ldr::hoc::pcv::erista {
         }
 
         for (auto &entry : patches) {
-            LOGGING("%s Count: %zu", entry.description, entry.patched_count);
+            LOGGING("%s Count: %zu\n", entry.description, entry.patched_count);
             if (R_FAILED(entry.CheckResult())) {
                 panic::SmcError(panic::Patch);
 
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.hpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.hpp
index 11f9041d..7e2a7e5b 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.hpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.hpp
@@ -26,9 +26,6 @@
 
 namespace ams::ldr::hoc::pcv::erista {
 
-    static u32 maxEmcClocks[] = { C.eristaEmcMaxClock2, C.eristaEmcMaxClock1, C.eristaEmcMaxClock, };
-    #define GET_MAX_OF_ARR(ARR) (*std::max_element(ARR, ARR + std::size(ARR)))
-
     constexpr cvb_entry_t CpuCvbTableDefault[] = {
         // CPU_PLL_CVB_TABLE_ODN
         {  204000,  {721094}, {                         } },
@@ -109,8 +106,11 @@ namespace ams::ldr::hoc::pcv::erista {
         {                                                        },
     };
 
+    constexpr u32 EmcListDefault[]   = { 40800, 68000, 102000, 204000, 408000, 665600, 800000, 1065600, 1331200, 1600000, };
+    constexpr u32 EmcListSizeDefault = std::size(EmcListDefault);
+    constexpr u32 EmcListEndDefault  = EmcListSizeDefault - 1;
+
     constexpr u32 MemVoltHOS      = 1125'000;
-    constexpr u32 EmcClkMinFreq   = 40800; /* 40.8 MHz table only exists on erista. */
     constexpr u32 EmcClkPllmLimit = 1866'000'000;
 
     constexpr u32 MTC_TABLE_REV        = 7;
@@ -147,6 +147,16 @@ namespace ams::ldr::hoc::pcv::erista {
         { ICOSA_4GB_HYNIX_H9HCNNNBPUMLHR_NLE,       T210SdevEmcDvfsTableH4gb01, },
     };
 
+    constexpr u32 MtcBrAsm   = 0xD61F0140;
+    constexpr u32 MtcMovAsm  = 0x52800148;
+    constexpr u32 MtcAdrpAsm = 0xD0000081;
+    constexpr u32 MtcAddAsm  = 0x91131821;
+
+    ALWAYS_INLINE bool MemMtcGetGetTablePatternFn(u32 *ptr) {
+        /* This builds an address that gets returned, so the register must be x0 by convention. */
+        return AsmCompareAddNoImm12(*ptr, MtcAddAsm);
+    }
+
     void Patch(uintptr_t mapped_nso, size_t nso_size);
 
 }
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp
index 1200ceb4..7023b278 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp
@@ -635,14 +635,14 @@ namespace ams::ldr::hoc::pcv::mariko {
     }
 
     void MtcGenerateFreqTables() {
-        if (C.marikoEmcMaxClock <= EmcClkOSLimit) {
-            return;
-        }
-
         newEmcList.clear();
         newEmcList.reserve(DvfsTableEntryCount);
         newEmcList.insert(newEmcList.end(), std::begin(EmcListDefault), std::end(EmcListDefault));
 
+        if (C.marikoEmcMaxClock <= EmcClkOSLimit) {
+            return;
+        }
+
         u32 stepRate = 0;
         switch (C.stepMode) {
             case StepMode_66MHz:
@@ -764,10 +764,6 @@ namespace ams::ldr::hoc::pcv::mariko {
         MarikoMtcTable *table = reinterpret_cast<MarikoMtcTable *>(startPtr + mtcOffset);
         R_TRY(MtcValidateAllTables(table, EmcListDefault, EmcListSizeDefault));
 
-        if (C.marikoEmcMaxClock <= EmcClkOSLimit) {
-            R_SKIP();
-        }
-
         PrepareMtcMemoryRegion(startPtr, table);
         table = reinterpret_cast<MarikoMtcTable *>(startPtr);
 
@@ -775,6 +771,10 @@ namespace ams::ldr::hoc::pcv::mariko {
             AbortInvalidMtc("Failed mtc validation");
         }
 
+        if (C.marikoEmcMaxClock <= EmcClkOSLimit) {
+            R_SKIP();
+        }
+
         MtcExtendTables(table);
 
         if (R_FAILED(MtcValidateAllTables(table, newEmcList.data(), newEmcList.size()))) {
@@ -834,18 +834,18 @@ namespace ams::ldr::hoc::pcv::mariko {
         DvbEntry emcDvbOcTableBrackets[] = {
             {  204000, {              637,  637,  637,  }, },
             { 1331200, {              650,  637,  637,  }, },
-            { 1600000, {              675,  650,  637,  }, }, 
-            { 1866000, { DVB(DvbVolt( 700,  675,  650)) }, }, 
-            { 2133000, { DVB(DvbVolt( 725,  700,  675)) }, }, 
-            { 2246000, { DVB(DvbVolt( 750,  725,  700)) }, }, 
-            { 2400000, { DVB(DvbVolt( 775,  750,  725)) }, }, 
-            { 2466000, { DVB(DvbVolt( 800,  775,  750)) }, }, 
-            { 2533000, { DVB(DvbVolt( 810,  785,  760)) }, }, 
-            { 2566000, { DVB(DvbVolt( 820,  795,  770)) }, }, 
-            { 2600000, { DVB(DvbVolt( 830,  805,  780)) }, }, 
-            { 2633000, { DVB(DvbVolt( 840,  815,  790)) }, }, 
-            { 2666000, { DVB(DvbVolt( 850,  825,  800)) }, }, 
-            { 2700000, { DVB(DvbVolt( 860,  835,  810)) }, }, 
+            { 1600000, {              675,  650,  637,  }, },
+            { 1866000, { DVB(DvbVolt( 700,  675,  650)) }, },
+            { 2133000, { DVB(DvbVolt( 725,  700,  675)) }, },
+            { 2246000, { DVB(DvbVolt( 750,  725,  700)) }, },
+            { 2400000, { DVB(DvbVolt( 775,  750,  725)) }, },
+            { 2466000, { DVB(DvbVolt( 800,  775,  750)) }, },
+            { 2533000, { DVB(DvbVolt( 810,  785,  760)) }, },
+            { 2566000, { DVB(DvbVolt( 820,  795,  770)) }, },
+            { 2600000, { DVB(DvbVolt( 830,  805,  780)) }, },
+            { 2633000, { DVB(DvbVolt( 840,  815,  790)) }, },
+            { 2666000, { DVB(DvbVolt( 850,  825,  800)) }, },
+            { 2700000, { DVB(DvbVolt( 860,  835,  810)) }, },
             { 2733000, { DVB(DvbVolt( 870,  845,  820)) }, },
             { 2766000, { DVB(DvbVolt( 880,  855,  830)) }, },
             { 2800000, { DVB(DvbVolt( 895,  865,  840)) }, },
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.hpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.hpp
index 43258993..65955f1a 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.hpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.hpp
@@ -148,8 +148,6 @@ namespace ams::ldr::hoc::pcv::mariko {
     constexpr u32 EmcListDefault[]   = { 204000, 1331200, 1600000, };
     constexpr u32 EmcListSizeDefault = std::size(EmcListDefault);
     constexpr u32 EmcListEndDefault  = EmcListSizeDefault - 1;
-    constexpr u32 EmcRateStep        = 33'000;
-    constexpr u32 EmcRateStepScale   = 33'200;
 
     constexpr u32 EmcClkOSAlt     = 1331'200;
     constexpr u32 EmcClkPllmLimit = 2133'000'000;
diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/ptm/ptm.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/ptm/ptm.cpp
index 7ae9183a..15917d0e 100644
--- a/Source/Atmosphere/stratosphere/loader/source/oc/ptm/ptm.cpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/ptm/ptm.cpp
@@ -84,7 +84,7 @@ namespace ams::ldr::hoc::ptm {
 
             switch (entry->cpu_freq_1) {
                 case cpuPtmBoost:
-                    cpuPtmBoostPatch.Apply(entry);
+                    R_DISCARD(cpuPtmBoostPatch.Apply(entry));
                     break;
                 case cpuPtmDefault:
                 case cpuPtmDevOC:
@@ -99,7 +99,7 @@ namespace ams::ldr::hoc::ptm {
                 case memPtmAlt:
                 case memPtmClamp:
                     if (isMariko) {
-                        memPtmPatch.Apply(entry);
+                        R_DISCARD(memPtmPatch.Apply(entry));
                     }
                     break;
                 default:
@@ -109,13 +109,15 @@ namespace ams::ldr::hoc::ptm {
         }
 
         LOGGING("%s Count: %zu", cpuPtmBoostPatch.description, cpuPtmBoostPatch.patched_count);
-        if (R_FAILED(cpuPtmBoostPatch.CheckResult()))
+        if (R_FAILED(cpuPtmBoostPatch.CheckResult())) {
             CRASH(cpuPtmBoostPatch.description);
+        }
 
         if (isMariko) {
             LOGGING("%s Count: %zu", memPtmPatch.description, memPtmPatch.patched_count);
-            if (R_FAILED(memPtmPatch.CheckResult()))
+            if (R_FAILED(memPtmPatch.CheckResult())) {
                 CRASH(memPtmPatch.description);
+            }
         }
     }
 
diff --git a/Source/hoc-clk/common/include/hocclk/config.h b/Source/hoc-clk/common/include/hocclk/config.h
index 603effdd..236dfba1 100644
--- a/Source/hoc-clk/common/include/hocclk/config.h
+++ b/Source/hoc-clk/common/include/hocclk/config.h
@@ -81,8 +81,6 @@ typedef enum {
 
     KipConfigValue_commonEmcMemVolt,
     KipConfigValue_eristaEmcMaxClock,
-    KipConfigValue_eristaEmcMaxClock1,
-    KipConfigValue_eristaEmcMaxClock2,
 
     KipConfigValue_stepMode,
     KipConfigValue_marikoEmcMaxClock,
@@ -115,9 +113,6 @@ typedef enum {
     KipConfigValue_write_latency_1866,
     KipConfigValue_write_latency_2133,
 
-    KipConfigValue_mem_burst_read_latency,
-    KipConfigValue_mem_burst_write_latency,
-
     KipConfigValue_eristaCpuUV,
     KipConfigValue_eristaCpuVmin,
     KipConfigValue_eristaCpuMaxVolt,
@@ -141,7 +136,6 @@ typedef enum {
     KipConfigValue_marikoGpuVmax,
 
     KipConfigValue_commonGpuVoltOffset,
-    KipConfigValue_gpuSpeedo,
 
     KipConfigValue_g_volt_76800,
     KipConfigValue_g_volt_153600,
@@ -304,11 +298,7 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr
         case KipConfigValue_commonEmcMemVolt:
             return pretty ? "Common EMC/MEM Voltage" : "common_emc_mem_volt";
         case KipConfigValue_eristaEmcMaxClock:
-            return pretty ? "Erista EMC Max Clock 1" : "erista_emc_max_clock";
-        case KipConfigValue_eristaEmcMaxClock1:
-            return pretty ? "Erista EMC Max Clock 2" : "erista_emc_max_clock1";
-        case KipConfigValue_eristaEmcMaxClock2:
-            return pretty ? "Erista EMC Max Clock 3" : "erista_emc_max_clock2";
+            return pretty ? "Erista EMC Max Clock" : "erista_emc_max_clock";
         case KipConfigValue_stepMode:
             return pretty ? "Step Mode:" : "step_mode";
         case KipConfigValue_marikoEmcMaxClock:
@@ -365,11 +355,6 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr
         case KipConfigValue_write_latency_2133:
             return pretty ? "2133 Write Latency" : "write_latency_2133";
 
-        case KipConfigValue_mem_burst_read_latency:
-            return pretty ? "Memory Burst Read Latency" : "mem_burst_read_latency";
-        case KipConfigValue_mem_burst_write_latency:
-            return pretty ? "Memory Burst Write Latency" : "mem_burst_write_latency";
-
         // CPU – Erista
         case KipConfigValue_eristaCpuUV:
             return pretty ? "Erista CPU Undervolt" : "erista_cpu_uv";
@@ -418,8 +403,6 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr
 
         case KipConfigValue_commonGpuVoltOffset:
             return pretty ? "Common GPU Voltage Offset" : "common_gpu_volt_offset";
-        case KipConfigValue_gpuSpeedo:
-            return pretty ? "GPU Speedo" : "gpu_speedo";
 
         // Mariko GPU voltages (24)
         case KipConfigValue_g_volt_76800: return pretty ? "Mariko GPU Volt 76 MHz" : "g_volt_76800";
@@ -572,8 +555,6 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
         case KipConfigValue_hpMode:
         case KipConfigValue_commonEmcMemVolt:
         case KipConfigValue_eristaEmcMaxClock:
-        case KipConfigValue_eristaEmcMaxClock1:
-        case KipConfigValue_eristaEmcMaxClock2:
         case KipConfigValue_stepMode:
         case KipConfigValue_marikoEmcMaxClock:
         case KipConfigValue_marikoEmcVddqVolt:
@@ -599,8 +580,6 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
         case KipConfigValue_write_latency_1600:
         case KipConfigValue_write_latency_1866:
         case KipConfigValue_write_latency_2133:
-        case KipConfigValue_mem_burst_read_latency:
-        case KipConfigValue_mem_burst_write_latency:
         case KipConfigValue_eristaCpuUV:
         case KipConfigValue_eristaCpuMaxVolt:
         case KipConfigValue_marikoCpuUVLow:
@@ -618,7 +597,6 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
         case KipConfigValue_marikoGpuVmin:
         case KipConfigValue_marikoGpuVmax:
         case KipConfigValue_commonGpuVoltOffset:
-        case KipConfigValue_gpuSpeedo:
         case KipConfigValue_g_volt_76800:
         case KipConfigValue_g_volt_153600:
         case KipConfigValue_g_volt_230400:
diff --git a/Source/hoc-clk/overlay/src/ui/gui/config_info_strings.cpp b/Source/hoc-clk/overlay/src/ui/gui/config_info_strings.cpp
index cba8f68f..89eae281 100644
--- a/Source/hoc-clk/overlay/src/ui/gui/config_info_strings.cpp
+++ b/Source/hoc-clk/overlay/src/ui/gui/config_info_strings.cpp
@@ -97,8 +97,8 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
                 "- Washed: Washed out colors.",
                 "- Basic: Real natural profile.",
                 "- Natural: Not actually natural.. Extra saturation.",
-                "- Vivid: Saturated.",      
-                "Default: Do not override"  
+                "- Vivid: Saturated.",
+                "Default: Do not override"
             };
 
         case HocClkConfigValue_CpuGovernorMinimumFreq:
@@ -224,7 +224,7 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
                 "Default: 600 mV"
             };
 
-        case KipConfigValue_stepMode:         
+        case KipConfigValue_stepMode:
             return {
                 "The step that RAM clocks take.",
                 "Options (with examples):",
@@ -247,8 +247,6 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
             };
 
         case KipConfigValue_eristaEmcMaxClock:
-        case KipConfigValue_eristaEmcMaxClock1:
-        case KipConfigValue_eristaEmcMaxClock2:
             return {
                 "The RAM frequency used in the particular slot. Higher frequencies may cause instability, so increase this gradually and test for stability.",
                 "Default: Disabled (1600 MHz)"
@@ -360,19 +358,6 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
                 "These properties apply for both write and read latencies, and you can mix-and-match the brackets if necessary",
                 "Default: -"
             };
-
-        case KipConfigValue_mem_burst_read_latency:
-            return {
-                "The read latency for the ram",
-                "Default: 1600 RL"
-            };
-
-        case KipConfigValue_mem_burst_write_latency:
-            return {
-                "The write latency for the ram",
-                "Default: 1600 WL"
-            };
-
         case KipConfigValue_marikoCpuUVLow:
             return {
                 "The CPU UV level used before tBreak",
diff --git a/Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp b/Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp
index 1b3d05ce..e1ea9de5 100644
--- a/Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp
+++ b/Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp
@@ -61,7 +61,6 @@ class RamLatenciesSubmenuGui;
 class CpuSubmenuGui;
 class GpuSubmenuGui;
 class GpuCustomTableSubmenuGui;
-class RamTableEditor;
 class ExperimentalSettingsSubMenuGui;
 
 MiscGui::MiscGui()
@@ -688,7 +687,7 @@ protected:
             false
 
         );
-        
+
         addConfigButton(
             HocClkConfigValue_PollingIntervalMs,
             "Polling Interval",
@@ -1005,7 +1004,7 @@ protected:
 
 
         this->listElement->addItem(new tsl::elm::CategoryHeader("RAM Settings"));
-        
+
         addMappedConfigTrackbar(KipConfigValue_emcDvbShift, "DVB Shift",
             {0xFFFFFFFCu, 0xFFFFFFFDu, 0xFFFFFFFEu, 0xFFFFFFFFu, 0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u},
             {"-4", "-3", "-2", "-1", " 0", "1", "2", "3", "4", "5", "6", "7", "8"});
@@ -1047,7 +1046,7 @@ protected:
                 true
             );
         }
-        
+
         addConfigToggle(KipConfigValue_hpMode, "HP Mode", true);
 
         std::map<uint32_t, std::string> emc_voltage_label = {
@@ -1097,20 +1096,51 @@ protected:
             addConfigButton(KipConfigValue_stepMode, "Step Mode", ValueRange(0, 0, 2, "", 0), "Step Mode", &thresholdsDisabled, {}, stepMode, false, true);
         }
 
+        std::vector<NamedValue> emcMaxClock = { };
+        RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];
+
         if (IsErista()) {
-            tsl::elm::ListItem* freqSubmenu = new tsl::elm::ListItem("RAM Frequency Editor");
-            freqSubmenu->setClickListener([](u64 keys) {
-                if (keys & HidNpadButton_A) {
-                    tsl::changeTo<RamTableEditor>();
-                    return true;
-                }
-                return false;
-            });
-            freqSubmenu->setValue(R_ARROW);
-            this->listElement->addItem(freqSubmenu);
+            emcMaxClock = {
+                NamedValue("Disabled", 1600000),
+                NamedValue("1633 MHz", 1633000),
+                NamedValue("1666 MHz", 1666000),
+                NamedValue("1700 MHz", 1700000),
+                NamedValue("1733 MHz", 1733000),
+                NamedValue("1766 MHz", 1766000),
+                NamedValue("1800 MHz", 1800000),
+                NamedValue("1833 MHz", 1833000),
+                NamedValue("1862 MHz", 1862400, "JEDEC."),
+                NamedValue("1881 MHz", 1881600),
+                NamedValue("1900 MHz", 1900800),
+                NamedValue("1920 MHz", 1920000),
+                NamedValue("1939 MHz", 1939200),
+                NamedValue("1958 MHz", 1958400),
+                NamedValue("1977 MHz", 1977600),
+                NamedValue("1996 MHz", 1996800, "JEDEC."),
+                NamedValue("2016 MHz", 2016000),
+                NamedValue("2035 MHz", 2035200),
+                NamedValue("2054 MHz", 2054400),
+                NamedValue("2073 MHz", 2073600),
+                NamedValue("2092 MHz", 2092800),
+                NamedValue("2112 MHz", 2112000),
+                NamedValue("2131 MHz", 2131200, "JEDEC."),
+                NamedValue("2150 MHz", 2150400),
+                NamedValue("2169 MHz", 2169600),
+                NamedValue("2188 MHz", 2188800),
+                NamedValue("2208 MHz", 2208000),
+                NamedValue("2227 MHz", 2227200),
+                NamedValue("2246 MHz", 2246400),
+                NamedValue("2265 MHz", 2265600),
+                NamedValue("2284 MHz", 2284800),
+                NamedValue("2304 MHz", 2304000),
+                NamedValue("2323 MHz", 2323200),
+                NamedValue("2342 MHz", 2342400),
+                NamedValue("2361 MHz", 2361600),
+                NamedValue("2380 MHz", 2380800),
+                NamedValue("2400 MHz", 2400000, "JEDEC."),
+            };
         } else {
-            RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];
-            std::vector<NamedValue> marikoMaxEmcClock = {
+            emcMaxClock = {
                 NamedValue("1600 MHz", 1600000),
                 NamedValue("1633 MHz", 1633000),
                 NamedValue("1666 MHz", 1666000),
@@ -1164,19 +1194,20 @@ protected:
                 NamedValue("3233 MHz", 3233000, "High speedo needed!"),
                 NamedValue("3266 MHz", 3266000, "High speedo needed!"),
                 NamedValue("3300 MHz", 3300000, "High speedo needed!"),
-                // NamedValue("3333MHz (Needs extreme Speedo/PLL)", 3333000),
-                // NamedValue("3366MHz (Needs extreme Speedo/PLL)", 3366000),
-                // NamedValue("3400MHz (Needs extreme Speedo/PLL)", 3400000),
-                // NamedValue("3433MHz (Needs ridiculous Speedo/PLL)", 3433000),
-                // NamedValue("3466MHz (Needs ridiculous Speedo/PLL)", 3466000),
-                // NamedValue("3500MHz (Needs ridiculous Speedo/PLL)", 3500000),
             };
-            for (auto& nv : marikoMaxEmcClock)
-                nv.name = formatMemClockKhzLabel(nv.value, unit);
-
-            addConfigButton(KipConfigValue_marikoEmcMaxClock, "Ram Max Clock", ValueRange(0, 1, 1, "", 1), "Ram Max Clock", &thresholdsDisabled, {}, marikoMaxEmcClock, false, true);
         }
 
+        for (auto& nv : emcMaxClock) {
+            if (nv.name != "Disabled") {
+                nv.name = formatMemClockKhzLabel(nv.value, unit);
+            }
+        }
+
+        if (IsMariko()) {
+            addConfigButton(KipConfigValue_marikoEmcMaxClock, "Ram Max Clock", ValueRange(0, 1, 1, "", 1), "Ram Max Clock", &thresholdsDisabled, {}, emcMaxClock, false, true);
+        } else {
+            addConfigButton(KipConfigValue_eristaEmcMaxClock, "Ram Max Clock", ValueRange(0, 1, 1, "", 1), "Ram Max Clock", &thresholdsDisabled, {}, emcMaxClock, false, true);
+        }
 
         tsl::elm::ListItem* latenciesSubmenu = new tsl::elm::ListItem("RAM Latency Editor");
         latenciesSubmenu->setClickListener([](u64 keys) {
@@ -1313,7 +1344,7 @@ public:
 protected:
 
     void normalizeLatencies(const HocClkConfigValue keysArr[4]) {
-        uint32_t maxClock = (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock];
+        uint32_t maxClock = IsMariko() ? (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock] : (uint32_t)this->configList->values[KipConfigValue_eristaEmcMaxClock];
         uint32_t vals[4];
 
         for (int i = 0; i < 4; i++) {
@@ -1348,35 +1379,37 @@ protected:
 
     void listUI() override {
         ValueThresholds thresholdsDisabled(0, 0);
-
-        if (IsErista()) {
-            std::vector<NamedValue> rlLabels = { NamedValue("1333 RL", 28), NamedValue("1600 RL", 32), NamedValue("1866 RL", 36), NamedValue("2133 RL", 40) };
-            std::vector<NamedValue> wlLabels = { NamedValue("1333 WL", 12), NamedValue("1600 WL", 14), NamedValue("1866 WL", 16), NamedValue("2133 WL", 18) };
-
-            addConfigButton(KipConfigValue_mem_burst_read_latency,  "Read Latency",  ValueRange(0, 6, 1, "", 0), "Read Latency",  &thresholdsDisabled, {}, rlLabels, false, true);
-            addConfigButton(KipConfigValue_mem_burst_write_latency, "Write Latency", ValueRange(0, 6, 1, "", 0), "Write Latency", &thresholdsDisabled, {}, wlLabels, false, true);
-            return;
-        }
-
         Result rc = hocclkIpcGetConfigValues(this->configList);
         if (R_FAILED(rc)) [[unlikely]] {
             FatalGui::openWithResultCode("hocclkIpcGetConfigValues", rc);
             return;
         }
 
-        uint32_t maxClock = (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock];
+        uint32_t maxClock = IsMariko() ? (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock] : (uint32_t)this->configList->values[KipConfigValue_eristaEmcMaxClock];
         RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];
 
-        static const std::vector<uint32_t> kFreqOptions = {
-            1633000, 1666000, 1700000, 1733000, 1766000, 1800000,
-            1833000, 1866000, 1900000, 1933000, 1966000, 1996800, 2000000,
-            2033000, 2066000, 2100000, 2133000, 2166000, 2200000, 2233000,
-            2266000, 2300000, 2333000, 2366000, 2400000, 2433000, 2466000,
-            2500000, 2533000, 2566000, 2600000, 2633000, 2666000, 2700000,
-            2733000, 2766000, 2800000, 2833000, 2866000, 2900000, 2933000,
-            2966000, 3000000, 3033000, 3066000, 3100000, 3133000, 3166000,
-            3200000, 3233000, 3266000, 3300000,
-        };
+        static std::vector<uint32_t> kFreqOptions = { };
+        if (IsMariko()) {
+            kFreqOptions = {
+                1633000, 1666000, 1700000, 1733000, 1766000, 1800000,
+                1833000, 1866000, 1900000, 1933000, 1966000, 1996800, 2000000,
+                2033000, 2066000, 2100000, 2133000, 2166000, 2200000, 2233000,
+                2266000, 2300000, 2333000, 2366000, 2400000, 2433000, 2466000,
+                2500000, 2533000, 2566000, 2600000, 2633000, 2666000, 2700000,
+                2733000, 2766000, 2800000, 2833000, 2866000, 2900000, 2933000,
+                2966000, 3000000, 3033000, 3066000, 3100000, 3133000, 3166000,
+                3200000, 3233000, 3266000, 3300000,
+            };
+        } else {
+            kFreqOptions = {
+                1633000, 1666000, 1700000, 1733000, 1800000,
+                1833000, 1862400, 1881600, 1900800, 1920000, 1939200,
+                1958400, 1977600, 1996800, 2016000, 2035200, 2054400,
+                2073600, 2092800, 2112000, 2131200, 2150400, 2169600,
+                2188800, 2208000, 2227200, 2246400, 2265600, 2284800,
+                2304000, 2323200, 2342400, 2361600, 2380800, 2400000,
+            };
+        }
 
         static const HocClkConfigValue kLatencyRKeys[4] = {
             KipConfigValue_read_latency_1333,
@@ -1436,7 +1469,7 @@ protected:
                 for (int i = 0; i < 4; i++)
                     vals[i] = (uint32_t)this->configList->values[keysArr[i]];
 
-                uint32_t maxClock = (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock];
+                uint32_t maxClock = IsMariko() ? (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock] : (uint32_t)this->configList->values[KipConfigValue_eristaEmcMaxClock];
                 RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];
 
                 auto resolveVal = [maxClock](uint32_t v) -> uint32_t {
@@ -1644,7 +1677,7 @@ protected:
                 true
             );
 
-            
+
             std::vector<NamedValue> maxClkOptions = {
                 NamedValue("1963 MHz", 1963500),
                 NamedValue("2091 MHz", 2091000),
@@ -1766,78 +1799,6 @@ protected:
     }
 };
 
-class RamTableEditor : public MiscGui {
-public:
-    RamTableEditor() { }
-
-protected:
-    void listUI() override {
-        Result rc = hocclkIpcGetConfigValues(this->configList);
-        if (R_FAILED(rc)) [[unlikely]] { FatalGui::openWithResultCode("hocclkIpcGetConfigValues", rc); return; }
-        this->listElement->addItem(new tsl::elm::CategoryHeader("RAM Frequency Editor"));
-
-        ValueThresholds thresholdsDisabled(0, 0);
-        // 1600000, 1331200, 1065600, 800000, 665600, 408000, 204000
-        RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];
-
-        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(665600, unit)));
-        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(800000, unit)));
-        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(1065600, unit)));
-        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(1331200, unit)));
-        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(1600000, unit)));
-
-        ValueThresholds eristaRamThresholds(2208000, 2304000);
-
-        std::vector<NamedValue> eristaMaxEmcClock = {
-            NamedValue("Disabled", 1600000),
-            NamedValue("1633 MHz", 1633000),
-            NamedValue("1666 MHz", 1666000),
-            NamedValue("1700 MHz", 1700000),
-            NamedValue("1733 MHz", 1733000),
-            NamedValue("1766 MHz", 1766000),
-            NamedValue("1800 MHz", 1800000),
-            NamedValue("1833 MHz", 1833000),
-            NamedValue("1862 MHz", 1862400, "JEDEC."),
-            NamedValue("1881 MHz", 1881600),
-            NamedValue("1900 MHz", 1900800),
-            NamedValue("1920 MHz", 1920000),
-            NamedValue("1939 MHz", 1939200),
-            NamedValue("1958 MHz", 1958400),
-            NamedValue("1977 MHz", 1977600),
-            NamedValue("1996 MHz", 1996800, "JEDEC."),
-            NamedValue("2016 MHz", 2016000),
-            NamedValue("2035 MHz", 2035200),
-            NamedValue("2054 MHz", 2054400),
-            NamedValue("2073 MHz", 2073600),
-            NamedValue("2092 MHz", 2092800),
-            NamedValue("2112 MHz", 2112000),
-            NamedValue("2131 MHz", 2131200, "JEDEC."),
-            NamedValue("2150 MHz", 2150400),
-            NamedValue("2169 MHz", 2169600),
-            NamedValue("2188 MHz", 2188800),
-            NamedValue("2208 MHz", 2208000),
-            NamedValue("2227 MHz", 2227200),
-            NamedValue("2246 MHz", 2246400),
-            NamedValue("2265 MHz", 2265600),
-            NamedValue("2284 MHz", 2284800),
-            NamedValue("2304 MHz", 2304000),
-            NamedValue("2323 MHz", 2323200),
-            NamedValue("2342 MHz", 2342400),
-            NamedValue("2361 MHz", 2361600),
-            NamedValue("2380 MHz", 2380800),
-            NamedValue("2400 MHz", 2400000, "JEDEC."),
-        };
-
-        for (auto& nv : eristaMaxEmcClock)
-            if (nv.name != "Disabled")
-                nv.name = formatMemClockKhzLabel(nv.value, unit);
-
-        addConfigButtonS(KipConfigValue_eristaEmcMaxClock, "", ValueRange(0, 1, 1, "", 1), "", &eristaRamThresholds, {}, eristaMaxEmcClock, false, A_BTN, true);
-        addConfigButtonS(KipConfigValue_eristaEmcMaxClock1, "", ValueRange(0, 1, 1, "", 1), "", &eristaRamThresholds, {}, eristaMaxEmcClock, false, A_BTN, true);
-        addConfigButtonS(KipConfigValue_eristaEmcMaxClock2, "", ValueRange(0, 1, 1, "", 1), "", &eristaRamThresholds, {}, eristaMaxEmcClock, false, A_BTN, true);
-    };
-};
-
 class GpuSubmenuGui : public MiscGui {
 public:
     GpuSubmenuGui() { }
@@ -2320,8 +2281,6 @@ void MiscGui::refresh() {
         constexpr HocClkConfigValue emcKeys[] = {
             KipConfigValue_marikoEmcMaxClock,
             KipConfigValue_eristaEmcMaxClock,
-            KipConfigValue_eristaEmcMaxClock1,
-            KipConfigValue_eristaEmcMaxClock2,
         };
         for (auto key : emcKeys) {
             auto it = this->configNamedValues.find(key);
diff --git a/Source/hoc-clk/sysmodule/src/file/kip.cpp b/Source/hoc-clk/sysmodule/src/file/kip.cpp
index b15793d2..07a4e8fa 100644
--- a/Source/hoc-clk/sysmodule/src/file/kip.cpp
+++ b/Source/hoc-clk/sysmodule/src/file/kip.cpp
@@ -72,8 +72,6 @@ namespace kip {
 
         CUST_WRITE_FIELD_BATCH(&table, commonEmcMemVolt, config::GetConfigValue(KipConfigValue_commonEmcMemVolt));
         CUST_WRITE_FIELD_BATCH(&table, eristaEmcMaxClock, config::GetConfigValue(KipConfigValue_eristaEmcMaxClock));
-        CUST_WRITE_FIELD_BATCH(&table, eristaEmcMaxClock1, config::GetConfigValue(KipConfigValue_eristaEmcMaxClock1));
-        CUST_WRITE_FIELD_BATCH(&table, eristaEmcMaxClock2, config::GetConfigValue(KipConfigValue_eristaEmcMaxClock2));
         CUST_WRITE_FIELD_BATCH(&table, marikoEmcMaxClock, config::GetConfigValue(KipConfigValue_marikoEmcMaxClock));
         CUST_WRITE_FIELD_BATCH(&table, marikoEmcVddqVolt, config::GetConfigValue(KipConfigValue_marikoEmcVddqVolt));
         CUST_WRITE_FIELD_BATCH(&table, emcDvbShift, config::GetConfigValue(KipConfigValue_emcDvbShift) > 8 && config::GetConfigValue(KipConfigValue_emcDvbShift) <= 16 ? 8 : config::GetConfigValue(KipConfigValue_emcDvbShift)); // 2.2.0 -> 2.3.0 compat
@@ -104,8 +102,6 @@ namespace kip {
         CUST_WRITE_FIELD_BATCH(&table, writeLatency1866, config::GetConfigValue(KipConfigValue_write_latency_1866));
         CUST_WRITE_FIELD_BATCH(&table, writeLatency2133, config::GetConfigValue(KipConfigValue_write_latency_2133));
 
-        CUST_WRITE_FIELD_BATCH(&table, mem_burst_read_latency, config::GetConfigValue(KipConfigValue_mem_burst_read_latency));
-        CUST_WRITE_FIELD_BATCH(&table, mem_burst_write_latency, config::GetConfigValue(KipConfigValue_mem_burst_write_latency));
         CUST_WRITE_FIELD_BATCH(&table, eristaCpuUV, config::GetConfigValue(KipConfigValue_eristaCpuUV));
         CUST_WRITE_FIELD_BATCH(&table, eristaCpuVmin, config::GetConfigValue(KipConfigValue_eristaCpuVmin));
         CUST_WRITE_FIELD_BATCH(&table, eristaCpuMaxVolt, config::GetConfigValue(KipConfigValue_eristaCpuMaxVolt));
@@ -130,7 +126,6 @@ namespace kip {
         CUST_WRITE_FIELD_BATCH(&table, marikoGpuVmax, config::GetConfigValue(KipConfigValue_marikoGpuVmax));
 
         CUST_WRITE_FIELD_BATCH(&table, commonGpuVoltOffset, config::GetConfigValue(KipConfigValue_commonGpuVoltOffset));
-        CUST_WRITE_FIELD_BATCH(&table, gpuSpeedo, config::GetConfigValue(KipConfigValue_gpuSpeedo));
 
         for (int i = 0; i < 24; i++) {
             table.marikoGpuVoltArray[i] = config::GetConfigValue((HocClkConfigValue)(KipConfigValue_g_volt_76800 + i));
@@ -229,8 +224,6 @@ namespace kip {
 
         configValues.values[KipConfigValue_commonEmcMemVolt] = cust_get_common_emc_volt(&table);
         configValues.values[KipConfigValue_eristaEmcMaxClock] = cust_get_erista_emc_max(&table);
-        configValues.values[KipConfigValue_eristaEmcMaxClock1] = cust_get_erista_emc_max1(&table);
-        configValues.values[KipConfigValue_eristaEmcMaxClock2] = cust_get_erista_emc_max2(&table);
         configValues.values[KipConfigValue_marikoEmcMaxClock] = cust_get_mariko_emc_max(&table);
         configValues.values[KipConfigValue_marikoEmcVddqVolt] = cust_get_mariko_emc_vddq(&table);
         configValues.values[KipConfigValue_emcDvbShift] = cust_get_emc_dvb_shift(&table) > 8 && cust_get_emc_dvb_shift(&table) <= 16 ? 8 : cust_get_emc_dvb_shift(&table); // 2.2.0 -> 2.3.0 compat
@@ -261,9 +254,6 @@ namespace kip {
         configValues.values[KipConfigValue_write_latency_1866] = cust_get_write_latency_1866(&table);
         configValues.values[KipConfigValue_write_latency_2133] = cust_get_write_latency_2133(&table);
 
-        configValues.values[KipConfigValue_mem_burst_read_latency] = cust_get_burst_read_lat(&table);
-        configValues.values[KipConfigValue_mem_burst_write_latency] = cust_get_burst_write_lat(&table);
-
         configValues.values[KipConfigValue_eristaCpuUV] = cust_get_erista_cpu_uv(&table);
         configValues.values[KipConfigValue_eristaCpuVmin] = cust_get_eristaCpuVmin(&table);
         configValues.values[KipConfigValue_eristaCpuMaxVolt] = cust_get_erista_cpu_max_volt(&table);
@@ -285,7 +275,6 @@ namespace kip {
         configValues.values[KipConfigValue_marikoGpuVmin] = cust_get_mariko_gpu_vmin(&table);
         configValues.values[KipConfigValue_marikoGpuVmax] = cust_get_mariko_gpu_vmax(&table);
         configValues.values[KipConfigValue_commonGpuVoltOffset] = cust_get_common_gpu_offset(&table);
-        configValues.values[KipConfigValue_gpuSpeedo] = board::GetFuseData()->gpuSpeedo; // cust_get_gpu_speedo(&table);
 
         for (int i = 0; i < 24; i++) {
             configValues.values[KipConfigValue_g_volt_76800 + i] = cust_get_mariko_gpu_volt(&table, i);
diff --git a/Source/hoc-clk/sysmodule/src/file/kip.hpp b/Source/hoc-clk/sysmodule/src/file/kip.hpp
index 2b8421b9..11b70c5e 100644
--- a/Source/hoc-clk/sysmodule/src/file/kip.hpp
+++ b/Source/hoc-clk/sysmodule/src/file/kip.hpp
@@ -38,8 +38,7 @@ namespace kip {
         u32 hpMode;
         u32 commonEmcMemVolt;
         u32 eristaEmcMaxClock;
-        u32 eristaEmcMaxClock1;
-        u32 eristaEmcMaxClock2;
+        u32 reserved1[2];
         u32 stepMode;
         u32 marikoEmcMaxClock;
         u32 marikoEmcVddqVolt;
@@ -66,8 +65,7 @@ namespace kip {
         u32 readLatency1333, readLatency1600, readLatency1866, readLatency2133;
         u32 writeLatency1333, writeLatency1600, writeLatency1866, writeLatency2133;
 
-        u32 mem_burst_read_latency;
-        u32 mem_burst_write_latency;
+        u32 reserved2[2];
 
         u32 eristaCpuUV;
         u32 eristaCpuVmin;
@@ -94,7 +92,7 @@ namespace kip {
 
         u32 commonGpuVoltOffset;
 
-        u32 gpuSpeedo;
+        u32 reserved3;
 
         u32 eristaGpuVoltArray[27];
         u32 marikoGpuVoltArray[24];
@@ -212,8 +210,6 @@ namespace kip {
 
     static inline bool cust_set_common_emc_volt(const char* p, u32 v) { CUST_WRITE_FIELD(p, commonEmcMemVolt, v); }
     static inline bool cust_set_erista_emc_max(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaEmcMaxClock, v); }
-    static inline bool cust_set_erista_emc_max1(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaEmcMaxClock1, v); }
-    static inline bool cust_set_erista_emc_max2(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaEmcMaxClock2, v); }
     static inline bool cust_set_step_mode(const char* p, u32 v) { CUST_WRITE_FIELD(p, stepMode, v); }
     static inline bool cust_set_mariko_emc_max(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoEmcMaxClock, v); }
     static inline bool cust_set_mariko_emc_vddq(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoEmcVddqVolt, v); }
@@ -244,9 +240,6 @@ namespace kip {
     static inline bool cust_set_write_latency_1866(const char* p, u32 v) { CUST_WRITE_FIELD(p, writeLatency1866, v); }
     static inline bool cust_set_write_latency_2133(const char* p, u32 v) { CUST_WRITE_FIELD(p, writeLatency2133, v); }
 
-    static inline bool cust_set_burst_read_lat(const char* p, u32 v) { CUST_WRITE_FIELD(p, mem_burst_read_latency, v); }
-    static inline bool cust_set_burst_write_lat(const char* p, u32 v) { CUST_WRITE_FIELD(p, mem_burst_write_latency, v); }
-
     static inline bool cust_set_erista_cpu_uv(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaCpuUV, v); }
     static inline bool cust_set_eristaCpuVmin(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaCpuVmin, v); }
     static inline bool cust_set_erista_cpu_max_volt(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaCpuMaxVolt, v); }
@@ -266,7 +259,6 @@ namespace kip {
     static inline bool cust_set_mariko_gpu_vmin(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoGpuVmin, v); }
     static inline bool cust_set_mariko_gpu_vmax(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoGpuVmax, v); }
     static inline bool cust_set_common_gpu_offset(const char* p, u32 v) { CUST_WRITE_FIELD(p, commonGpuVoltOffset, v); }
-    static inline bool cust_set_gpu_speedo(const char* p, u32 v) { CUST_WRITE_FIELD(p, gpuSpeedo, v); }
     static inline bool cust_set_marikoCpuMaxClock(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoCpuMaxClock, v); }
     static inline bool cust_set_marikoSocVmax(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoSocVmax, v); }
 
@@ -301,8 +293,6 @@ namespace kip {
 
     static inline u32 cust_get_common_emc_volt(const CustomizeTable* t) { return CUST_GET_FIELD(t, commonEmcMemVolt); }
     static inline u32 cust_get_erista_emc_max(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaEmcMaxClock); }
-    static inline u32 cust_get_erista_emc_max1(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaEmcMaxClock1); }
-    static inline u32 cust_get_erista_emc_max2(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaEmcMaxClock2); }
     static inline u32 cust_get_step_mode(const CustomizeTable* t) { return CUST_GET_FIELD(t, stepMode); }
     static inline u32 cust_get_mariko_emc_max(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoEmcMaxClock); }
     static inline u32 cust_get_mariko_emc_vddq(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoEmcVddqVolt); }
@@ -333,9 +323,6 @@ namespace kip {
     static inline u32 cust_get_write_latency_1866(const CustomizeTable* t) { return CUST_GET_FIELD(t, writeLatency1866); }
     static inline u32 cust_get_write_latency_2133(const CustomizeTable* t) { return CUST_GET_FIELD(t, writeLatency2133); }
 
-    static inline u32 cust_get_burst_read_lat(const CustomizeTable* t) { return CUST_GET_FIELD(t, mem_burst_read_latency); }
-    static inline u32 cust_get_burst_write_lat(const CustomizeTable* t) { return CUST_GET_FIELD(t, mem_burst_write_latency); }
-
     static inline u32 cust_get_erista_cpu_uv(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaCpuUV); }
     static inline u32 cust_get_eristaCpuVmin(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaCpuVmin); }
     static inline u32 cust_get_erista_cpu_max_volt(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaCpuMaxVolt); }
@@ -356,7 +343,6 @@ namespace kip {
     static inline u32 cust_get_mariko_gpu_vmin(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoGpuVmin); }
     static inline u32 cust_get_mariko_gpu_vmax(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoGpuVmax); }
     static inline u32 cust_get_common_gpu_offset(const CustomizeTable* t) { return CUST_GET_FIELD(t, commonGpuVoltOffset); }
-    static inline u32 cust_get_gpu_speedo(const CustomizeTable* t) { return CUST_GET_FIELD(t, gpuSpeedo); }
     static inline u32 cust_get_marikoCpuMaxClock(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoCpuMaxClock); }
     static inline u32 cust_get_marikoSocVmax(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoSocVmax); }
 
diff --git a/dist/README.md b/dist/README.md
deleted file mode 100644
index ff3e6be6..00000000
--- a/dist/README.md
+++ /dev/null
@@ -1,214 +0,0 @@
-
-<div align="center">
-
-<img src="assets/logo.png" alt="logo" width="768"/>
-
----
-
-![License: GPL-2.0](https://img.shields.io/badge/GPL--2.0-red?style=for-the-badge)
-![Nintendo Switch](https://img.shields.io/badge/Nintendo_Switch-E60012?style=for-the-badge\&logo=nintendo-switch\&logoColor=white)
-[![Discord](https://img.shields.io/badge/Discord-5865F2?style=for-the-badge\&logo=discord\&logoColor=white)](https://dsc.gg/horizonoc)
-![VSCode](https://img.shields.io/badge/VSCode-0078D4?style=for-the-badge\&logo=visual%20studio%20code\&logoColor=white)
-![Made with Notepad++](assets/np++.png?raw=true)
-![C++](https://img.shields.io/badge/C%2B%2B-00599C?style=for-the-badge\&logo=c%2B%2B\&logoColor=white)
-![Downloads](https://img.shields.io/github/downloads/Horizon-OC/Horizon-OC/total.svg?style=for-the-badge)
-
----
-
-</div>
-
-## ⚠️ Disclaimer
-
-> **THIS TOOL CAN BE DANGEROUS IF MISUSED. PROCEED WITH CAUTION.**
-> Due to the design of Horizon OS, **overclocking RAM can cause NAND OR SD CORRUPTION.**
-> Ensure you have a **full NAND, PROINFO, EMUMMC and SD backup** before proceeding.
-
----
-
-## About
-
-**Horizon OC** is an open-source overclocking tool for Nintendo Switch consoles running **Atmosphere custom firmware**.
-It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration tools.
-
----
-
-## Default clocks
-
-* **CPU:** Up to 1963MHz (Mariko) / 1785MHz (Erista)
-* **GPU:** Up to 1075MHz (Mariko) / 921MHz (Erista)
-* **RAM:** Up to 1866/2133MHz (Mariko) / 1600MHz (Erista)
-* Over/undervolting support
-* Built-in configurator
-* Compatible with most homebrew
-
-> It is recommended to read the [guide](https://rentry.co/howtoget60fps) before proceeding, as this can help you get a *significant* performance boost over the default settings, often times with less power draw and heat output
-
----
-
-## Installation
-
-1. Ensure you have the latest versions of
-
-   * [Atmosphere](https://github.com/Atmosphere-NX/Atmosphere)
-   * [Ultrahand Overlay](https://github.com/ppkantorski/Ultrahand-Overlay)
-2. Download and extract the **Horizon OC Package** to the root of your SD card.
-3. If using **Hekate**, edit `hekate_ipl.ini` to include:
-
-   ```
-   kip1=atmosphere/kips/hoc.kip
-   ```
-
-   *(No changes needed if using fusee.)*
-
----
-
-## Configuration
-
-1. Open the Horizon OC Overlay
-2. Open the settings menu
-3. Adjust your overclocking settings as desired. A helpful guide can be found [here.](https://rentry.co/mariko#oc-settings-for-horizon-oc)
-4. Click **Save KIP Settings** to apply your configuration.
-
----
-
-## Building from Source
-
-Refer to COMPILATION.md
-
----
-## Clock table
-
-### MEM clocks (mhz)
-
-* 3200 → max on mariko, JEDEC.
-* 3166
-* 3133
-* 3100
-* 3066
-* 3033
-* 3000
-* 2966
-* 2933 → JEDEC.
-* 2900
-* 2866
-* 2833
-* 2800
-* 2766
-* 2733
-* 2700
-* 2666 → JEDEC.
-* 2633
-* 2600
-* 2566
-* 2533
-* 2500
-* 2466
-* 2433
-* 2400 → max on erista, JEDEC.
-* 2366
-* 2333
-* 2300
-* 2266
-* 2233
-* 2200
-* 2166
-* 2133 → Mariko JEDEC standard max (4266 Modules)
-* 2100
-* 2066
-* 2033
-* 2000
-* 1996 → JEDEC standard
-* 1966
-* 1933
-* 1900
-* 1866 → Mariko JEDEC standard max (3733 Modules)
-* 1833
-* 1800
-* 1766
-* 1733
-* 1700
-* 1666
-* 1633
-* 1600 → official docked, boost mode, Erista JEDEC standard max (3200 Modules), JEDEC.
-* 1331 → official handheld, JEDEC.
-* 1065
-* 800
-* 665
-
-### CPU clocks (mhz)
-* 2703 → mariko absolute max, dangerous
-* 2601 → unsafe
-* 2499
-* 2397 → mariko safe max with UV (low speedo)
-* 2295
-* 2193
-* 2091
-* 1963 → mariko no UV max clock
-* 1887
-* 1785 → erista no UV max clock, boost mode
-* 1683
-* 1581
-* 1428
-* 1326
-* 1224 → sdev oc
-* 1122
-* 1020 → official docked & handheld
-* 918
-* 816
-* 714
-* 612 → sleep mode
-
-### GPU clocks (mhz)
-* 1536 → absolute max clock on mariko. very dangerous
-* 1459
-* 1382
-* 1305
-* 1267 → NVIDIA T214(mariko) rating
-* 1228 → mariko High UV safe clock
-* 1152 → mariko hiOpt-15mV max clock
-* 1075 → mariko hiOpt max clock. absolute max clock on erista. very dangerous
-* 998 → NVIDIA T210 (erista) rating
-* 960 (erista only) → erista high uv/hiOpt-15mV safe max clock
-* 921 → erista no UV max clock
-* 844
-* 768 → official docked
-* 691
-* 614
-* 537
-* 460 → max handheld
-* 384 → official handheld
-* 307 → official handheld
-* 230
-* 153
-* 76 → boost mode
-
-**Notes:**
-1. On Erista, CPU in handheld is capped to 1581MHz
-2. GPU overclock is capped at 460MHz on erista in handheld
-3. On Mariko, cap with hiOpt is 614MHz, with hiOpt-15mV it is 691MHz and with High UV it's 768MHz
-4. Clocks higher than 768MHz on erista need the official charger is plugged in.
-
----
-
-## Credits
-* **Lightos's Cat** - Cat
-* **Souldbminer** - hoc-clk and loader development
-* **Lightos** - Loader patches development, hoc-clk development, guides
-* **TDRR** - HOC Logo Design
-* **tetetete-ctrl** - Website design
-* **SciresM** - Atmosphere CFW
-* **CTCaer** - L4T, Hekate, proper RAM timings
-* **KazushiMe** - Switch OC Suite
-* **Hanai3bi (Meha)** - Switch OC Suite, EOS, sys-clk-eos
-* **NaGaa95** - L4T-OC kernel, Status Monitor fork
-* **B3711 (halop)** - EOS, contributions
-* **sys-clk team (m4xw, p-sam, natinusala)** - sys-clk
-* **Dominatorul** - Soctherm driver, guides, general help
-* **ppkantorski** - Ultrahand sys-clk & Status Monitor fork
-* **MasaGratoR and ZachyCatGames** - General help
-* **MasaGratoR** - Status Monitor & Display Refresh Rate driver
-* **Dominatorul, Samybigio, Arcdelta, Miki, Happy, Winnerboi77, Blaise, Alvise, agjeococh, frost, letum00, and Xenshen** - Testing
-* **Samybigio2011, Miki** - Italian translations
-* **angelblaster** - Korean translations
-* **q1332348216-glitch** - Chinese translations
-* **Nvidia** - [Tegra X1 Technical Reference Manual](https://developer.nvidia.com/embedded/dlc/tegra-x1-technical-reference-manual), soctherm driver, L4T
diff --git a/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp b/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp
index c0482a40..221ba651 100644
Binary files a/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp and b/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp differ
diff --git a/dist/atmosphere/exosphere.bin b/dist/atmosphere/exosphere.bin
index 9315328e..147372e1 100644
Binary files a/dist/atmosphere/exosphere.bin and b/dist/atmosphere/exosphere.bin differ
diff --git a/dist/atmosphere/kips/hoc.kip b/dist/atmosphere/kips/hoc.kip
index 006812e2..279d87ce 100644
Binary files a/dist/atmosphere/kips/hoc.kip and b/dist/atmosphere/kips/hoc.kip differ
diff --git a/dist/config/horizon-oc/lang/es.json b/dist/config/horizon-oc/lang/es.json
index 546b4429..a938c1e3 100644
--- a/dist/config/horizon-oc/lang/es.json
+++ b/dist/config/horizon-oc/lang/es.json
@@ -2,140 +2,140 @@
     "Information": "Información",
     "IDDQ:": "IDDQ:",
     "Module: ": "Módulo:",
-    "sys-dock status:": "estado del sys-dock:",
+    "sys-dock status:": "Estado de sys-dock:",
     "SaltyNX status:": "Estado de SaltyNX:",
-    "RR Display status:": "Estado de visualización RR:",
-    "Wafer Position:": "Posición de la oblea:",
+    "RR Display status:": "Estado de pantalla RR:",
+    "Wafer Position:": "Posición del wafer:",
     "Credits": "Créditos",
     "Developers": "Desarrolladores",
     "Contributors": "Colaboradores",
-    "Testers": "Probadores",
-    "Special Thanks": "agradecimiento especial",
+    "Testers": "Testers",
+    "Special Thanks": "Agradecimientos especiales",
     "Unknown": "Desconocido",
     "Installed": "Instalado",
     "Not Installed": "No instalado",
     "X: %u Y: %u": "X: %u Y: %u",
-    "THE BEER-WARE LICENSE": "LA LICENCIA DE CERVEZA",
+    "THE BEER-WARE LICENSE": "LICENCIA BEER-WARE",
     "Default": "Predeterminado",
-    "Do Not Override": "No anular",
-    "Disabled": "Discapacitado",
-    "Enabled": "Habilitado",
+    "Do Not Override": "No sobrescribir",
+    "Disabled": "Desactivado",
+    "Enabled": "Activado",
     " \\ue0e3 Reset": "\\ue0e3 Restablecer",
     "Display": "Pantalla",
-    "Application changed\\n\\n": "Aplicación modificada\\n\\n",
-    "The running application changed\\n\\n": "La aplicación en ejecución cambió\\n\\n",
-    "while editing was going on.": "mientras se realizaba la edición.",
-    "Board": "tablero",
+    "Application changed\\n\\n": "Aplicación cambiada\\n\\n",
+    "The running application changed\\n\\n": "La aplicación en ejecución ha cambiado\\n\\n",
+    "while editing was going on.": "mientras se estaba editando.",
+    "Board": "Placa",
     "%u.%u%u mV": "%u.%u%u mV",
-    "Could not connect to hoc-clk sysmodule.\\n\\n": "No se pudo conectar al módulo del sistema hoc-clk.\\n\\n",
-    "Please make sure everything is\\n\\n": "Por favor asegúrese de que todo esté\\n\\n",
-    "correctly installed and enabled.": "correctamente instalado y habilitado.",
-    "Fatal error": "error fatal",
-    "Temporary Overrides ": "Anulaciones temporales",
-    "Sleep Mode": "Modo de suspensión",
-    "Stock": "Valores",
-    "Dev OC": "Desarrollador OC",
-    "Boost Mode": "Modo de impulso",
+    "Could not connect to hoc-clk sysmodule.\\n\\n": "No se pudo conectar al sysmodule hoc-clk.\\n\\n",
+    "Please make sure everything is\\n\\n": "Asegúrate de que todo esté\\n\\n",
+    "correctly installed and enabled.": "correctamente instalado y activado.",
+    "Fatal error": "Error fatal",
+    "Temporary Overrides ": "Ajustes temporales",
+    "Sleep Mode": "Modo reposo",
+    "Stock": "Valores de fábrica",
+    "Dev OC": "OC de desarrollo",
+    "Boost Mode": "Modo boost",
     "Safe Max": "Máximo seguro",
-    "Unsafe Max": "Máximo inseguro",
+    "Unsafe Max": "Máximo no seguro",
     "Absolute Max": "Máximo absoluto",
-    "Handheld Safe Max": "Caja fuerte de mano máx.",
-    "Enable": "Habilitar",
+    "Handheld Safe Max": "Máximo seguro en portátil",
+    "Enable": "Activar",
     "Edit App Profile": "Editar perfil de aplicación",
     "Edit Global Profile": "Editar perfil global",
-    "Temporary Overrides": "Anulaciones temporales",
+    "Temporary Overrides": "Ajustes temporales",
     "Settings": "Configuración",
     "About": "Acerca de",
-    "Compiling with minimal features": "Compilando con características mínimas",
-    "General Settings": "Configuraciones generales",
-    "Governor Settings": "Configuración del gobernador",
-    "Safety Settings": "Configuraciones de seguridad",
-    "Save KIP Settings": "Guardar configuración de KIP",
+    "Compiling with minimal features": "Compilado con funciones mínimas",
+    "General Settings": "Configuración general",
+    "Governor Settings": "Configuración del governor",
+    "Safety Settings": "Configuración de seguridad",
+    "Save KIP Settings": "Guardar configuración KIP",
     "RAM Settings": "Configuración de RAM",
-    "CPU Settings": "Configuración de la CPU",
+    "CPU Settings": "Configuración de CPU",
     "GPU Settings": "Configuración de GPU",
     "Display Settings": "Configuración de pantalla",
     "Experimental": "Experimental",
-    "GPU Scheduling Override Method": "Método de anulación de programación de GPU",
-    "can be dangerous and may cause": "puede ser peligroso y puede causar",
-    "damage to your battery or charger!": "¡Daños a su batería o cargador!",
-    "Charge Current Override": "Anulación de corriente de carga",
+    "GPU Scheduling Override Method": "Método de sobrescritura del scheduling de GPU",
+    "can be dangerous and may cause": "puede ser peligroso y causar",
+    "damage to your battery or charger!": "daños a la batería o al cargador.",
+    "Charge Current Override": "Sobrescritura de corriente de carga",
     "RAM Voltage Display Mode": "Modo de visualización de voltaje de RAM",
     "Polling Interval": "Intervalo de sondeo",
-    "CPU Governor Minimum Frequency": "Frecuencia mínima del gobernador de CPU",
-    "refresh rates may cause stress": "Las frecuencias de actualización pueden causar estrés.",
-    "or damage to your display! ": "o daños a su pantalla!",
-    "Proceed at your own risk!": "¡Continúe bajo su propio riesgo!",
-    "Max Handheld Display": "Pantalla portátil máxima",
-    "Display Clock": "Reloj de pantalla",
-    "Official Rating": "Calificación oficial",
+    "CPU Governor Minimum Frequency": "Frecuencia mínima del governor de CPU",
+    "refresh rates may cause stress": "las tasas de refresco pueden causar estrés",
+    "or damage to your display! ": "o dañar la pantalla.",
+    "Proceed at your own risk!": "¡Úsalo bajo tu propio riesgo!",
+    "Max Handheld Display": "Frecuencia máxima de pantalla en portátil",
+    "Display Clock": "Frecuencia de pantalla",
+    "Official Rating": "Valor oficial",
     "TDP Threshold": "Umbral de TDP",
-    "Power": "poder",
-    "Thermal Throttle Limit": "Límite del acelerador térmico",
-    "HP Mode": "Modo HP",
+    "Power": "Potencia",
+    "Thermal Throttle Limit": "Límite de thermal throttling",
+    "HP Mode": "Modo alto rendimiento",
     "Default (Mariko)": "Predeterminado (Mariko)",
     "Default (Erista)": "Predeterminado (Erista)",
-    "Rating": "Calificación",
-    "Safe Max (Mariko)": "Max seguro (Mariko)",
-    "Safe Max (Erista)": "Safe Max (Erista)",
-    "RAM VDD2 Voltage": "Voltaje RAM VDD2",
-    "Voltage": "voltaje",
-    "RAM VDDQ Voltage": "Voltaje RAM VDDQ",
-    "RAM Frequency Editor": "Editor de frecuencia RAM",
-    "JEDEC.": "JEDEC.",
-    "High speedo needed!": "¡Se necesita alta velocidad!",
-    "3333MHz (Needs extreme Speedo/PLL)": "3333MHz (Necesita Speedo/PLL extremo)",
-    "3366MHz (Needs extreme Speedo/PLL)": "3366MHz (Necesita Speedo/PLL extremo)",
-    "3400MHz (Needs extreme Speedo/PLL)": "3400MHz (Necesita Speedo/PLL extremo)",
-    "3433MHz (Needs ridiculous Speedo/PLL)": "3433MHz (Necesita Speedo/PLL ridículo)",
-    "3466MHz (Needs ridiculous Speedo/PLL)": "3466MHz (Necesita Speedo/PLL ridículo)",
-    "3500MHz (Needs ridiculous Speedo/PLL)": "3500MHz (Necesita Speedo/PLL ridículo)",
-    "Ram Max Clock": "Ram Max Reloj",
-    "RAM Latency Editor": "Editor de latencia de RAM",
-    "RAM Timing Reductions": "Reducciones de tiempo de RAM",
-    "Memory Timings": "Tiempos de memoria",
+    "Rating": "Valor",
+    "Safe Max (Mariko)": "Máximo seguro (Mariko)",
+    "Safe Max (Erista)": "Máximo seguro (Erista)",
+    "RAM VDD2 Voltage": "Voltaje VDD2 de RAM",
+    "Voltage": "Voltaje",
+    "RAM VDDQ Voltage": "Voltaje VDDQ de RAM",
+    "RAM Frequency Editor": "Editor de frecuencia de RAM",
+    "JEDEC.": "JEDEC",
+    "High speedo needed!": "¡Se necesita alto speedo!",
+    "3333MHz (Needs extreme Speedo/PLL)": "3333MHz (requiere Speedo/PLL extremo)",
+    "3366MHz (Needs extreme Speedo/PLL)": "3366MHz (requiere Speedo/PLL extremo)",
+    "3400MHz (Needs extreme Speedo/PLL)": "3400MHz (requiere Speedo/PLL extremo)",
+    "3433MHz (Needs ridiculous Speedo/PLL)": "3433MHz (requiere Speedo/PLL muy alto)",
+    "3466MHz (Needs ridiculous Speedo/PLL)": "3466MHz (requiere Speedo/PLL muy alto)",
+    "3500MHz (Needs ridiculous Speedo/PLL)": "3500MHz (requiere Speedo/PLL muy alto)",
+    "Ram Max Clock": "Frecuencia máxima de RAM",
+    "RAM Latency Editor": "Editor de latencias de RAM",
+    "RAM Timing Reductions": "Reducción de timings de RAM",
+    "Memory Timings": "Timings de memoria",
     "Advanced": "Avanzado",
-    "t6 tRTW Fine Tune": "t6 tRTW Ajuste fino",
+    "t6 tRTW Fine Tune": "Ajuste fino t6 tRTW",
     "tRTW Fine Tune": "Ajuste fino tRTW",
-    "t7 tWTR Fine Tune": "t7 tWTR Ajuste fino",
-    "tWTR Fine Tune": "Ajuste fino de tWTR",
-    "Memory Latencies": "Latencias de la memoria",
-    "Read Latency": "Leer latencia",
+    "t7 tWTR Fine Tune": "Ajuste fino t7 tWTR",
+    "tWTR Fine Tune": "Ajuste fino tWTR",
+    "Memory Latencies": "Latencias de memoria",
+    "Read Latency": "Latencia de lectura",
     "Write Latency": "Latencia de escritura",
-    "CPU Boost Clock": "Reloj de aumento de CPU",
-    "CPU UV": "procesador ultravioleta",
+    "CPU Boost Clock": "Frecuencia boost de CPU",
+    "CPU UV": "Undervolt de CPU",
     "CPU Unlock": "Desbloqueo de CPU",
-    "CPU VMIN": "CPU VMIN",
-    "CPU Max Voltage": "Voltaje máximo de la CPU",
-    "CPU Max Clock": "Reloj máximo de CPU",
-    "Extreme UV Table": "Mesa UV extrema",
-    "CPU UV Table": "Tabla UV de CPU",
-    "CPU Low UV": "CPU baja radiación ultravioleta",
-    "CPU High UV": "CPU alta UV",
+    "CPU VMIN": "VMIN de CPU",
+    "CPU Max Voltage": "Voltaje máximo de CPU",
+    "CPU Max Clock": "Frecuencia máxima de CPU",
+    "Extreme UV Table": "Tabla de undervolt extrema",
+    "CPU UV Table": "Tabla de undervolt de CPU",
+    "CPU Low UV": "Undervolt bajo de CPU",
+    "CPU High UV": "Undervolt alto de CPU",
     "CPU Low VMIN": "VMIN bajo de CPU",
     "CPU High VMIN": "VMIN alto de CPU",
-    "No Undervolt": "Sin subvoltaje",
-    "SLT Table": "Mesa TR",
+    "No Undervolt": "Sin undervolt",
+    "SLT Table": "Tabla SLT",
     "HiOPT Table": "Tabla HiOPT",
-    "GPU Undervolt Table": "Tabla de subvoltaje de GPU",
+    "GPU Undervolt Table": "Tabla de undervolt de GPU",
     "GPU Minimum Voltage": "Voltaje mínimo de GPU",
-    "Calculate GPU Vmin": "Calcular GPU Vmin",
-    "GPU VMIN": "GPU VMIN",
+    "Calculate GPU Vmin": "Calcular Vmin de GPU",
+    "GPU VMIN": "VMIN de GPU",
     "GPU Maximum Voltage": "Voltaje máximo de GPU",
-    "GPU Voltage Offset": "Compensación de voltaje de GPU",
-    "Do not override": "no anular",
-    "Enabled (Default)": "Habilitado (predeterminado)",
-    "96.6% limit": "límite del 96,6%",
-    "99.7% limit": "límite del 99,7%",
-    "GPU Scheduling Override": "Anulación de programación de GPU",
-    "Official Service": "Servicio Oficial",
-    "GPU DVFS Mode": "Modo GPU DVFS",
-    "GPU DVFS Offset": "Compensación DVFS de GPU",
+    "GPU Voltage Offset": "Offset de voltaje de GPU",
+    "Do not override": "No sobrescribir",
+    "Enabled (Default)": "Activado (predeterminado)",
+    "96.6% limit": "Límite 96,6%",
+    "99.7% limit": "Límite 99,7%",
+    "GPU Scheduling Override": "Sobrescritura de scheduling de GPU",
+    "Official Service": "Servicio oficial",
+    "GPU DVFS Mode": "Modo DVFS de GPU",
+    "GPU DVFS Offset": "Offset DVFS de GPU",
     "GPU Voltage Table": "Tabla de voltaje de GPU",
     "GPU Custom Table (mV)": "Tabla personalizada de GPU (mV)",
-    "1075MHz without UV, 1152MHz on SLT": "1075MHz sin UV, 1152MHz en SLT",
-    "or 1228MHz on HiOPT can cause ": "o 1228MHz en HiOPT pueden causar",
-    "permanent damage to your Switch!": "¡Daño permanente a tu Switch!",
-    "921MHz without UV and 960MHz on": "921MHz sin UV y 960MHz encendido",
-    "SLT or HiOPT can cause ": "SLT o HiOPT pueden causar"
-}
+    "1075MHz without UV, 1152MHz on SLT": "1075MHz sin undervolt, 1152MHz en SLT",
+    "or 1228MHz on HiOPT can cause ": "o 1228MHz en HiOPT pueden causar ",
+    "permanent damage to your Switch!": "¡daño permanente a tu Switch!",
+    "921MHz without UV and 960MHz on": "921MHz sin undervolt y 960MHz en",
+    "SLT or HiOPT can cause ": "SLT o HiOPT pueden causar "
+}
\ No newline at end of file
diff --git a/dist/config/horizon-oc/lang/fr.json b/dist/config/horizon-oc/lang/fr.json
index 2494473a..e4e41177 100644
--- a/dist/config/horizon-oc/lang/fr.json
+++ b/dist/config/horizon-oc/lang/fr.json
@@ -1,11 +1,11 @@
 {
     "Information": "Informations",
-    "IDDQ:": "IDDQ :",
-    "Module: ": "Module :",
-    "sys-dock status:": "état du dock système :",
-    "SaltyNX status:": "Statut SaltyNX :",
-    "RR Display status:": "Etat d'affichage RR :",
-    "Wafer Position:": "Position de la plaquette :",
+    "IDDQ:": "IDDQ :",
+    "Module: ": "Module :",
+    "sys-dock status:": "Statut de sys-dock :",
+    "SaltyNX status:": "Statut de SaltyNX :",
+    "RR Display status:": "Statut de l'affichage RR :",
+    "Wafer Position:": "Position du wafer :",
     "Credits": "Crédits",
     "Developers": "Développeurs",
     "Contributors": "Contributeurs",
@@ -15,127 +15,127 @@
     "Installed": "Installé",
     "Not Installed": "Non installé",
     "X: %u Y: %u": "X : %u Y : %u",
-    "THE BEER-WARE LICENSE": "LA LICENCE DE LA BIÈRE",
+    "THE BEER-WARE LICENSE": "LA LICENCE BEER-WARE",
     "Default": "Par défaut",
     "Do Not Override": "Ne pas remplacer",
     "Disabled": "Désactivé",
     "Enabled": "Activé",
     " \\ue0e3 Reset": "\\ue0e3 Réinitialiser",
-    "Display": "Affichage",
+    "Display": "Écran",
     "Application changed\\n\\n": "Application modifiée\\n\\n",
     "The running application changed\\n\\n": "L'application en cours d'exécution a changé\\n\\n",
-    "while editing was going on.": "pendant le montage.",
-    "Board": "Conseil",
+    "while editing was going on.": "pendant la modification.",
+    "Board": "Carte",
     "%u.%u%u mV": "%u.%u%u mV",
-    "Could not connect to hoc-clk sysmodule.\\n\\n": "Impossible de se connecter au module système hoc-clk.\\n\\n",
+    "Could not connect to hoc-clk sysmodule.\\n\\n": "Impossible de se connecter au sysmodule hoc-clk.\\n\\n",
     "Please make sure everything is\\n\\n": "Veuillez vous assurer que tout est\\n\\n",
     "correctly installed and enabled.": "correctement installé et activé.",
     "Fatal error": "Erreur fatale",
-    "Temporary Overrides ": "Remplacements temporaires",
+    "Temporary Overrides ": "Forçages temporaires ",
     "Sleep Mode": "Mode veille",
-    "Stock": "Actions",
-    "Dev OC": "Développeur OC",
+    "Stock": "D'origine",
+    "Dev OC": "OC Développeur",
     "Boost Mode": "Mode Boost",
-    "Safe Max": "Coffre-fort maximum",
-    "Unsafe Max": "Dangereux Max",
+    "Safe Max": "Max sûr",
+    "Unsafe Max": "Max non sûr",
     "Absolute Max": "Max absolu",
-    "Handheld Safe Max": "Coffre-fort portatif Max",
+    "Handheld Safe Max": "Max sûr (mode portable)",
     "Enable": "Activer",
-    "Edit App Profile": "Modifier le profil de l'application",
+    "Edit App Profile": "Modifier le profil de l'app",
     "Edit Global Profile": "Modifier le profil global",
-    "Temporary Overrides": "Remplacements temporaires",
+    "Temporary Overrides": "Forçages temporaires",
     "Settings": "Paramètres",
     "About": "À propos",
-    "Compiling with minimal features": "Compilation avec des fonctionnalités minimales",
+    "Compiling with minimal features": "Compilation avec fonctionnalités minimales",
     "General Settings": "Paramètres généraux",
     "Governor Settings": "Paramètres du gouverneur",
     "Safety Settings": "Paramètres de sécurité",
     "Save KIP Settings": "Enregistrer les paramètres KIP",
-    "RAM Settings": "Paramètres de la RAM",
-    "CPU Settings": "Paramètres du processeur",
-    "GPU Settings": "Paramètres du processeur graphique",
+    "RAM Settings": "Paramètres RAM",
+    "CPU Settings": "Paramètres CPU",
+    "GPU Settings": "Paramètres GPU",
     "Display Settings": "Paramètres d'affichage",
     "Experimental": "Expérimental",
-    "GPU Scheduling Override Method": "Méthode de remplacement de la planification GPU",
-    "can be dangerous and may cause": "peut être dangereux et provoquer",
-    "damage to your battery or charger!": "dommages à votre batterie ou à votre chargeur !",
-    "Charge Current Override": "Remplacement du courant de charge",
-    "RAM Voltage Display Mode": "Mode d'affichage de la tension de la RAM",
+    "GPU Scheduling Override Method": "Méthode de Forçage de l'ordonnancement GPU",
+    "can be dangerous and may cause": "peut être dangereux et causer des",
+    "damage to your battery or charger!": "dommages à votre batterie ou chargeur !",
+    "Charge Current Override": "Forçage du courant de charge",
+    "RAM Voltage Display Mode": "Mode d'affichage de la tension RAM",
     "Polling Interval": "Intervalle d'interrogation",
-    "CPU Governor Minimum Frequency": "Fréquence minimale du gouverneur du processeur",
-    "refresh rates may cause stress": "les taux de rafraîchissement peuvent causer du stress",
-    "or damage to your display! ": "ou endommager votre écran !",
-    "Proceed at your own risk!": "Procédez à vos propres risques !",
-    "Max Handheld Display": "Affichage portable maximum",
-    "Display Clock": "Affichage de l'horloge",
+    "CPU Governor Minimum Frequency": "Fréquence minimale du gouverneur CPU",
+    "refresh rates may cause stress": "les taux de rafraîchissement peuvent stresser",
+    "or damage to your display! ": "ou endommager votre écran !",
+    "Proceed at your own risk!": "À utiliser à vos propres risques !",
+    "Max Handheld Display": "Affichage portable max",
+    "Display Clock": "Fréquence d'affichage",
     "Official Rating": "Classement officiel",
     "TDP Threshold": "Seuil TDP",
-    "Power": "Puissance",
-    "Thermal Throttle Limit": "Limite d'accélérateur thermique",
+    "Power": "Alimentation",
+    "Thermal Throttle Limit": "Limite d'étranglement thermique",
     "HP Mode": "Mode HP",
     "Default (Mariko)": "Par défaut (Mariko)",
     "Default (Erista)": "Par défaut (Erista)",
-    "Rating": "Note",
-    "Safe Max (Mariko)": "Coffre-fort Max (Mariko)",
-    "Safe Max (Erista)": "Coffre-fort Max (Erista)",
-    "RAM VDD2 Voltage": "Tension de la RAM VDD2",
+    "Rating": "Évaluation",
+    "Safe Max (Mariko)": "Max sûr (Mariko)",
+    "Safe Max (Erista)": "Max sûr (Erista)",
+    "RAM VDD2 Voltage": "Tension RAM VDD2",
     "Voltage": "Tension",
-    "RAM VDDQ Voltage": "Tension VDDQ de la RAM",
+    "RAM VDDQ Voltage": "Tension RAM VDDQ",
     "RAM Frequency Editor": "Éditeur de fréquence RAM",
     "JEDEC.": "JEDEC.",
-    "High speedo needed!": "Besoin d'un speedo haut !",
-    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (nécessite un Speedo/PLL extrême)",
-    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (nécessite un Speedo/PLL extrême)",
-    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (nécessite un Speedo/PLL extrême)",
-    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (nécessite un Speedo/PLL ridicule)",
-    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (nécessite un Speedo/PLL ridicule)",
-    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (nécessite un Speedo/PLL ridicule)",
-    "Ram Max Clock": "Ram Max Horloge",
+    "High speedo needed!": "Speedo élevé requis !",
+    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (nécessite Speedo/PLL extrême)",
+    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (nécessite Speedo/PLL extrême)",
+    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (nécessite Speedo/PLL extrême)",
+    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (nécessite Speedo/PLL ridicule)",
+    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (nécessite Speedo/PLL ridicule)",
+    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (nécessite Speedo/PLL ridicule)",
+    "Ram Max Clock": "Fréquence RAM max",
     "RAM Latency Editor": "Éditeur de latence RAM",
-    "RAM Timing Reductions": "Réductions de synchronisation de la RAM",
-    "Memory Timings": "Horaires de mémoire",
+    "RAM Timing Reductions": "Réductions des timings RAM",
+    "Memory Timings": "Timings mémoire",
     "Advanced": "Avancé",
-    "t6 tRTW Fine Tune": "t6 tRTW réglage fin",
-    "tRTW Fine Tune": "tRTW Réglage fin",
-    "t7 tWTR Fine Tune": "t7 tWTR réglage fin",
-    "tWTR Fine Tune": "Réglage fin du tWTR",
-    "Memory Latencies": "Latences de mémoire",
+    "t6 tRTW Fine Tune": "Ajustement précis t6 tRTW",
+    "tRTW Fine Tune": "Ajustement précis tRTW",
+    "t7 tWTR Fine Tune": "Ajustement précis t7 tWTR",
+    "tWTR Fine Tune": "Ajustement précis tWTR",
+    "Memory Latencies": "Latences mémoire",
     "Read Latency": "Latence de lecture",
     "Write Latency": "Latence d'écriture",
-    "CPU Boost Clock": "Horloge d'augmentation du processeur",
-    "CPU UV": "UV du processeur",
-    "CPU Unlock": "Déverrouillage du processeur",
+    "CPU Boost Clock": "Fréquence Boost CPU",
+    "CPU UV": "UV CPU",
+    "CPU Unlock": "Déverrouillage CPU",
     "CPU VMIN": "CPU VMIN",
-    "CPU Max Voltage": "Tension maximale du processeur",
-    "CPU Max Clock": "Horloge maximale du processeur",
-    "Extreme UV Table": "Table UV Extrême",
-    "CPU UV Table": "Tableau UV du processeur",
-    "CPU Low UV": "CPU faible UV",
-    "CPU High UV": "CPU UV élevé",
-    "CPU Low VMIN": "CPU faible VMIN",
-    "CPU High VMIN": "Processeur VMIN élevé",
-    "No Undervolt": "Pas de sous-tension",
-    "SLT Table": "Tableau SLT",
-    "HiOPT Table": "Tableau HiOPT",
-    "GPU Undervolt Table": "Tableau de sous-tension GPU",
-    "GPU Minimum Voltage": "Tension minimale du GPU",
-    "Calculate GPU Vmin": "Calculer la Vmin du GPU",
+    "CPU Max Voltage": "Tension CPU max",
+    "CPU Max Clock": "Fréquence CPU max",
+    "Extreme UV Table": "Table d'UV extrême",
+    "CPU UV Table": "Table d'UV CPU",
+    "CPU Low UV": "UV CPU faible",
+    "CPU High UV": "UV CPU élevé",
+    "CPU Low VMIN": "VMIN CPU faible",
+    "CPU High VMIN": "VMIN CPU élevé",
+    "No Undervolt": "Aucun Undervolt",
+    "SLT Table": "Table SLT",
+    "HiOPT Table": "Table HiOPT",
+    "GPU Undervolt Table": "Table d'undervolt GPU",
+    "GPU Minimum Voltage": "Tension GPU minimale",
+    "Calculate GPU Vmin": "Calculer Vmin GPU",
     "GPU VMIN": "GPU VMIN",
-    "GPU Maximum Voltage": "Tension maximale du GPU",
-    "GPU Voltage Offset": "Décalage de tension du GPU",
-    "Do not override": "Ne remplacez pas",
+    "GPU Maximum Voltage": "Tension GPU maximale",
+    "GPU Voltage Offset": "Offset de tension GPU",
+    "Do not override": "Ne pas remplacer",
     "Enabled (Default)": "Activé (par défaut)",
-    "96.6% limit": "Limite de 96,6 %",
-    "99.7% limit": "Limite de 99,7 %",
-    "GPU Scheduling Override": "Remplacement de la planification GPU",
+    "96.6% limit": "Limite de 96,6 %",
+    "99.7% limit": "Limite de 99,7 %",
+    "GPU Scheduling Override": "Forçage de l'ordonnancement GPU",
     "Official Service": "Service officiel",
     "GPU DVFS Mode": "Mode GPU DVFS",
-    "GPU DVFS Offset": "Décalage GPU DVFS",
-    "GPU Voltage Table": "Tableau de tension du GPU",
-    "GPU Custom Table (mV)": "Tableau personnalisé GPU (mV)",
+    "GPU DVFS Offset": "Offset GPU DVFS",
+    "GPU Voltage Table": "Table de tension GPU",
+    "GPU Custom Table (mV)": "Table de GPU personnalisée (mV)",
     "1075MHz without UV, 1152MHz on SLT": "1075 MHz sans UV, 1152 MHz sur SLT",
-    "or 1228MHz on HiOPT can cause ": "ou 1228 MHz sur HiOPT peut provoquer",
-    "permanent damage to your Switch!": "dommages permanents à votre Switch !",
-    "921MHz without UV and 960MHz on": "921 MHz sans UV et 960 MHz activé",
-    "SLT or HiOPT can cause ": "SLT ou HiOPT peuvent provoquer"
+    "or 1228MHz on HiOPT can cause ": "ou 1228 MHz sur HiOPT peut causer des",
+    "permanent damage to your Switch!": "dommages permanents à votre Switch !",
+    "921MHz without UV and 960MHz on": "921 MHz sans UV et 960 MHz sur",
+    "SLT or HiOPT can cause ": "SLT ou HiOPT peuvent causer des"
 }
diff --git a/dist/config/horizon-oc/lang/it.json b/dist/config/horizon-oc/lang/it.json
index d7056f36..5e65fdae 100644
--- a/dist/config/horizon-oc/lang/it.json
+++ b/dist/config/horizon-oc/lang/it.json
@@ -2,140 +2,140 @@
     "Information": "Informazioni",
     "IDDQ:": "IDDQ:",
     "Module: ": "Modulo:",
-    "sys-dock status:": "stato del dock di sistema:",
+    "sys-dock status:": "stato di sys-dock",
     "SaltyNX status:": "Stato di SaltyNX:",
-    "RR Display status:": "Stato di visualizzazione RR:",
-    "Wafer Position:": "Posizione del wafer:",
+    "RR Display status:": "Stato del RR:",
+    "Wafer Position:": "Posizione nel Wafer:",
     "Credits": "Crediti",
     "Developers": "Sviluppatori",
     "Contributors": "Collaboratori",
     "Testers": "Tester",
-    "Special Thanks": "Un ringraziamento speciale",
+    "Special Thanks": "Un Ringraziamento Speciale",
     "Unknown": "Sconosciuto",
     "Installed": "Installato",
     "Not Installed": "Non installato",
     "X: %u Y: %u": "X: %u Y: %u",
-    "THE BEER-WARE LICENSE": "LA LICENZA PER GLI ARTICOLI DI BIRRA",
+    "THE BEER-WARE LICENSE": "THE BEER-WARE LICENSE",
     "Default": "Predefinito",
-    "Do Not Override": "Non sovrascrivere",
+    "Do Not Override": "Non Sovrascrivere",
     "Disabled": "Disabilitato",
     "Enabled": "Abilitato",
     " \\ue0e3 Reset": "\\ue0e3 Ripristina",
-    "Display": "Visualizzazione",
+    "Display": "Schermo",
     "Application changed\\n\\n": "Applicazione modificata\\n\\n",
     "The running application changed\\n\\n": "L'applicazione in esecuzione è cambiata\\n\\n",
     "while editing was going on.": "mentre era in corso la modifica.",
-    "Board": "Consiglio",
+    "Board": "Scheda",
     "%u.%u%u mV": "%u.%u%u mV",
-    "Could not connect to hoc-clk sysmodule.\\n\\n": "Impossibile connettersi al modulo di sistema hoc-clk.\\n\\n",
+    "Could not connect to hoc-clk sysmodule.\\n\\n": "Impossibile connettersi al sysmodule hoc-clk.\\n\\n",
     "Please make sure everything is\\n\\n": "Assicurati che tutto sia\\n\\n",
     "correctly installed and enabled.": "correttamente installato e abilitato.",
     "Fatal error": "Errore fatale",
-    "Temporary Overrides ": "Sostituzioni temporanee",
-    "Sleep Mode": "Modalità di sospensione",
-    "Stock": "Magazzino",
-    "Dev OC": "OC di sviluppo",
-    "Boost Mode": "Modalità potenziamento",
-    "Safe Max": "Sicuro massimo",
-    "Unsafe Max": "Non sicuro Max",
-    "Absolute Max": "Massimo assoluto",
-    "Handheld Safe Max": "Cassaforte portatile max",
+    "Temporary Overrides ": "Sostituzioni Temporanee",
+    "Sleep Mode": "Modalità di Sospensione",
+    "Stock": "Originale",
+    "Dev OC": "OC dev",
+    "Boost Mode": "Modalità Boost",
+    "Safe Max": "Massimo Sicuro",
+    "Unsafe Max": "Massimo Non Sicuro",
+    "Absolute Max": "Massimo Assoluto",
+    "Handheld Safe Max": "Massimo Sicuro Modalità Portatile",
     "Enable": "Abilita",
-    "Edit App Profile": "Modifica profilo dell'app",
-    "Edit Global Profile": "Modifica profilo globale",
-    "Temporary Overrides": "Sostituzioni temporanee",
+    "Edit App Profile": "Modifica Profilo Dell'App",
+    "Edit Global Profile": "Modifica Profilo Globale",
+    "Temporary Overrides": "Sostituzioni Temporanee",
     "Settings": "Impostazioni",
-    "About": "Circa",
+    "About": "A Riguardo Di",
     "Compiling with minimal features": "Compilazione con funzionalità minime",
-    "General Settings": "Impostazioni generali",
-    "Governor Settings": "Impostazioni del governatore",
-    "Safety Settings": "Impostazioni di sicurezza",
-    "Save KIP Settings": "Salva le impostazioni KIP",
+    "General Settings": "Impostazioni Generali",
+    "Governor Settings": "Impostazioni Del Governor",
+    "Safety Settings": "Impostazioni Di Sicurezza",
+    "Save KIP Settings": "Salva le impostazioni del KIP",
     "RAM Settings": "Impostazioni della RAM",
     "CPU Settings": "Impostazioni della CPU",
     "GPU Settings": "Impostazioni della GPU",
-    "Display Settings": "Impostazioni di visualizzazione",
+    "Display Settings": "Impostazioni dello Schermo",
     "Experimental": "Sperimentale",
-    "GPU Scheduling Override Method": "Metodo di override della pianificazione GPU",
+    "GPU Scheduling Override Method": "Metodo di override dello scheduling GPU",
     "can be dangerous and may cause": "può essere pericoloso e può causare",
     "damage to your battery or charger!": "danni alla batteria o al caricabatterie!",
-    "Charge Current Override": "Override della corrente di carica",
-    "RAM Voltage Display Mode": "Modalità di visualizzazione della tensione RAM",
+    "Charge Current Override": "Override della Corrente di Carica",
+    "RAM Voltage Display Mode": "Modalità di Visualizzazione della Tensione RAM",
     "Polling Interval": "Intervallo di polling",
-    "CPU Governor Minimum Frequency": "Frequenza minima del governatore della CPU",
+    "CPU Governor Minimum Frequency": "Frequenza minima del Governor della CPU",
     "refresh rates may cause stress": "le frequenze di aggiornamento possono causare stress",
     "or damage to your display! ": "o danni al display!",
     "Proceed at your own risk!": "Procedi a tuo rischio e pericolo!",
-    "Max Handheld Display": "Display portatile massimo",
-    "Display Clock": "Visualizza orologio",
-    "Official Rating": "Valutazione ufficiale",
+    "Max Handheld Display": "Display Massimo in Modalità Portatile",
+    "Display Clock": "Frequenza del Display",
+    "Official Rating": "Rating Ufficiale",
     "TDP Threshold": "Soglia TDP",
     "Power": "Potenza",
-    "Thermal Throttle Limit": "Limite della valvola termica",
+    "Thermal Throttle Limit": "Limite Termico",
     "HP Mode": "Modalità HP",
     "Default (Mariko)": "Predefinito (Mariko)",
     "Default (Erista)": "Predefinito (Erista)",
     "Rating": "Valutazione",
-    "Safe Max (Mariko)": "Safe Max (Mariko)",
-    "Safe Max (Erista)": "Safe Max (Erista)",
+    "Safe Max (Mariko)": "Massimo Sicuro (Mariko)",
+    "Safe Max (Erista)": "Massimo Sicuro (Erista)",
     "RAM VDD2 Voltage": "Tensione RAM VDD2",
     "Voltage": "Voltaggio",
     "RAM VDDQ Voltage": "Voltaggio VDDQ della RAM",
     "RAM Frequency Editor": "Editor della frequenza RAM",
     "JEDEC.": "JEDEC.",
-    "High speedo needed!": "È necessaria l'alta velocità!",
-    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (richiede Speedo/PLL estremo)",
-    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (richiede Speedo/PLL estremo)",
-    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (richiede Speedo/PLL estremo)",
-    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (è necessario un ridicolo Speedo/PLL)",
-    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (è necessario un ridicolo Speedo/PLL)",
-    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (è necessario un ridicolo Speedo/PLL)",
-    "Ram Max Clock": "Orologio Ram Max",
-    "RAM Latency Editor": "Editor della latenza RAM",
-    "RAM Timing Reductions": "Riduzioni della temporizzazione della RAM",
-    "Memory Timings": "Tempi di memoria",
+    "High speedo needed!": "Alto Valore Speedo Necessario!",
+    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (richiede Speedo/PLL altissimo)",
+    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (richiede Speedo/PLL altissimo)",
+    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (richiede Speedo/PLL altissimo)",
+    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (richiede Speedo/PLL estremo)",
+    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (richiede Speedo/PLL estremo)",
+    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (richiede Speedo/PLL estremo)",
+    "Ram Max Clock": "Frequenza Massima Ram",
+    "RAM Latency Editor": "Editor della Latenza RAM",
+    "RAM Timing Reductions": "Riduzioni dei Timing della RAM",
+    "Memory Timings": "Timing di Memoria",
     "Advanced": "Avanzato",
-    "t6 tRTW Fine Tune": "t6 tRTW Sintonia fine",
-    "tRTW Fine Tune": "tRTW Sintonia fine",
-    "t7 tWTR Fine Tune": "t7 tWTR Sintonia fine",
-    "tWTR Fine Tune": "tWTR Sintonia fine",
-    "Memory Latencies": "Latenza della memoria",
-    "Read Latency": "Leggi latenza",
-    "Write Latency": "Scrivi latenza",
-    "CPU Boost Clock": "Orologio di potenziamento della CPU",
-    "CPU UV": "UV della CPU",
+    "t6 tRTW Fine Tune": "Regolazione Fine t6 tRTW",
+    "tRTW Fine Tune": "Regolazione Fine tRTW",
+    "t7 tWTR Fine Tune": "Regolazione Fine t7 tWTR",
+    "tWTR Fine Tune": "Regolazione Fine tWTR",
+    "Memory Latencies": "Latenza della Memoria",
+    "Read Latency": "Latenza di Lettura",
+    "Write Latency": "Latenza di Scrittura",
+    "CPU Boost Clock": "Frequenza CPU in Boost",
+    "CPU UV": "Undervolt CPU",
     "CPU Unlock": "Sblocco della CPU",
-    "CPU VMIN": "CPUVMIN",
+    "CPU VMIN": "CPU VMIN",
     "CPU Max Voltage": "Voltaggio massimo della CPU",
-    "CPU Max Clock": "Orologio massimo della CPU",
-    "Extreme UV Table": "Tavolo UV estremo",
+    "CPU Max Clock": "Frequenza massima della CPU",
+    "Extreme UV Table": "Tabella UV estremo",
     "CPU UV Table": "Tabella UV della CPU",
-    "CPU Low UV": "CPU con raggi UV bassi",
-    "CPU High UV": "UV elevato della CPU",
-    "CPU Low VMIN": "VMIN CPU basso",
-    "CPU High VMIN": "CPU alta VMIN",
-    "No Undervolt": "Nessuna sottotensione",
+    "CPU Low UV": "CPU UV Bassa Frequenza",
+    "CPU High UV": "CPU UV Alta Frequenza",
+    "CPU Low VMIN": "CPU VMIN Bassa Frequenza",
+    "CPU High VMIN": "CPU VMIN Alta Frequenza",
+    "No Undervolt": "Nessun Undervolt",
     "SLT Table": "Tabella SLT",
     "HiOPT Table": "Tabella HiOPT",
-    "GPU Undervolt Table": "Tabella di sottotensione GPU",
-    "GPU Minimum Voltage": "Voltaggio minimo della GPU",
+    "GPU Undervolt Table": "Tabella di Undervolt GPU",
+    "GPU Minimum Voltage": "Voltaggio Minimo della GPU",
     "Calculate GPU Vmin": "Calcola GPU Vmin",
-    "GPU VMIN": "GPUVMIN",
+    "GPU VMIN": "GPU VMIN",
     "GPU Maximum Voltage": "Voltaggio massimo della GPU",
-    "GPU Voltage Offset": "Offset di tensione della GPU",
+    "GPU Voltage Offset": "Offset di Voltaggio della GPU",
     "Do not override": "Non sovrascrivere",
     "Enabled (Default)": "Abilitato (impostazione predefinita)",
     "96.6% limit": "Limite del 96,6%.",
     "99.7% limit": "Limite del 99,7%.",
-    "GPU Scheduling Override": "Override della pianificazione GPU",
+    "GPU Scheduling Override": "Override dello Scheduling GPU",
     "Official Service": "Servizio ufficiale",
     "GPU DVFS Mode": "Modalità DVFS GPU",
     "GPU DVFS Offset": "Offset DVFS della GPU",
-    "GPU Voltage Table": "Tabella delle tensioni della GPU",
-    "GPU Custom Table (mV)": "Tabella personalizzata GPU (mV)",
+    "GPU Voltage Table": "Tabella delle Tensioni della GPU",
+    "GPU Custom Table (mV)": "Tabella GPU Personalizzata (mV)",
     "1075MHz without UV, 1152MHz on SLT": "1075 MHz senza UV, 1152 MHz su SLT",
     "or 1228MHz on HiOPT can cause ": "o 1228 MHz su HiOPT possono causare",
-    "permanent damage to your Switch!": "danni permanenti al tuo Switch!",
-    "921MHz without UV and 960MHz on": "921 MHz senza UV e 960 MHz attivi",
+    "permanent damage to your Switch!": "danni permanenti alla tua Switch!",
+    "921MHz without UV and 960MHz on": "921 MHz senza UV e 960 MHz su",
     "SLT or HiOPT can cause ": "SLT o HiOPT possono causare"
 }
diff --git a/dist/config/horizon-oc/lang/ru.json b/dist/config/horizon-oc/lang/ru.json
index 4cfdb1bd..7edb4408 100644
--- a/dist/config/horizon-oc/lang/ru.json
+++ b/dist/config/horizon-oc/lang/ru.json
@@ -1,141 +1,179 @@
 {
     "Information": "Информация",
-    "IDDQ:": "ИДДК:",
-    "Module: ": "Модуль:",
-    "sys-dock status:": "Статус системной док-станции:",
+    "IDDQ:": "IDDQ:",
+    "Module: ": "Module:",
+    "sys-dock status:": "Статус sys-dock:",
     "SaltyNX status:": "Статус SaltyNX:",
-    "RR Display status:": "Статус отображения RR:",
-    "Wafer Position:": "Позиция вафли:",
-    "Credits": "Кредиты",
+    "RR Display status:": "Статус RR Display:",
+    "Wafer Position:": "Wafer Position:",
+    "Credits": "Благодарности",
     "Developers": "Разработчики",
-    "Contributors": "Авторы",
+    "Contributors": "Внесли вклад",
     "Testers": "Тестеры",
     "Special Thanks": "Особая благодарность",
     "Unknown": "Неизвестно",
     "Installed": "Установлено",
     "Not Installed": "Не установлено",
     "X: %u Y: %u": "X: %u Y: %u",
-    "THE BEER-WARE LICENSE": "ЛИЦЕНЗИЯ НА ПРОДАЖУ ПИВА",
+    "THE BEER-WARE LICENSE": "BEER-WARE LICENSE",
     "Default": "По умолчанию",
-    "Do Not Override": "Не переопределять",
+    "Do Not Override": "Не менять",
     "Disabled": "Отключено",
     "Enabled": "Включено",
+    "Auto": "Авто",
     " \\ue0e3 Reset": "\\ue0e3 Сброс",
     "Display": "Дисплей",
     "Application changed\\n\\n": "Приложение изменено\\n\\n",
     "The running application changed\\n\\n": "Запущенное приложение изменилось\\n\\n",
     "while editing was going on.": "пока шло редактирование.",
-    "Board": "Совет",
+    "Board": "Board",
     "%u.%u%u mV": "%u.%u%u мВ",
-    "Could not connect to hoc-clk sysmodule.\\n\\n": "Не удалось подключиться к системному модулю hoc-clk.\\n\\n",
-    "Please make sure everything is\\n\\n": "Пожалуйста, убедитесь, что все в порядке\\n\\n",
-    "correctly installed and enabled.": "правильно установлен и включен.",
-    "Fatal error": "Неустранимая ошибка",
-    "Temporary Overrides ": "Временные переопределения",
+    "Could not connect to hoc-clk sysmodule.\\n\\n": "Не удалось подключиться к сис-модулю hoc-clk.\\n\\n",
+    "Please make sure everything is\\n\\n": "Пожалуйста, убедитесь, что все\\n\\n",
+    "correctly installed and enabled.": "правильно установлено и включено.",
+    "Fatal error": "Фатальная ошибка",
+    "Temporary Overrides ": "Временный профиль",
     "Sleep Mode": "Спящий режим",
-    "Stock": "Акции",
-    "Dev OC": "Разработчик OC",
-    "Boost Mode": "Режим повышения",
-    "Safe Max": "Сейф Макс",
-    "Unsafe Max": "Небезопасный Макс",
-    "Absolute Max": "Абсолютный Макс",
-    "Handheld Safe Max": "Ручной сейф Макс",
-    "Enable": "Включить",
-    "Edit App Profile": "Редактировать профиль приложения",
-    "Edit Global Profile": "Редактировать глобальный профиль",
-    "Temporary Overrides": "Временные переопределения",
+    "Stock": "Стандарт",
+    "Dev OC": "Разгон dev-кита",
+    "Boost Mode": "Режим буста",
+    "Safe Max": "Безопасный макс.",
+    "Unsafe Max": "Опасный макс.",
+    "Absolute Max": "Абсолютный макс.",
+    "Handheld Safe Max": "Портативный безопасный макс.",
+    "Enable": "Включено",
+    "Edit App Profile": "Профиль приложения",
+    "Edit Global Profile": "Глобальный профиль",
+    "Temporary Overrides": "Временный профиль",
     "Settings": "Настройки",
-    "About": "О",
-    "Compiling with minimal features": "Компиляция с минимальными возможностями",
-    "General Settings": "Общие настройки",
-    "Governor Settings": "Настройки губернатора",
+    "About": "Сведения",
+    "Compiling with minimal features": "Собрано с урезанием функций",
+    "\uE150 Settings marked in blue": "Настройки помеченные синим",
+    "don't require a reboot to apply!": "Синие настройки применяются сразу!",
+    "General Settings": "Основные настройки",
+    "Governor Settings": "Настройки говернора",
     "Safety Settings": "Настройки безопасности",
-    "Save KIP Settings": "Сохранить настройки КИП",
-    "RAM Settings": "Настройки ОЗУ",
-    "CPU Settings": "Настройки процессора",
-    "GPU Settings": "Настройки графического процессора",
+    "Save KIP Settings": "Сохранить настройки KIP",
+    "RAM Settings": "Настройки RAM",
+    "CPU Settings": "Настройки CPU",
+    "GPU Settings": "Настройки GPU",
     "Display Settings": "Настройки дисплея",
     "Experimental": "Экспериментальный",
-    "GPU Scheduling Override Method": "Метод переопределения планирования графического процессора",
-    "can be dangerous and may cause": "может быть опасным и может вызвать",
-    "damage to your battery or charger!": "повреждение аккумулятора или зарядного устройства!",
-    "Charge Current Override": "Блокировка зарядного тока",
-    "RAM Voltage Display Mode": "Режим отображения напряжения ОЗУ",
+    "Enable Experimental Settings": "Экспериментальные настройки",
+    "\uE150 Experimental Settings are incomplete ": "Экспериментальные настройки не закончены",
+    "and may not work correctly or at all!": "Экспериментальные настройки не",
+    "Here be dragons!": "закончены и могут не работать!",
+    "Experimental Settings": "Экспериментальные",
+    "Live CPU Undervolt": "Мгновенный андервольт CPU",
+    "GPU Scheduling Override Method": "Метод перезаписи планировщика GPU",
+    "Memory Frequency Measurement Mode": "Режим измерения частоты RAM",
+    "\uE150 Overriding the charge current": "Перезапись зарядного тока может",
+    "can be dangerous and may cause": "Перезапись зарядного тока может",
+    "damage to your battery or charger!": "повреждить аккумулятор или зарядку!",
+    "Charge Current Override": "Перезапись зарядного тока",
+    "RAM Voltage Display Mode": "Показ вольтажа RAM",
+    "RAM Display Unit": "Показ единицы измерения RAM",
     "Polling Interval": "Интервал опроса",
-    "CPU Governor Minimum Frequency": "Минимальная частота регулятора ЦП",
-    "refresh rates may cause stress": "частота обновления может вызвать стресс",
-    "or damage to your display! ": "или повреждение дисплея!",
+    "CPU Governor Minimum Frequency": "Минимальная частота говернора CPU",
+    "\uE150 Usage of unsafe display": "\uE150 Использование не безопасной",
+    "refresh rates may cause stress": "Не безопасная частота",
+    "or damage to your display! ": "может повредить ваш экран",
     "Proceed at your own risk!": "Действуйте на свой страх и риск!",
-    "Max Handheld Display": "Макс. портативный дисплей",
-    "Display Clock": "Дисплей Часы",
+    "Max Handheld Display Hz": "Макс. в портативе",
+    "Display Clock": "Частота экрана",
     "Official Rating": "Официальный рейтинг",
     "TDP Threshold": "Порог TDP",
     "Power": "Мощность",
-    "Thermal Throttle Limit": "Температурный предел дроссельной заслонки",
+    "Thermal Throttle Limit": "Предел троттлинга",
     "HP Mode": "Режим HP",
-    "Default (Mariko)": "По умолчанию (Марико)",
-    "Default (Erista)": "По умолчанию (Эриста)",
+    "Default (Mariko)": "По умолчанию (M)",
+    "Default (Erista)": "По умолчанию (E)",
     "Rating": "Рейтинг",
-    "Safe Max (Mariko)": "Сейф Макс (Марико)",
-    "Safe Max (Erista)": "Сейф Макс (Эриста)",
-    "RAM VDD2 Voltage": "Напряжение ОЗУ VDD2",
-    "Voltage": "Напряжение",
-    "RAM VDDQ Voltage": "Напряжение ОЗУ VDDQ",
-    "RAM Frequency Editor": "Редактор частоты оперативной памяти",
-    "JEDEC.": "ДЖЕДЕК.",
-    "High speedo needed!": "Нужен высокий спидометр!",
-    "3333MHz (Needs extreme Speedo/PLL)": "3333 МГц (требуется экстремальный спидометр/PLL)",
-    "3366MHz (Needs extreme Speedo/PLL)": "3366 МГц (требуется экстремальный спидометр/PLL)",
-    "3400MHz (Needs extreme Speedo/PLL)": "3400 МГц (требуется экстремальный спидометр/PLL)",
-    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 МГц (нужен нелепый спидометр/PLL)",
-    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 МГц (нужен нелепый спидометр/PLL)",
-    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 МГц (нужен нелепый спидометр/PLL)",
-    "Ram Max Clock": "Рам Макс Часы",
-    "RAM Latency Editor": "Редактор задержки оперативной памяти",
-    "RAM Timing Reductions": "Сокращение таймингов ОЗУ",
-    "Memory Timings": "Тайминги памяти",
-    "Advanced": "Расширенный",
-    "t6 tRTW Fine Tune": "t6 tRTW Точная настройка",
-    "tRTW Fine Tune": "tRTW Точная настройка",
-    "t7 tWTR Fine Tune": "t7 tWTR Тонкая настройка",
-    "tWTR Fine Tune": "tWTR Тонкая настройка",
+    "Safe Max (Mariko)": "Сейф Макс (M)",
+    "Safe Max (Erista)": "Сейф Макс (E)",
+    "RAM VDD2 Voltage": "Вольтаж VDD2",
+    "Voltage": "Вольтаж",
+    "RAM VDDQ Voltage": "Вольтаж VDDQ",
+    "Step Mode": "Частотный шаг",
+    "RAM Frequency Editor": "Редактор частоты",
+    "JEDEC.": "JEDEC.",
+    "High speedo needed!": "Для высоких speedo",
+    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (нужны невероятные speedo/PLL)",
+    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (нужны невероятные speedo/PLL)",
+    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (нужны невероятные speedo/PLL)",
+    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (нужны безумные speedo/PLL)",
+    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (нужны безумные speedo/PLL)",
+    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (нужны безумные speedo/PLL)",
+    "Ram Max Clock": "Макс. частота",
+    "RAM Latency Editor": "Редактор задержек",
+    "1333 Latency Max": "1333 задержка",
+    "1600 Latency Max": "1600 задержка",
+    "1866 Latency Max": "1866 задержка",
+    "2133 Latency Max": "2133 задержка",
+    "RAM Timing Reductions": "Настройка таймингов",
+    "Memory Timings": "Тайминги RAM",
+    "RAM-Timing tBreak": "Разбитие таблицы таймингов",
+    "Memory": "RAM",
+    "mem": "RAM",
+    "MEM": "RAM",
+    "Profile": "Профиль",
+    "Governor": "Говернор",
+    "Advanced": "Расширенные",
+    "Docked": "В доке",
+    "Handheld": "Портатив",
+    "Charging": "На зарядке",
+    "USB Charger": "USB Зарядка",
+    "PD Charger": "PD Зарядка", 
+    "Handheld TDP": "TPD в портативе",
+    "Thermal Throttle": "Троттлинг",
+    "Uncapped Clocks": "Максимальные частоты",
+    "SoC DVB Shift": "SoC DVB сдвиг",
+    "SoC Max Volt": "Макс. вольт SoC",
+    "Overwrite Boost Mode": "Перезапись буста",
+    "Display Refresh Rate Changing": "Изменение частоты экрана",
+    "Low t6 tRTW": "Нижний t6 tRTW",
+    "Low t7 tWTR": "Нижний t7 tWTR",
+    "1333WL t2 RP Cap": "Предел 1333WL t2 RP",
+    "t6 tRTW Fine Tune": " Точная настройка t6 tRTW",
+    "tRTW Fine Tune": " Точная настройка tRTW",
+    "t7 tWTR Fine Tune": " Точная настройка t7 tWTR",
+    "tWTR Fine Tune": " Точная настройка tWTR",
     "Memory Latencies": "Задержки памяти",
     "Read Latency": "Задержка чтения",
     "Write Latency": "Задержка записи",
-    "CPU Boost Clock": "Тактовая частота процессора",
-    "CPU UV": "УФ процессора",
-    "CPU Unlock": "Разблокировка процессора",
-    "CPU VMIN": "ЦП VMIN",
-    "CPU Max Voltage": "Максимальное напряжение процессора",
-    "CPU Max Clock": "Максимальная частота процессора",
-    "Extreme UV Table": "Стол для экстремального УФ-излучения",
-    "CPU UV Table": "UV-таблица процессора",
-    "CPU Low UV": "ЦП с низким УФ-излучением",
-    "CPU High UV": "Процессор с высоким УФ",
-    "CPU Low VMIN": "Низкий VMIN процессора",
-    "CPU High VMIN": "Высокий VMIN процессора",
-    "No Undervolt": "Нет Андервольта",
-    "SLT Table": "Таблица ТА",
+    "CPU Boost Clock": "Частота буста",
+    "CPU UV": "Андервольт CPU",
+    "CPU Unlock": "Разблокировка CPU",
+    "CPU VMIN": "Мин. вольтаж",
+    "CPU Max Voltage": "Макс. вольтаж",
+    "CPU Max Clock": "Макс. частота",
+    "Extreme UV Table": "Экстримальная",
+    "CPU UV Table": "Таблица андервольта",
+    "CPU Low UV": "Андервольт нижних частот",
+    "CPU High UV": "Андервольт верхних частот",
+    "CPU Low VMIN": "Мин. вольт. нижних частот",
+    "CPU High VMIN": "Мин. вольт. верхних частот",
+    "No Undervolt": "Без андервольта",
+    "SLT Table": "Таблица SLT",
     "HiOPT Table": "Таблица HiOPT",
-    "GPU Undervolt Table": "Таблица пониженного напряжения графического процессора",
-    "GPU Minimum Voltage": "Минимальное напряжение графического процессора",
-    "Calculate GPU Vmin": "Рассчитать Vmin графического процессора",
-    "GPU VMIN": "Вмин графического процессора",
-    "GPU Maximum Voltage": "Максимальное напряжение графического процессора",
-    "GPU Voltage Offset": "Смещение напряжения графического процессора",
-    "Do not override": "Не переопределять",
-    "Enabled (Default)": "Включено (по умолчанию)",
-    "96.6% limit": "Предел 96,6%",
-    "99.7% limit": "лимит 99,7%",
-    "GPU Scheduling Override": "Переопределение планирования графического процессора",
+    "GPU Undervolt Table": "Таблица андервольта",
+    "GPU Minimum Voltage": "Мин. вольтаж",
+    "Calculate GPU Vmin": "Вычисление мин. вольтаж",
+    "GPU VMIN": "Мин. вольтаж",
+    "GPU Maximum Voltage": "Макс. вольтаж",
+    "GPU Voltage Offset": "Смещение вольтажа",
+    "Do not override": "Не менять",
+    "Enabled (Default)": "Включено (По умолчанию)",
+    "96.6% limit": "≤96,6%",
+    "99.7% limit": "≤99,7%",
+    "GPU Scheduling Override": "Перезапись планировщика",
     "Official Service": "Официальная служба",
-    "GPU DVFS Mode": "Режим графического процессора DVFS",
-    "GPU DVFS Offset": "Смещение DVFS графического процессора",
-    "GPU Voltage Table": "Таблица напряжений графического процессора",
-    "GPU Custom Table (mV)": "Пользовательская таблица графического процессора (мВ)",
-    "1075MHz without UV, 1152MHz on SLT": "1075 МГц без УФ, 1152 МГц на SLT",
-    "or 1228MHz on HiOPT can cause ": "или 1228 МГц на HiOPT может привести к",
-    "permanent damage to your Switch!": "необратимое повреждение вашего коммутатора!",
-    "921MHz without UV and 960MHz on": "921 МГц без УФ и 960 МГц с включенным",
-    "SLT or HiOPT can cause ": "SLT или HiOPT могут вызвать"
+    "GPU DVFS Mode": "Режим DVFS",
+    "GPU DVFS Offset": "Смещение DVFS",
+    "GPU Voltage Table": "Таблица вольтажей",
+    "GPU Custom Table (mV)": "Ручная таблица (мВ)",
+    "\uE150 Setting GPU Clocks past": "\uE150 Установка частот GPU выше",
+	"1228MHz without a proper undervolt": "Установка частот GPU выше 1228 МГц",
+    "can cause degradation or damage": "без хорошего андервольта может",
+    "to your console!": "повредить вашу консоль!"
 }
diff --git a/dist/switch/.overlays/Horizon-OC-Monitor.ovl b/dist/switch/.overlays/Horizon-OC-Monitor.ovl
index 8445c3c4..401d33aa 100644
Binary files a/dist/switch/.overlays/Horizon-OC-Monitor.ovl and b/dist/switch/.overlays/Horizon-OC-Monitor.ovl differ
diff --git a/dist/switch/.overlays/horizon-oc-overlay.ovl b/dist/switch/.overlays/horizon-oc-overlay.ovl
index 7d5d01e8..b027bcb1 100644
Binary files a/dist/switch/.overlays/horizon-oc-overlay.ovl and b/dist/switch/.overlays/horizon-oc-overlay.ovl differ