diff --git a/common/defaults/system_settings.ini b/common/defaults/system_settings.ini
index 86e211793..d1b7418b9 100644
--- a/common/defaults/system_settings.ini
+++ b/common/defaults/system_settings.ini
@@ -11,4 +11,8 @@ usb30_force_enabled = u8!0x0
 power_menu_reboot_function = str!payload
 ; Controls whether dmnt cheats should be toggled on or off by 
 ; default. 1 = toggled on by default, 0 = toggled off by default.
-dmnt_cheats_enabled_by_default = u8!0x1
\ No newline at end of file
+dmnt_cheats_enabled_by_default = u8!0x1
+; Controls whether dmnt should always save cheat toggle state
+; for restoration on new game launch. 1 = always save toggles,
+; 0 = only save toggles if toggle file exists.
+dmnt_always_save_cheat_toggles = u8!0x0
\ No newline at end of file
diff --git a/stratosphere/dmnt/source/dmnt_cheat_manager.cpp b/stratosphere/dmnt/source/dmnt_cheat_manager.cpp
index ba44fdfa0..fd7234d4b 100644
--- a/stratosphere/dmnt/source/dmnt_cheat_manager.cpp
+++ b/stratosphere/dmnt/source/dmnt_cheat_manager.cpp
@@ -13,7 +13,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
- 
+
 #include <map>
 #include <switch.h>
 #include "dmnt_cheat_manager.hpp"
@@ -33,6 +33,8 @@ static Handle g_cheat_process_debug_hnd = 0;
 
 /* Should we enable cheats by default? */
 static bool g_enable_cheats_by_default = true;
+static bool g_always_save_cheat_toggles = false;
+static bool g_should_save_cheat_toggles = false;
 
 /* For debug event thread management. */
 static HosMutex g_debug_event_thread_lock, g_attach_lock;
@@ -49,31 +51,31 @@ static std::map<u64, FrozenAddressValue> g_frozen_addresses_map;
 
 void DmntCheatManager::StartDebugEventsThread() {
     std::scoped_lock<HosMutex> lk(g_debug_event_thread_lock);
-    
+
     /* Spawn the debug events thread. */
     if (!g_has_debug_events_thread) {
         Result rc;
-        
+
         if (R_FAILED((rc = g_debug_events_thread.Initialize(&DmntCheatManager::DebugEventsThread, nullptr, 0x4000, 48)))) {
             return fatalSimple(rc);
         }
-        
+
         if (R_FAILED((rc = g_debug_events_thread.Start()))) {
             return fatalSimple(rc);
         }
-        
+
         g_has_debug_events_thread = true;
     }
 }
 
 void DmntCheatManager::WaitDebugEventsThread() {
     std::scoped_lock<HosMutex> lk(g_debug_event_thread_lock);
-    
+
     /* Wait for the thread to exit. */
     if (g_has_debug_events_thread) {
         g_debug_events_thread.CancelSynchronization();
         g_debug_events_thread.Join();
-        
+
         g_has_debug_events_thread = false;
     }
 }
@@ -83,14 +85,22 @@ void DmntCheatManager::CloseActiveCheatProcess() {
         /* Close process resources. */
         svcCloseHandle(g_cheat_process_debug_hnd);
         g_cheat_process_debug_hnd = 0;
+
+        /* Save cheat toggles. */
+        if (g_always_save_cheat_toggles || g_should_save_cheat_toggles) {
+            SaveCheatToggles(g_cheat_process_metadata.title_id);
+            g_should_save_cheat_toggles = false;
+        }
+
+        /* Clear metadata. */
         g_cheat_process_metadata = (CheatProcessMetadata){0};
-        
+
         /* Clear cheat list. */
         ResetAllCheatEntries();
-        
+
         /* Clear frozen addresses. */
         ResetFrozenAddresses();
-        
+
         /* Signal to our fans. */
         g_cheat_process_event->Signal();
     }
@@ -99,15 +109,15 @@ void DmntCheatManager::CloseActiveCheatProcess() {
 bool DmntCheatManager::HasActiveCheatProcess() {
     u64 tmp;
     bool has_cheat_process = g_cheat_process_debug_hnd != 0;
-    
+
     if (has_cheat_process) {
         has_cheat_process &= R_SUCCEEDED(svcGetProcessId(&tmp, g_cheat_process_debug_hnd));
     }
-    
+
     if (has_cheat_process) {
         has_cheat_process &= R_SUCCEEDED(pmdmntGetApplicationPid(&tmp));
     }
-    
+
     if (has_cheat_process) {
         has_cheat_process &= tmp == g_cheat_process_metadata.process_id;
     }
@@ -115,7 +125,7 @@ bool DmntCheatManager::HasActiveCheatProcess() {
     if (!has_cheat_process) {
         CloseActiveCheatProcess();
     }
-    
+
     return has_cheat_process;
 }
 
@@ -123,14 +133,14 @@ Result DmntCheatManager::ReadCheatProcessMemoryForVm(u64 proc_addr, void *out_da
     if (HasActiveCheatProcess()) {
         return svcReadDebugProcessMemory(out_data, g_cheat_process_debug_hnd, proc_addr, size);
     }
-    
+
     return ResultDmntCheatNotAttached;
 }
 
 Result DmntCheatManager::WriteCheatProcessMemoryForVm(u64 proc_addr, const void *data, size_t size) {
     if (HasActiveCheatProcess()) {
         Result rc = svcWriteDebugProcessMemory(g_cheat_process_debug_hnd, data, proc_addr, size);
-        
+
         /* We might have a frozen address. Update it if we do! */
         if (R_SUCCEEDED(rc)) {
             for (auto & [address, value] : g_frozen_addresses_map) {
@@ -138,7 +148,7 @@ Result DmntCheatManager::WriteCheatProcessMemoryForVm(u64 proc_addr, const void
                 if (address >= proc_addr + size) {
                     break;
                 }
-                
+
                 /* Check if we need to write. */
                 if (proc_addr <= address) {
                     const size_t offset = (address - proc_addr);
@@ -147,23 +157,23 @@ Result DmntCheatManager::WriteCheatProcessMemoryForVm(u64 proc_addr, const void
                 }
             }
         }
-        
+
         return rc;
     }
-    
+
     return ResultDmntCheatNotAttached;
 }
 
 
 Result DmntCheatManager::GetCheatProcessMappingCount(u64 *out_count) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     MemoryInfo mem_info;
-    
+
     u64 address = 0;
     *out_count = 0;
     do {
@@ -172,24 +182,24 @@ Result DmntCheatManager::GetCheatProcessMappingCount(u64 *out_count) {
         if (R_FAILED(svcQueryDebugProcessMemory(&mem_info, &tmp, g_cheat_process_debug_hnd, address))) {
             break;
         }
-        
+
         if (mem_info.perm != 0) {
             *out_count += 1;
         }
-        
+
         address = mem_info.addr + mem_info.size;
     } while (address != 0);
-    
+
     return 0;
 }
 
 Result DmntCheatManager::GetCheatProcessMappings(MemoryInfo *mappings, size_t max_count, u64 *out_count, u64 offset) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     MemoryInfo mem_info;
     u64 address = 0;
     u64 count = 0;
@@ -200,40 +210,40 @@ Result DmntCheatManager::GetCheatProcessMappings(MemoryInfo *mappings, size_t ma
         if (R_FAILED(svcQueryDebugProcessMemory(&mem_info, &tmp, g_cheat_process_debug_hnd, address))) {
             break;
         }
-        
+
         if (mem_info.perm != 0) {
             count++;
             if (count > offset) {
                 mappings[(*out_count)++] = mem_info;
             }
         }
-        
+
         address = mem_info.addr + mem_info.size;
     } while (address != 0 && *out_count < max_count);
-    
+
     return 0;
 }
 
 Result DmntCheatManager::ReadCheatProcessMemory(u64 proc_addr, void *out_data, size_t size) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     return ReadCheatProcessMemoryForVm(proc_addr, out_data, size);
 }
 
 Result DmntCheatManager::WriteCheatProcessMemory(u64 proc_addr, const void *data, size_t size) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     return WriteCheatProcessMemoryForVm(proc_addr, data, size);
 }
 
 Result DmntCheatManager::QueryCheatProcessMemory(MemoryInfo *mapping, u64 address) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (HasActiveCheatProcess()) {
         u32 tmp;
         return svcQueryDebugProcessMemory(mapping, &tmp, g_cheat_process_debug_hnd, address);
     }
-    
+
     return ResultDmntCheatNotAttached;
 }
 
@@ -247,7 +257,7 @@ void DmntCheatManager::ResetCheatEntry(size_t i) {
         g_cheat_entries[i].enabled = false;
         g_cheat_entries[i].cheat_id = i;
         g_cheat_entries[i].definition = {0};
-        
+
         /* Trigger a VM reload. */
         g_needs_reload_vm_program = true;
     }
@@ -266,7 +276,7 @@ CheatEntry *DmntCheatManager::GetFreeCheatEntry() {
             return &g_cheat_entries[i];
         }
     }
-    
+
     return nullptr;
 }
 
@@ -274,17 +284,28 @@ CheatEntry *DmntCheatManager::GetCheatEntryById(size_t i) {
     if (i < DmntCheatManager::MaxCheatCount) {
         return &g_cheat_entries[i];
     }
-    
+
+    return nullptr;
+}
+
+CheatEntry *DmntCheatManager::GetCheatEntryByReadableName(const char *readable_name) {
+    /* Check all non-master cheats for match. */
+    for (size_t i = 1; i < DmntCheatManager::MaxCheatCount; i++) {
+        if (strcmp(g_cheat_entries[i].definition.readable_name, readable_name) == 0) {
+            return &g_cheat_entries[i];
+        }
+    }
+
     return nullptr;
 }
 
 bool DmntCheatManager::ParseCheats(const char *s, size_t len) {
     size_t i = 0;
     CheatEntry *cur_entry = NULL;
-        
+
     /* Trigger a VM reload. */
     g_needs_reload_vm_program = true;
-    
+
     while (i < len) {
         if (isspace(s[i])) {
             /* Just ignore space. */
@@ -295,7 +316,7 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) {
             if (cur_entry == NULL) {
                 return false;
             }
-            
+
             /* Extract name bounds. */
             size_t j = i + 1;
             while (s[j] != ']') {
@@ -304,23 +325,23 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) {
                     return false;
                 }
             }
-            
+
             /* s[i+1:j] is cheat name. */
             const size_t cheat_name_len = (j - i - 1);
             memcpy(cur_entry->definition.readable_name, &s[i+1], cheat_name_len);
             cur_entry->definition.readable_name[cheat_name_len] = 0;
-            
+
             /* Skip onwards. */
             i = j + 1;
         } else if (s[i] == '{') {
             /* We're parsing a master cheat. */
             cur_entry = &g_cheat_entries[0];
-            
+
             /* There can only be one master cheat. */
             if (cur_entry->definition.num_opcodes > 0) {
                 return false;
             }
-            
+
             /* Extract name bounds */
             size_t j = i + 1;
             while (s[j] != '}') {
@@ -329,12 +350,12 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) {
                     return false;
                 }
             }
-            
+
             /* s[i+1:j] is cheat name. */
             const size_t cheat_name_len = (j - i - 1);
             memcpy(cur_entry->definition.readable_name, &s[i+1], cheat_name_len);
             cur_entry->definition.readable_name[cheat_name_len] = 0;
-            
+
             /* Skip onwards. */
             i = j + 1;
         } else if (isxdigit(s[i])) {
@@ -342,12 +363,12 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) {
             if (cur_entry == NULL) {
                 return false;
             }
-            
+
             /* Bounds check the opcode count. */
             if (cur_entry->definition.num_opcodes >= sizeof(cur_entry->definition.opcodes)/sizeof(cur_entry->definition.opcodes[0])) {
                 return false;
             }
-            
+
             /* We're parsing an instruction, so validate it's 8 hex digits. */
             for (size_t j = 1; j < 8; j++) {
                 /* Validate 8 hex chars. */
@@ -355,13 +376,13 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) {
                     return false;
                 }
             }
-           
+
             /* Parse the new opcode. */
             char hex_str[9] = {0};
             memcpy(hex_str, &s[i], 8);
             cur_entry->definition.opcodes[cur_entry->definition.num_opcodes++] = strtoul(hex_str, NULL, 16);
-            
-            
+
+
             /* Skip onwards. */
             i += 8;
         } else {
@@ -369,88 +390,227 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) {
             return false;
         }
     }
-    
+
     /* Master cheat can't be disabled. */
     if (g_cheat_entries[0].definition.num_opcodes > 0) {
         g_cheat_entries[0].enabled = true;
     }
-    
+
     /* Enable all entries we parsed. */
     for (size_t i = 1; i < DmntCheatManager::MaxCheatCount; i++) {
         if (g_cheat_entries[i].definition.num_opcodes > 0) {
             g_cheat_entries[i].enabled = g_enable_cheats_by_default;
         }
     }
-    
+
     return true;
 }
 
 bool DmntCheatManager::LoadCheats(u64 title_id, const u8 *build_id) {
     /* Reset existing entries. */
     ResetAllCheatEntries();
-        
+
     FILE *f_cht = NULL;
     /* Open the file for title/build_id. */
     {
         char path[FS_MAX_PATH+1] = {0};
         snprintf(path, FS_MAX_PATH, "sdmc:/atmosphere/titles/%016lx/cheats/%02x%02x%02x%02x%02x%02x%02x%02x.txt", title_id,
-                build_id[0], build_id[1], build_id[2], build_id[3], build_id[4], build_id[5], build_id[6], build_id[7]); 
+                build_id[0], build_id[1], build_id[2], build_id[3], build_id[4], build_id[5], build_id[6], build_id[7]);
 
         f_cht = fopen(path, "rb");
     }
-    
+
     /* Check for NULL */
     if (f_cht == NULL) {
         return false;
     }
     ON_SCOPE_EXIT { fclose(f_cht); };
-    
+
     /* Get file size. */
     fseek(f_cht, 0L, SEEK_END);
     const size_t cht_sz = ftell(f_cht);
     fseek(f_cht, 0L, SEEK_SET);
-        
+
     /* Allocate cheat txt buffer. */
     char *cht_txt = (char *)malloc(cht_sz + 1);
     if (cht_txt == NULL) {
         return false;
     }
     ON_SCOPE_EXIT { free(cht_txt); };
-    
+
     /* Read cheats into buffer. */
     if (fread(cht_txt, 1, cht_sz, f_cht) != cht_sz) {
         return false;
     }
     cht_txt[cht_sz] = 0;
-        
+
     /* Parse cheat buffer. */
     return ParseCheats(cht_txt, strlen(cht_txt));
 }
 
+bool DmntCheatManager::ParseCheatToggles(const char *s, size_t len) {
+    size_t i = 0;
+    char cur_cheat_name[sizeof(CheatEntry::definition.readable_name)];
+    char toggle[8];
+
+    while (i < len) {
+        if (isspace(s[i])) {
+            /* Just ignore space. */
+            i++;
+        } else if (s[i] == '[') {
+
+            /* Extract name bounds. */
+            size_t j = i + 1;
+            while (s[j] != ']') {
+                j++;
+                if (j >= len || (j - i - 1) >= sizeof(cur_cheat_name)) {
+                    return false;
+                }
+            }
+
+            /* s[i+1:j] is cheat name. */
+            const size_t cheat_name_len = (j - i - 1);
+            memcpy(cur_cheat_name, &s[i+1], cheat_name_len);
+            cur_cheat_name[cheat_name_len] = 0;
+
+            /* Skip onwards. */
+            i = j + 1;
+
+            /* Skip whitespace. */
+            while (isspace(s[i])) {
+                i++;
+            }
+
+            /* Parse whether to toggle. */
+            j = i + 1;
+            while (!isspace(s[j])) {
+                j++;
+                if (j >= len || (j - i) >= sizeof(toggle)) {
+                    return false;
+                }
+            }
+
+            /* s[i:j] is toggle. */
+            const size_t toggle_len = (j - i);
+            memcpy(toggle, &s[i], toggle_len);
+            toggle[toggle_len] = 0;
+
+            /* Allow specifying toggle for not present cheat. */
+            CheatEntry *entry = GetCheatEntryByReadableName(cur_cheat_name);
+            if (entry != nullptr) {
+                if (strcasecmp(toggle, "1") == 0 || strcasecmp(toggle, "true") == 0 || strcasecmp(toggle, "on") == 0) {
+                    entry->enabled = true;
+                } else if (strcasecmp(toggle, "0") == 0 || strcasecmp(toggle, "false") == 0 || strcasecmp(toggle, "off") == 0) {
+                    entry->enabled = false;
+                }
+            }
+
+            /* Skip onwards. */
+            i = j + 1;
+        } else {
+            /* Unexpected character encountered. */
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool DmntCheatManager::LoadCheatToggles(u64 title_id) {
+    FILE *f_tg = NULL;
+    /* Open the file for title id. */
+    {
+        char path[FS_MAX_PATH+1] = {0};
+        snprintf(path, FS_MAX_PATH, "sdmc:/atmosphere/titles/%016lx/cheats/toggles.txt", title_id);
+
+        f_tg = fopen(path, "rb");
+    }
+
+    /* Unless we successfully parse, don't save toggles on close. */
+    g_should_save_cheat_toggles = false;
+
+    /* Check for NULL, which is allowed. */
+    if (f_tg == NULL) {
+        return true;
+    }
+    ON_SCOPE_EXIT { fclose(f_tg); };
+
+    /* Get file size. */
+    fseek(f_tg, 0L, SEEK_END);
+    const size_t tg_sz = ftell(f_tg);
+    fseek(f_tg, 0L, SEEK_SET);
+
+    /* Allocate toggle txt buffer. */
+    char *tg_txt = (char *)malloc(tg_sz + 1);
+    if (tg_txt == NULL) {
+        return false;
+    }
+    ON_SCOPE_EXIT { free(tg_txt); };
+
+    /* Read toggles into buffer. */
+    if (fread(tg_txt, 1, tg_sz, f_tg) != tg_sz) {
+        return false;
+    }
+    tg_txt[tg_sz] = 0;
+
+    /* Parse toggle buffer. */
+    g_should_save_cheat_toggles = ParseCheatToggles(tg_txt, strlen(tg_txt));
+    return g_should_save_cheat_toggles;
+}
+
+void DmntCheatManager::SaveCheatToggles(u64 title_id) {
+    FILE *f_tg = NULL;
+    /* Open the file for title id. */
+    {
+        char path[FS_MAX_PATH+1] = {0};
+        snprintf(path, FS_MAX_PATH, "sdmc:/atmosphere/titles/%016lx/cheats/toggles.txt", title_id);
+
+        f_tg = fopen(path, "wb");
+    }
+
+    if (f_tg == NULL) {
+        return;
+    }
+
+    ON_SCOPE_EXIT { fclose(f_tg); };
+
+    /* Save all non-master cheats. */
+    for (size_t i = 1; i < DmntCheatManager::MaxCheatCount; i++) {
+        if (g_cheat_entries[i].definition.num_opcodes != 0) {
+            fprintf(f_tg, "[%s]\n", g_cheat_entries[i].definition.readable_name);
+            if (g_cheat_entries[i].enabled) {
+                fprintf(f_tg, "true\n");
+            } else {
+                fprintf(f_tg, "false\n");
+            }
+        }
+    }
+}
+
 Result DmntCheatManager::GetCheatCount(u64 *out_count) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     *out_count = 0;
     for (size_t i = 0; i < DmntCheatManager::MaxCheatCount; i++) {
         if (g_cheat_entries[i].definition.num_opcodes > 0) {
             *out_count += 1;
         }
     }
-    
+
     return 0;
 }
 
 Result DmntCheatManager::GetCheats(CheatEntry *cheats, size_t max_count, u64 *out_count, u64 offset) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     u64 count = 0;
     *out_count = 0;
     for (size_t i = 0; i < DmntCheatManager::MaxCheatCount && (*out_count) < max_count; i++) {
@@ -461,44 +621,44 @@ Result DmntCheatManager::GetCheats(CheatEntry *cheats, size_t max_count, u64 *ou
             }
         }
     }
-    
+
     return 0;
 }
 
 Result DmntCheatManager::GetCheatById(CheatEntry *out_cheat, u32 cheat_id) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     const CheatEntry *entry = GetCheatEntryById(cheat_id);
     if (entry == nullptr || entry->definition.num_opcodes == 0) {
         return ResultDmntCheatUnknownChtId;
     }
-    
+
     *out_cheat = *entry;
     return 0;
 }
 
 Result DmntCheatManager::ToggleCheat(u32 cheat_id) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     CheatEntry *entry = GetCheatEntryById(cheat_id);
     if (entry == nullptr || entry->definition.num_opcodes == 0) {
         return ResultDmntCheatUnknownChtId;
     }
-    
+
     if (cheat_id == 0) {
         return ResultDmntCheatCannotDisableMasterCheat;
     }
-    
+
     entry->enabled = !entry->enabled;
-    
+
     /* Trigger a VM reload. */
     g_needs_reload_vm_program = true;
     return 0;
@@ -506,23 +666,23 @@ Result DmntCheatManager::ToggleCheat(u32 cheat_id) {
 
 Result DmntCheatManager::AddCheat(u32 *out_id, CheatDefinition *def, bool enabled) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     if (def->num_opcodes == 0 || def->num_opcodes > sizeof(def->opcodes)/sizeof(def->opcodes[0])) {
         return ResultDmntCheatInvalidCheat;
     }
-    
+
     CheatEntry *new_entry = GetFreeCheatEntry();
     if (new_entry == nullptr) {
         return ResultDmntCheatOutOfCheats;
     }
-    
+
     new_entry->enabled = enabled;
     new_entry->definition = *def;
-    
+
     /* Trigger a VM reload. */
     g_needs_reload_vm_program = true;
     return 0;
@@ -530,17 +690,17 @@ Result DmntCheatManager::AddCheat(u32 *out_id, CheatDefinition *def, bool enable
 
 Result DmntCheatManager::RemoveCheat(u32 cheat_id) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     if (cheat_id >= DmntCheatManager::MaxCheatCount) {
         return ResultDmntCheatUnknownChtId;
     }
-    
+
     ResetCheatEntry(cheat_id);
-    
+
     /* Trigger a VM reload. */
     g_needs_reload_vm_program = true;
     return 0;
@@ -548,29 +708,29 @@ Result DmntCheatManager::RemoveCheat(u32 cheat_id) {
 
 Result DmntCheatManager::GetFrozenAddressCount(u64 *out_count) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     *out_count = g_frozen_addresses_map.size();
     return 0;
 }
 
 Result DmntCheatManager::GetFrozenAddresses(FrozenAddressEntry *frz_addrs, size_t max_count, u64 *out_count, u64 offset) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     u64 count = 0;
     *out_count = 0;
     for (auto const& [address, value] : g_frozen_addresses_map) {
         if ((*out_count) >= max_count) {
             break;
         }
-        
+
         count++;
         if (count > offset) {
             const u64 cur_ind = (*out_count)++;
@@ -578,22 +738,22 @@ Result DmntCheatManager::GetFrozenAddresses(FrozenAddressEntry *frz_addrs, size_
             frz_addrs[cur_ind].value = value;
         }
     }
-    
+
     return 0;
 }
 
 Result  DmntCheatManager::GetFrozenAddress(FrozenAddressEntry *frz_addr, u64 address) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     const auto it = g_frozen_addresses_map.find(address);
     if (it == g_frozen_addresses_map.end()) {
         return ResultDmntCheatAddressNotFrozen;
     }
-    
+
     frz_addr->address = it->first;
     frz_addr->value = it->second;
     return 0;
@@ -601,27 +761,27 @@ Result  DmntCheatManager::GetFrozenAddress(FrozenAddressEntry *frz_addr, u64 add
 
 Result DmntCheatManager::EnableFrozenAddress(u64 *out_value, u64 address, u64 width) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     if (g_frozen_addresses_map.size() >= DmntCheatManager::MaxFrozenAddressCount) {
         return ResultDmntCheatTooManyFrozenAddresses;
     }
-    
+
     const auto it = g_frozen_addresses_map.find(address);
     if (it != g_frozen_addresses_map.end()) {
         return ResultDmntCheatAddressAlreadyFrozen;
     }
-    
+
     Result rc;
     FrozenAddressValue value = {0};
     value.width = width;
     if (R_FAILED((rc = ReadCheatProcessMemoryForVm(address, &value.value, width)))) {
         return rc;
     }
-    
+
     g_frozen_addresses_map[address] = value;
     *out_value = value.value;
     return 0;
@@ -629,16 +789,16 @@ Result DmntCheatManager::EnableFrozenAddress(u64 *out_value, u64 address, u64 wi
 
 Result DmntCheatManager::DisableFrozenAddress(u64 address) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (!HasActiveCheatProcess()) {
         return ResultDmntCheatNotAttached;
     }
-    
+
     const auto it = g_frozen_addresses_map.find(address);
     if (it == g_frozen_addresses_map.end()) {
         return ResultDmntCheatAddressNotFrozen;
     }
-    
+
     g_frozen_addresses_map.erase(address);
     return 0;
 }
@@ -649,7 +809,7 @@ Handle DmntCheatManager::PrepareDebugNextApplication() {
     if (R_FAILED((rc = pmdmntEnableDebugForApplication(&event_h)))) {
         fatalSimple(rc);
     }
-    
+
     return event_h;
 }
 
@@ -659,7 +819,7 @@ static void PopulateMemoryExtents(MemoryRegionExtents *extents, Handle p_h, u64
     if (R_FAILED((rc = svcGetInfo(&extents->base, id_base, p_h, 0)))) {
         fatalSimple(rc);
     }
-    
+
     /* Get size extent. */
     if (R_FAILED((rc = svcGetInfo(&extents->size, id_size, p_h, 0)))) {
         fatalSimple(rc);
@@ -676,41 +836,41 @@ static void StartDebugProcess(u64 pid) {
 Result DmntCheatManager::ForceOpenCheatProcess() {
     std::scoped_lock<HosMutex> attach_lk(g_attach_lock);
     Result rc;
-    
+
     /* Acquire the cheat lock for long enough to close the process if needed. */
     {
         std::scoped_lock<HosMutex> lk(g_cheat_lock);
-        
+
         if (HasActiveCheatProcess()) {
             return 0;
         }
-        
+
         /* Close the current application, if it's open. */
         CloseActiveCheatProcess();
     }
-    
+
     /* Intentionally yield the cheat lock to the debug events thread. */
     /* Wait to not have debug events thread. */
     WaitDebugEventsThread();
-    
+
     /* At this point, we can re-acquire the lock for the rest of the function. */
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     /* Get the current application process ID. */
     if (R_FAILED((rc = pmdmntGetApplicationPid(&g_cheat_process_metadata.process_id)))) {
         return rc;
     }
     ON_SCOPE_EXIT { if (R_FAILED(rc)) { g_cheat_process_metadata.process_id = 0; } };
-    
+
     /* Get process handle, use it to learn memory extents. */
     {
         Handle proc_h = 0;
         ON_SCOPE_EXIT { if (proc_h != 0) { svcCloseHandle(proc_h); } };
-        
+
         if (R_FAILED((rc = pmdmntAtmosphereGetProcessInfo(&proc_h, &g_cheat_process_metadata.title_id, nullptr, g_cheat_process_metadata.process_id)))) {
             return rc;
         }
-        
+
         /* Get memory extents. */
         PopulateMemoryExtents(&g_cheat_process_metadata.heap_extents, proc_h, 4, 5);
         PopulateMemoryExtents(&g_cheat_process_metadata.alias_extents, proc_h, 2, 3);
@@ -721,7 +881,7 @@ Result DmntCheatManager::ForceOpenCheatProcess() {
             g_cheat_process_metadata.address_space_extents.size = 0x78000000UL;
         }
     }
-    
+
     /* Get module information from Loader. */
     {
         LoaderModuleInfo proc_modules[2];
@@ -729,7 +889,7 @@ Result DmntCheatManager::ForceOpenCheatProcess() {
         if (R_FAILED((rc = ldrDmntGetModuleInfos(g_cheat_process_metadata.process_id, proc_modules, sizeof(proc_modules), &num_modules)))) {
             return rc;
         }
-        
+
         /* All applications must have two modules. */
         /* However, this is a force-open, so we will accept one module. */
         /* Poor HBL, I guess... */
@@ -742,60 +902,63 @@ Result DmntCheatManager::ForceOpenCheatProcess() {
             rc = ResultDmntCheatNotAttached;
             return rc;
         }
-        
+
         g_cheat_process_metadata.main_nso_extents.base = proc_module->base_address;
         g_cheat_process_metadata.main_nso_extents.size = proc_module->size;
         memcpy(g_cheat_process_metadata.main_nso_build_id, proc_module->build_id, sizeof(g_cheat_process_metadata.main_nso_build_id));
     }
-    
+
     /* Read cheats off the SD. */
     /* This is allowed to fail. We may not have any cheats. */
     LoadCheats(g_cheat_process_metadata.title_id, g_cheat_process_metadata.main_nso_build_id);
-    
+
+    /* Load saved toggles, if present. */
+    LoadCheatToggles(g_cheat_process_metadata.title_id);
+
     /* Open a debug handle. */
     if (R_FAILED((rc = svcDebugActiveProcess(&g_cheat_process_debug_hnd, g_cheat_process_metadata.process_id)))) {
         return rc;
     }
     /* Start debug events thread. */
     StartDebugEventsThread();
-        
+
     /* Signal to our fans. */
     g_cheat_process_event->Signal();
-    
+
     return rc;
 }
 
 void DmntCheatManager::OnNewApplicationLaunch() {
     std::scoped_lock<HosMutex> attach_lk(g_attach_lock);
     Result rc;
-    
+
     {
         std::scoped_lock<HosMutex> lk(g_cheat_lock);
         /* Close the current application, if it's open. */
         CloseActiveCheatProcess();
     }
-    
+
     /* Intentionally yield the cheat lock to the debug events thread. */
     /* Wait to not have debug events thread. */
     WaitDebugEventsThread();
-    
+
     /* At this point, we can re-acquire the lock for the rest of the function. */
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     /* Get the new application's process ID. */
     if (R_FAILED((rc = pmdmntGetApplicationPid(&g_cheat_process_metadata.process_id)))) {
         fatalSimple(rc);
     }
-    
+
     /* Get process handle, use it to learn memory extents. */
     {
         Handle proc_h = 0;
         ON_SCOPE_EXIT { if (proc_h != 0) { svcCloseHandle(proc_h); } };
-        
+
         if (R_FAILED((rc = pmdmntAtmosphereGetProcessInfo(&proc_h, &g_cheat_process_metadata.title_id, nullptr, g_cheat_process_metadata.process_id)))) {
             fatalSimple(rc);
         }
-        
+
         /* Get memory extents. */
         PopulateMemoryExtents(&g_cheat_process_metadata.heap_extents, proc_h, 4, 5);
         PopulateMemoryExtents(&g_cheat_process_metadata.alias_extents, proc_h, 2, 3);
@@ -806,14 +969,14 @@ void DmntCheatManager::OnNewApplicationLaunch() {
             g_cheat_process_metadata.address_space_extents.size = 0x78000000UL;
         }
     }
-    
+
     /* Check if we should skip based on keys down. */
     if (!DmntConfigManager::HasCheatEnableButton(g_cheat_process_metadata.title_id)) {
         StartDebugProcess(g_cheat_process_metadata.process_id);
         g_cheat_process_metadata.process_id = 0;
         return;
     }
-    
+
     /* Get module information from Loader. */
     {
         LoaderModuleInfo proc_modules[2];
@@ -821,7 +984,7 @@ void DmntCheatManager::OnNewApplicationLaunch() {
         if (R_FAILED((rc = ldrDmntGetModuleInfos(g_cheat_process_metadata.process_id, proc_modules, sizeof(proc_modules), &num_modules)))) {
             fatalSimple(rc);
         }
-        
+
         /* All applications must have two modules. */
         /* If we only have one, we must be e.g. mitming HBL. */
         /* We don't want to fuck with HBL. */
@@ -830,31 +993,31 @@ void DmntCheatManager::OnNewApplicationLaunch() {
             g_cheat_process_metadata.process_id = 0;
             return;
         }
-        
+
         g_cheat_process_metadata.main_nso_extents.base = proc_modules[1].base_address;
         g_cheat_process_metadata.main_nso_extents.size = proc_modules[1].size;
         memcpy(g_cheat_process_metadata.main_nso_build_id, proc_modules[1].build_id, sizeof(g_cheat_process_metadata.main_nso_build_id));
     }
-        
+
     /* Read cheats off the SD. */
-    if (!LoadCheats(g_cheat_process_metadata.title_id, g_cheat_process_metadata.main_nso_build_id)) {
+    if (!LoadCheats(g_cheat_process_metadata.title_id, g_cheat_process_metadata.main_nso_build_id) || !LoadCheatToggles(g_cheat_process_metadata.title_id)) {
         /* If we don't have cheats, or cheats are malformed, don't attach. */
         StartDebugProcess(g_cheat_process_metadata.process_id);
         g_cheat_process_metadata.process_id = 0;
         return;
     }
-    
+
     /* Open a debug handle. */
     if (R_FAILED((rc = svcDebugActiveProcess(&g_cheat_process_debug_hnd, g_cheat_process_metadata.process_id)))) {
         fatalSimple(rc);
     }
-    
+
     /* Start the process. */
     StartDebugProcess(g_cheat_process_metadata.process_id);
 
     /* Start debug events thread. */
     StartDebugEventsThread();
-        
+
     /* Signal to our fans. */
     g_cheat_process_event->Signal();
 }
@@ -864,43 +1027,43 @@ void DmntCheatManager::DetectThread(void *arg) {
     waiter->AddWaitable(LoadReadOnlySystemEvent(PrepareDebugNextApplication(), [](u64 timeout) {
         /* Process stuff for new application. */
         DmntCheatManager::OnNewApplicationLaunch();
-        
+
         /* Setup detection for the next application, and close the duplicate handle. */
         svcCloseHandle(PrepareDebugNextApplication());
-        
+
         return 0x0;
     }, true));
-    
+
     waiter->Process();
     delete waiter;
 }
- 
+
 void DmntCheatManager::VmThread(void *arg) {
     while (true) {
         /* Execute Cheat VM. */
         {
             /* Acquire lock. */
             std::scoped_lock<HosMutex> lk(g_cheat_lock);
-            
+
             if (HasActiveCheatProcess()) {
                 /* Execute VM. */
                 if (!g_needs_reload_vm_program || (g_cheat_vm->LoadProgram(g_cheat_entries, DmntCheatManager::MaxCheatCount))) {
                     /* Program: reloaded. */
                     g_needs_reload_vm_program = false;
-                    
+
                     /* Execute program if it's present. */
                     if (g_cheat_vm->GetProgramSize() != 0) {
                         g_cheat_vm->Execute(&g_cheat_process_metadata);
                     }
                 }
-                
+
                 /* Apply frozen addresses. */
                 for (auto const& [address, value] : g_frozen_addresses_map) {
                     WriteCheatProcessMemoryForVm(address, &value.value, value.width);
                 }
             }
         }
-        
+
         constexpr u64 ONE_SECOND = 1000000000ul;
         constexpr u64 NUM_TIMES = 12;
         constexpr u64 DELAY = ONE_SECOND / NUM_TIMES;
@@ -909,21 +1072,21 @@ void DmntCheatManager::VmThread(void *arg) {
 }
 
 void DmntCheatManager::DebugEventsThread(void *arg) {
-    
-    while (R_SUCCEEDED(svcWaitSynchronizationSingle(g_cheat_process_debug_hnd, U64_MAX))) {        
+
+    while (R_SUCCEEDED(svcWaitSynchronizationSingle(g_cheat_process_debug_hnd, U64_MAX))) {
         std::scoped_lock<HosMutex> lk(g_cheat_lock);
-        
+
         /* Handle any pending debug events. */
         if (HasActiveCheatProcess()) {
             DmntCheatDebugEventsManager::ContinueCheatProcess(g_cheat_process_debug_hnd);
         }
-        
+
     }
 }
 
 bool DmntCheatManager::GetHasActiveCheatProcess() {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     return HasActiveCheatProcess();
 }
 
@@ -933,42 +1096,46 @@ Handle DmntCheatManager::GetCheatProcessEventHandle() {
 
 Result DmntCheatManager::GetCheatProcessMetadata(CheatProcessMetadata *out) {
     std::scoped_lock<HosMutex> lk(g_cheat_lock);
-    
+
     if (HasActiveCheatProcess()) {
         *out = g_cheat_process_metadata;
         return 0;
     }
-    
+
     return ResultDmntCheatNotAttached;
 }
 
 void DmntCheatManager::InitializeCheatManager() {
     /* Create cheat process detection event. */
     g_cheat_process_event = CreateWriteOnlySystemEvent();
-    
+
     /* Create cheat vm. */
     g_cheat_vm = new DmntCheatVm();
-    
+
     /* Learn whether we should enable cheats by default. */
     {
         u8 en;
         if (R_SUCCEEDED(setsysGetSettingsItemValue("atmosphere", "dmnt_cheats_enabled_by_default", &en, sizeof(en)))) {
             g_enable_cheats_by_default = (en != 0);
         }
+
+        if (R_SUCCEEDED(setsysGetSettingsItemValue("atmosphere", "dmnt_always_save_cheat_toggles", &en, sizeof(en)))) {
+            g_always_save_cheat_toggles = (en != 0);
+        }
     }
-    
+
     /* Initialize debug events manager. */
     DmntCheatDebugEventsManager::Initialize();
-    
+
     /* Spawn application detection thread, spawn cheat vm thread. */
     if (R_FAILED(g_detect_thread.Initialize(&DmntCheatManager::DetectThread, nullptr, 0x4000, 39))) {
         std::abort();
     }
-    
+
     if (R_FAILED(g_vm_thread.Initialize(&DmntCheatManager::VmThread, nullptr, 0x4000, 48))) {
         std::abort();
     }
-    
+
     /* Start threads. */
     if (R_FAILED(g_detect_thread.Start()) || R_FAILED(g_vm_thread.Start())) {
         std::abort();
diff --git a/stratosphere/dmnt/source/dmnt_cheat_manager.hpp b/stratosphere/dmnt/source/dmnt_cheat_manager.hpp
index dc8bff712..0805e52e4 100644
--- a/stratosphere/dmnt/source/dmnt_cheat_manager.hpp
+++ b/stratosphere/dmnt/source/dmnt_cheat_manager.hpp
@@ -42,8 +42,13 @@ class DmntCheatManager {
         static void ResetAllCheatEntries();
         static CheatEntry *GetFreeCheatEntry();
         static CheatEntry *GetCheatEntryById(size_t i);
+        static CheatEntry *GetCheatEntryByReadableName(const char *readable_name);
         static bool ParseCheats(const char *cht_txt, size_t len);
         static bool LoadCheats(u64 title_id, const u8 *build_id);
+
+        static bool ParseCheatToggles(const char *s, size_t len);
+        static bool LoadCheatToggles(u64 title_id);
+        static void SaveCheatToggles(u64 title_id);
         
         static void ResetFrozenAddresses();
     public: