diff --git a/Source/Core/Core/BootManager.cpp b/Source/Core/Core/BootManager.cpp
index 574b8becc5..d2a1f86841 100644
--- a/Source/Core/Core/BootManager.cpp
+++ b/Source/Core/Core/BootManager.cpp
@@ -91,7 +91,7 @@ bool BootCore(std::unique_ptr<BootParameters> boot, const WindowSystemInfo& wsi)
       return false;
 
     Config::AddLayer(ConfigLoaders::GenerateNetPlayConfigLoader(*netplay_settings));
-    StartUp.bCopyWiiSaveNetplay = netplay_settings->m_CopyWiiSave;
+    StartUp.bCopyWiiSaveNetplay = netplay_settings->copy_wii_save;
   }
   else
   {
diff --git a/Source/Core/Core/ConfigLoaders/NetPlayConfigLoader.cpp b/Source/Core/Core/ConfigLoaders/NetPlayConfigLoader.cpp
index f52a828719..02eef5aaee 100644
--- a/Source/Core/Core/ConfigLoaders/NetPlayConfigLoader.cpp
+++ b/Source/Core/Core/ConfigLoaders/NetPlayConfigLoader.cpp
@@ -30,99 +30,99 @@ public:
 
   void Load(Config::Layer* layer) override
   {
-    layer->Set(Config::MAIN_CPU_THREAD, m_settings.m_CPUthread);
-    layer->Set(Config::MAIN_CPU_CORE, m_settings.m_CPUcore);
-    layer->Set(Config::MAIN_ENABLE_CHEATS, m_settings.m_EnableCheats);
-    layer->Set(Config::MAIN_GC_LANGUAGE, m_settings.m_SelectedLanguage);
-    layer->Set(Config::MAIN_OVERRIDE_REGION_SETTINGS, m_settings.m_OverrideRegionSettings);
-    layer->Set(Config::MAIN_DSP_HLE, m_settings.m_DSPHLE);
-    layer->Set(Config::MAIN_OVERCLOCK_ENABLE, m_settings.m_OCEnable);
-    layer->Set(Config::MAIN_OVERCLOCK, m_settings.m_OCFactor);
+    layer->Set(Config::MAIN_CPU_THREAD, m_settings.cpu_thread);
+    layer->Set(Config::MAIN_CPU_CORE, m_settings.cpu_core);
+    layer->Set(Config::MAIN_ENABLE_CHEATS, m_settings.enable_cheats);
+    layer->Set(Config::MAIN_GC_LANGUAGE, m_settings.selected_language);
+    layer->Set(Config::MAIN_OVERRIDE_REGION_SETTINGS, m_settings.override_region_settings);
+    layer->Set(Config::MAIN_DSP_HLE, m_settings.dsp_hle);
+    layer->Set(Config::MAIN_OVERCLOCK_ENABLE, m_settings.oc_enable);
+    layer->Set(Config::MAIN_OVERCLOCK, m_settings.oc_factor);
     for (ExpansionInterface::Slot slot : ExpansionInterface::SLOTS)
-      layer->Set(Config::GetInfoForEXIDevice(slot), m_settings.m_EXIDevice[slot]);
-    layer->Set(Config::MAIN_MEMORY_CARD_SIZE, m_settings.m_MemcardSizeOverride);
-    layer->Set(Config::SESSION_SAVE_DATA_WRITABLE, m_settings.m_WriteToMemcard);
-    layer->Set(Config::MAIN_RAM_OVERRIDE_ENABLE, m_settings.m_RAMOverrideEnable);
-    layer->Set(Config::MAIN_MEM1_SIZE, m_settings.m_Mem1Size);
-    layer->Set(Config::MAIN_MEM2_SIZE, m_settings.m_Mem2Size);
-    layer->Set(Config::MAIN_FALLBACK_REGION, m_settings.m_FallbackRegion);
-    layer->Set(Config::MAIN_ALLOW_SD_WRITES, m_settings.m_AllowSDWrites);
-    layer->Set(Config::MAIN_DSP_JIT, m_settings.m_DSPEnableJIT);
+      layer->Set(Config::GetInfoForEXIDevice(slot), m_settings.exi_device[slot]);
+    layer->Set(Config::MAIN_MEMORY_CARD_SIZE, m_settings.memcard_size_override);
+    layer->Set(Config::SESSION_SAVE_DATA_WRITABLE, m_settings.write_to_memcard);
+    layer->Set(Config::MAIN_RAM_OVERRIDE_ENABLE, m_settings.ram_override_enable);
+    layer->Set(Config::MAIN_MEM1_SIZE, m_settings.mem1_size);
+    layer->Set(Config::MAIN_MEM2_SIZE, m_settings.mem2_size);
+    layer->Set(Config::MAIN_FALLBACK_REGION, m_settings.fallback_region);
+    layer->Set(Config::MAIN_ALLOW_SD_WRITES, m_settings.allow_sd_writes);
+    layer->Set(Config::MAIN_DSP_JIT, m_settings.dsp_enable_jit);
 
     for (size_t i = 0; i < Config::SYSCONF_SETTINGS.size(); ++i)
     {
       std::visit(
           [&](auto* info) {
             layer->Set(*info, static_cast<decltype(info->GetDefaultValue())>(
-                                  m_settings.m_SYSCONFSettings[i]));
+                                  m_settings.sysconf_settings[i]));
           },
           Config::SYSCONF_SETTINGS[i].config_info);
     }
 
-    layer->Set(Config::GFX_HACK_EFB_ACCESS_ENABLE, m_settings.m_EFBAccessEnable);
-    layer->Set(Config::GFX_HACK_BBOX_ENABLE, m_settings.m_BBoxEnable);
-    layer->Set(Config::GFX_HACK_FORCE_PROGRESSIVE, m_settings.m_ForceProgressive);
-    layer->Set(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM, m_settings.m_EFBToTextureEnable);
-    layer->Set(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM, m_settings.m_XFBToTextureEnable);
-    layer->Set(Config::GFX_HACK_DISABLE_COPY_TO_VRAM, m_settings.m_DisableCopyToVRAM);
-    layer->Set(Config::GFX_HACK_IMMEDIATE_XFB, m_settings.m_ImmediateXFBEnable);
-    layer->Set(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES, m_settings.m_EFBEmulateFormatChanges);
+    layer->Set(Config::GFX_HACK_EFB_ACCESS_ENABLE, m_settings.efb_access_enable);
+    layer->Set(Config::GFX_HACK_BBOX_ENABLE, m_settings.bbox_enable);
+    layer->Set(Config::GFX_HACK_FORCE_PROGRESSIVE, m_settings.force_progressive);
+    layer->Set(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM, m_settings.efb_to_texture_enable);
+    layer->Set(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM, m_settings.xfb_to_texture_enable);
+    layer->Set(Config::GFX_HACK_DISABLE_COPY_TO_VRAM, m_settings.disable_copy_to_vram);
+    layer->Set(Config::GFX_HACK_IMMEDIATE_XFB, m_settings.immediate_xfb_enable);
+    layer->Set(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES, m_settings.efb_emulate_format_changes);
     layer->Set(Config::GFX_SAFE_TEXTURE_CACHE_COLOR_SAMPLES,
-               m_settings.m_SafeTextureCacheColorSamples);
-    layer->Set(Config::GFX_PERF_QUERIES_ENABLE, m_settings.m_PerfQueriesEnable);
-    layer->Set(Config::MAIN_FLOAT_EXCEPTIONS, m_settings.m_FloatExceptions);
-    layer->Set(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS, m_settings.m_DivideByZeroExceptions);
-    layer->Set(Config::MAIN_FPRF, m_settings.m_FPRF);
-    layer->Set(Config::MAIN_ACCURATE_NANS, m_settings.m_AccurateNaNs);
-    layer->Set(Config::MAIN_DISABLE_ICACHE, m_settings.m_DisableICache);
-    layer->Set(Config::MAIN_SYNC_ON_SKIP_IDLE, m_settings.m_SyncOnSkipIdle);
-    layer->Set(Config::MAIN_SYNC_GPU, m_settings.m_SyncGPU);
-    layer->Set(Config::MAIN_SYNC_GPU_MAX_DISTANCE, m_settings.m_SyncGpuMaxDistance);
-    layer->Set(Config::MAIN_SYNC_GPU_MIN_DISTANCE, m_settings.m_SyncGpuMinDistance);
-    layer->Set(Config::MAIN_SYNC_GPU_OVERCLOCK, m_settings.m_SyncGpuOverclock);
+               m_settings.safe_texture_cache_color_samples);
+    layer->Set(Config::GFX_PERF_QUERIES_ENABLE, m_settings.perf_queries_enable);
+    layer->Set(Config::MAIN_FLOAT_EXCEPTIONS, m_settings.float_exceptions);
+    layer->Set(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS, m_settings.divide_by_zero_exceptions);
+    layer->Set(Config::MAIN_FPRF, m_settings.fprf);
+    layer->Set(Config::MAIN_ACCURATE_NANS, m_settings.accurate_nans);
+    layer->Set(Config::MAIN_DISABLE_ICACHE, m_settings.disable_icache);
+    layer->Set(Config::MAIN_SYNC_ON_SKIP_IDLE, m_settings.sync_on_skip_idle);
+    layer->Set(Config::MAIN_SYNC_GPU, m_settings.sync_gpu);
+    layer->Set(Config::MAIN_SYNC_GPU_MAX_DISTANCE, m_settings.sync_gpu_max_distance);
+    layer->Set(Config::MAIN_SYNC_GPU_MIN_DISTANCE, m_settings.sync_gpu_min_distance);
+    layer->Set(Config::MAIN_SYNC_GPU_OVERCLOCK, m_settings.sync_gpu_overclock);
 
-    layer->Set(Config::MAIN_JIT_FOLLOW_BRANCH, m_settings.m_JITFollowBranch);
-    layer->Set(Config::MAIN_FAST_DISC_SPEED, m_settings.m_FastDiscSpeed);
-    layer->Set(Config::MAIN_MMU, m_settings.m_MMU);
-    layer->Set(Config::MAIN_FASTMEM, m_settings.m_Fastmem);
-    layer->Set(Config::MAIN_SKIP_IPL, m_settings.m_SkipIPL);
-    layer->Set(Config::SESSION_LOAD_IPL_DUMP, m_settings.m_LoadIPLDump);
+    layer->Set(Config::MAIN_JIT_FOLLOW_BRANCH, m_settings.jit_follow_branch);
+    layer->Set(Config::MAIN_FAST_DISC_SPEED, m_settings.fast_disc_speed);
+    layer->Set(Config::MAIN_MMU, m_settings.mmu);
+    layer->Set(Config::MAIN_FASTMEM, m_settings.fastmem);
+    layer->Set(Config::MAIN_SKIP_IPL, m_settings.skip_ipl);
+    layer->Set(Config::SESSION_LOAD_IPL_DUMP, m_settings.load_ipl_dump);
 
-    layer->Set(Config::GFX_HACK_DEFER_EFB_COPIES, m_settings.m_DeferEFBCopies);
-    layer->Set(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE, m_settings.m_EFBAccessTileSize);
-    layer->Set(Config::GFX_HACK_EFB_DEFER_INVALIDATION, m_settings.m_EFBAccessDeferInvalidation);
+    layer->Set(Config::GFX_HACK_DEFER_EFB_COPIES, m_settings.defer_efb_copies);
+    layer->Set(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE, m_settings.efb_access_tile_size);
+    layer->Set(Config::GFX_HACK_EFB_DEFER_INVALIDATION, m_settings.efb_access_defer_invalidation);
 
-    layer->Set(Config::SESSION_USE_FMA, m_settings.m_UseFMA);
+    layer->Set(Config::SESSION_USE_FMA, m_settings.use_fma);
 
     layer->Set(Config::MAIN_BLUETOOTH_PASSTHROUGH_ENABLED, false);
 
-    if (m_settings.m_StrictSettingsSync)
+    if (m_settings.strict_settings_sync)
     {
-      layer->Set(Config::GFX_HACK_VERTEX_ROUNDING, m_settings.m_VertexRounding);
-      layer->Set(Config::GFX_EFB_SCALE, m_settings.m_InternalResolution);
-      layer->Set(Config::GFX_HACK_COPY_EFB_SCALED, m_settings.m_EFBScaledCopy);
-      layer->Set(Config::GFX_FAST_DEPTH_CALC, m_settings.m_FastDepthCalc);
-      layer->Set(Config::GFX_ENABLE_PIXEL_LIGHTING, m_settings.m_EnablePixelLighting);
-      layer->Set(Config::GFX_WIDESCREEN_HACK, m_settings.m_WidescreenHack);
-      layer->Set(Config::GFX_ENHANCE_FORCE_FILTERING, m_settings.m_ForceFiltering);
-      layer->Set(Config::GFX_ENHANCE_MAX_ANISOTROPY, m_settings.m_MaxAnisotropy);
-      layer->Set(Config::GFX_ENHANCE_FORCE_TRUE_COLOR, m_settings.m_ForceTrueColor);
-      layer->Set(Config::GFX_ENHANCE_DISABLE_COPY_FILTER, m_settings.m_DisableCopyFilter);
-      layer->Set(Config::GFX_DISABLE_FOG, m_settings.m_DisableFog);
+      layer->Set(Config::GFX_HACK_VERTEX_ROUNDING, m_settings.vertex_rounding);
+      layer->Set(Config::GFX_EFB_SCALE, m_settings.internal_resolution);
+      layer->Set(Config::GFX_HACK_COPY_EFB_SCALED, m_settings.efb_scaled_copy);
+      layer->Set(Config::GFX_FAST_DEPTH_CALC, m_settings.fast_depth_calc);
+      layer->Set(Config::GFX_ENABLE_PIXEL_LIGHTING, m_settings.enable_pixel_lighting);
+      layer->Set(Config::GFX_WIDESCREEN_HACK, m_settings.widescreen_hack);
+      layer->Set(Config::GFX_ENHANCE_FORCE_FILTERING, m_settings.force_filtering);
+      layer->Set(Config::GFX_ENHANCE_MAX_ANISOTROPY, m_settings.max_anisotropy);
+      layer->Set(Config::GFX_ENHANCE_FORCE_TRUE_COLOR, m_settings.force_true_color);
+      layer->Set(Config::GFX_ENHANCE_DISABLE_COPY_FILTER, m_settings.disable_copy_filter);
+      layer->Set(Config::GFX_DISABLE_FOG, m_settings.disable_fog);
       layer->Set(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION,
-                 m_settings.m_ArbitraryMipmapDetection);
+                 m_settings.arbitrary_mipmap_detection);
       layer->Set(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION_THRESHOLD,
-                 m_settings.m_ArbitraryMipmapDetectionThreshold);
-      layer->Set(Config::GFX_ENABLE_GPU_TEXTURE_DECODING, m_settings.m_EnableGPUTextureDecoding);
+                 m_settings.arbitrary_mipmap_detection_threshold);
+      layer->Set(Config::GFX_ENABLE_GPU_TEXTURE_DECODING, m_settings.enable_gpu_texture_decoding);
 
       // Disable AA as it isn't deterministic across GPUs
       layer->Set(Config::GFX_MSAA, 1);
       layer->Set(Config::GFX_SSAA, false);
     }
 
-    if (m_settings.m_SyncSaveData)
+    if (m_settings.sync_save_data)
     {
-      if (!m_settings.m_IsHosting)
+      if (!m_settings.is_hosting)
       {
         const std::string path = File::GetUserPath(D_GCUSER_IDX) + GC_MEMCARD_NETPLAY DIR_SEP;
         layer->Set(Config::MAIN_GCI_FOLDER_A_PATH_OVERRIDE, path + "Card A");
@@ -130,7 +130,7 @@ public:
 
         const auto make_memcard_path = [this](char letter) {
           return fmt::format("{}{}{}.{}.raw", File::GetUserPath(D_GCUSER_IDX), GC_MEMCARD_NETPLAY,
-                             letter, m_settings.m_SaveDataRegion);
+                             letter, m_settings.save_data_region);
         };
         layer->Set(Config::MAIN_MEMCARD_A_PATH, make_memcard_path('A'));
         layer->Set(Config::MAIN_MEMCARD_B_PATH, make_memcard_path('B'));
@@ -140,14 +140,14 @@ public:
     }
 
 #ifdef HAS_LIBMGBA
-    for (size_t i = 0; i < m_settings.m_GBARomPaths.size(); ++i)
+    for (size_t i = 0; i < m_settings.gba_rom_paths.size(); ++i)
     {
-      layer->Set(Config::MAIN_GBA_ROM_PATHS[i], m_settings.m_GBARomPaths[i]);
+      layer->Set(Config::MAIN_GBA_ROM_PATHS[i], m_settings.gba_rom_paths[i]);
     }
 #endif
 
     // Check To Override Client's Cheat Codes
-    if (m_settings.m_SyncCodes && !m_settings.m_IsHosting)
+    if (m_settings.sync_codes && !m_settings.is_hosting)
     {
       // Raise flag to use host's codes
       layer->Set(Config::SESSION_CODE_SYNC_OVERRIDE, true);
diff --git a/Source/Core/Core/NetPlayClient.cpp b/Source/Core/Core/NetPlayClient.cpp
index ddba519b8c..090ff2353f 100644
--- a/Source/Core/Core/NetPlayClient.cpp
+++ b/Source/Core/Core/NetPlayClient.cpp
@@ -635,7 +635,7 @@ void NetPlayClient::OnGBAConfig(sf::Packet& packet)
         std::tie(old_config.has_rom, old_config.title, old_config.hash))
     {
       m_dialog->OnMsgChangeGBARom(static_cast<int>(i), config);
-      m_net_settings.m_GBARomPaths[i] =
+      m_net_settings.gba_rom_paths[i] =
           config.has_rom ?
               m_dialog->FindGBARomPath(config.hash, config.title, static_cast<int>(i)) :
               "";
@@ -809,92 +809,91 @@ void NetPlayClient::OnStartGame(sf::Packet& packet)
     INFO_LOG_FMT(NETPLAY, "Start of game {}", m_selected_game.game_id);
 
     packet >> m_current_game;
-    packet >> m_net_settings.m_CPUthread;
-    packet >> m_net_settings.m_CPUcore;
-    packet >> m_net_settings.m_EnableCheats;
-    packet >> m_net_settings.m_SelectedLanguage;
-    packet >> m_net_settings.m_OverrideRegionSettings;
-    packet >> m_net_settings.m_DSPEnableJIT;
-    packet >> m_net_settings.m_DSPHLE;
-    packet >> m_net_settings.m_WriteToMemcard;
-    packet >> m_net_settings.m_RAMOverrideEnable;
-    packet >> m_net_settings.m_Mem1Size;
-    packet >> m_net_settings.m_Mem2Size;
-    packet >> m_net_settings.m_FallbackRegion;
-    packet >> m_net_settings.m_AllowSDWrites;
-    packet >> m_net_settings.m_CopyWiiSave;
-    packet >> m_net_settings.m_OCEnable;
-    packet >> m_net_settings.m_OCFactor;
+    packet >> m_net_settings.cpu_thread;
+    packet >> m_net_settings.cpu_core;
+    packet >> m_net_settings.enable_cheats;
+    packet >> m_net_settings.selected_language;
+    packet >> m_net_settings.override_region_settings;
+    packet >> m_net_settings.dsp_enable_jit;
+    packet >> m_net_settings.dsp_hle;
+    packet >> m_net_settings.write_to_memcard;
+    packet >> m_net_settings.ram_override_enable;
+    packet >> m_net_settings.mem1_size;
+    packet >> m_net_settings.mem2_size;
+    packet >> m_net_settings.fallback_region;
+    packet >> m_net_settings.allow_sd_writes;
+    packet >> m_net_settings.copy_wii_save;
+    packet >> m_net_settings.oc_enable;
+    packet >> m_net_settings.oc_factor;
 
     for (auto slot : ExpansionInterface::SLOTS)
-      packet >> m_net_settings.m_EXIDevice[slot];
+      packet >> m_net_settings.exi_device[slot];
 
-    packet >> m_net_settings.m_MemcardSizeOverride;
+    packet >> m_net_settings.memcard_size_override;
 
-    for (u32& value : m_net_settings.m_SYSCONFSettings)
+    for (u32& value : m_net_settings.sysconf_settings)
       packet >> value;
 
-    packet >> m_net_settings.m_EFBAccessEnable;
-    packet >> m_net_settings.m_BBoxEnable;
-    packet >> m_net_settings.m_ForceProgressive;
-    packet >> m_net_settings.m_EFBToTextureEnable;
-    packet >> m_net_settings.m_XFBToTextureEnable;
-    packet >> m_net_settings.m_DisableCopyToVRAM;
-    packet >> m_net_settings.m_ImmediateXFBEnable;
-    packet >> m_net_settings.m_EFBEmulateFormatChanges;
-    packet >> m_net_settings.m_SafeTextureCacheColorSamples;
-    packet >> m_net_settings.m_PerfQueriesEnable;
-    packet >> m_net_settings.m_FloatExceptions;
-    packet >> m_net_settings.m_DivideByZeroExceptions;
-    packet >> m_net_settings.m_FPRF;
-    packet >> m_net_settings.m_AccurateNaNs;
-    packet >> m_net_settings.m_DisableICache;
-    packet >> m_net_settings.m_SyncOnSkipIdle;
-    packet >> m_net_settings.m_SyncGPU;
-    packet >> m_net_settings.m_SyncGpuMaxDistance;
-    packet >> m_net_settings.m_SyncGpuMinDistance;
-    packet >> m_net_settings.m_SyncGpuOverclock;
-    packet >> m_net_settings.m_JITFollowBranch;
-    packet >> m_net_settings.m_FastDiscSpeed;
-    packet >> m_net_settings.m_MMU;
-    packet >> m_net_settings.m_Fastmem;
-    packet >> m_net_settings.m_SkipIPL;
-    packet >> m_net_settings.m_LoadIPLDump;
-    packet >> m_net_settings.m_VertexRounding;
-    packet >> m_net_settings.m_InternalResolution;
-    packet >> m_net_settings.m_EFBScaledCopy;
-    packet >> m_net_settings.m_FastDepthCalc;
-    packet >> m_net_settings.m_EnablePixelLighting;
-    packet >> m_net_settings.m_WidescreenHack;
-    packet >> m_net_settings.m_ForceFiltering;
-    packet >> m_net_settings.m_MaxAnisotropy;
-    packet >> m_net_settings.m_ForceTrueColor;
-    packet >> m_net_settings.m_DisableCopyFilter;
-    packet >> m_net_settings.m_DisableFog;
-    packet >> m_net_settings.m_ArbitraryMipmapDetection;
-    packet >> m_net_settings.m_ArbitraryMipmapDetectionThreshold;
-    packet >> m_net_settings.m_EnableGPUTextureDecoding;
-    packet >> m_net_settings.m_DeferEFBCopies;
-    packet >> m_net_settings.m_EFBAccessTileSize;
-    packet >> m_net_settings.m_EFBAccessDeferInvalidation;
-    packet >> m_net_settings.m_StrictSettingsSync;
+    packet >> m_net_settings.efb_access_enable;
+    packet >> m_net_settings.bbox_enable;
+    packet >> m_net_settings.force_progressive;
+    packet >> m_net_settings.efb_to_texture_enable;
+    packet >> m_net_settings.xfb_to_texture_enable;
+    packet >> m_net_settings.disable_copy_to_vram;
+    packet >> m_net_settings.immediate_xfb_enable;
+    packet >> m_net_settings.efb_emulate_format_changes;
+    packet >> m_net_settings.safe_texture_cache_color_samples;
+    packet >> m_net_settings.perf_queries_enable;
+    packet >> m_net_settings.float_exceptions;
+    packet >> m_net_settings.divide_by_zero_exceptions;
+    packet >> m_net_settings.fprf;
+    packet >> m_net_settings.accurate_nans;
+    packet >> m_net_settings.disable_icache;
+    packet >> m_net_settings.sync_on_skip_idle;
+    packet >> m_net_settings.sync_gpu;
+    packet >> m_net_settings.sync_gpu_max_distance;
+    packet >> m_net_settings.sync_gpu_min_distance;
+    packet >> m_net_settings.sync_gpu_overclock;
+    packet >> m_net_settings.jit_follow_branch;
+    packet >> m_net_settings.fast_disc_speed;
+    packet >> m_net_settings.mmu;
+    packet >> m_net_settings.fastmem;
+    packet >> m_net_settings.skip_ipl;
+    packet >> m_net_settings.load_ipl_dump;
+    packet >> m_net_settings.vertex_rounding;
+    packet >> m_net_settings.internal_resolution;
+    packet >> m_net_settings.efb_scaled_copy;
+    packet >> m_net_settings.fast_depth_calc;
+    packet >> m_net_settings.enable_pixel_lighting;
+    packet >> m_net_settings.widescreen_hack;
+    packet >> m_net_settings.force_filtering;
+    packet >> m_net_settings.max_anisotropy;
+    packet >> m_net_settings.force_true_color;
+    packet >> m_net_settings.disable_copy_filter;
+    packet >> m_net_settings.disable_fog;
+    packet >> m_net_settings.arbitrary_mipmap_detection;
+    packet >> m_net_settings.arbitrary_mipmap_detection_threshold;
+    packet >> m_net_settings.enable_gpu_texture_decoding;
+    packet >> m_net_settings.defer_efb_copies;
+    packet >> m_net_settings.efb_access_tile_size;
+    packet >> m_net_settings.efb_access_defer_invalidation;
+    packet >> m_net_settings.strict_settings_sync;
 
     m_initial_rtc = Common::PacketReadU64(packet);
 
-    packet >> m_net_settings.m_SyncSaveData;
-    packet >> m_net_settings.m_SaveDataRegion;
-    packet >> m_net_settings.m_SyncCodes;
-    packet >> m_net_settings.m_SyncAllWiiSaves;
+    packet >> m_net_settings.sync_save_data;
+    packet >> m_net_settings.save_data_region;
+    packet >> m_net_settings.sync_codes;
+    packet >> m_net_settings.sync_all_wii_saves;
 
-    for (int& extension : m_net_settings.m_WiimoteExtension)
+    for (int& extension : m_net_settings.wiimote_extension)
       packet >> extension;
 
-    packet >> m_net_settings.m_GolfMode;
-    packet >> m_net_settings.m_UseFMA;
-    packet >> m_net_settings.m_HideRemoteGBAs;
+    packet >> m_net_settings.golf_mode;
+    packet >> m_net_settings.use_fma;
+    packet >> m_net_settings.hide_remote_gbas;
 
-    m_net_settings.m_IsHosting = m_local_player->IsHost();
-    m_net_settings.m_HostInputAuthority = m_host_input_authority;
+    m_net_settings.is_hosting = m_local_player->IsHost();
   }
 
   m_dialog->OnMsgStartGame();
@@ -2300,7 +2299,7 @@ void NetPlayClient::SendPowerButtonEvent()
 
 void NetPlayClient::RequestGolfControl(const PlayerId pid)
 {
-  if (!m_host_input_authority || !m_net_settings.m_GolfMode)
+  if (!m_host_input_authority || !m_net_settings.golf_mode)
     return;
 
   sf::Packet packet;
@@ -2402,7 +2401,7 @@ void NetPlayClient::SendGameStatus()
   for (size_t i = 0; i < 4; ++i)
   {
     if (m_gba_config[i].enabled && m_gba_config[i].has_rom &&
-        m_net_settings.m_GBARomPaths[i].empty())
+        m_net_settings.gba_rom_paths[i].empty())
     {
       result = SyncIdentifierComparison::DifferentGame;
     }
@@ -2592,7 +2591,7 @@ bool IsSyncingAllWiiSaves()
   std::lock_guard lk(crit_netplay_client);
 
   if (netplay_client)
-    return netplay_client->GetNetSettings().m_SyncAllWiiSaves;
+    return netplay_client->GetNetSettings().sync_all_wii_saves;
 
   return false;
 }
@@ -2602,14 +2601,14 @@ void SetupWiimotes()
   ASSERT(IsNetPlayRunning());
   const NetSettings& netplay_settings = netplay_client->GetNetSettings();
   const PadMappingArray& wiimote_map = netplay_client->GetWiimoteMapping();
-  for (size_t i = 0; i < netplay_settings.m_WiimoteExtension.size(); i++)
+  for (size_t i = 0; i < netplay_settings.wiimote_extension.size(); i++)
   {
     if (wiimote_map[i] > 0)
     {
       static_cast<ControllerEmu::Attachments*>(
           static_cast<WiimoteEmu::Wiimote*>(Wiimote::GetConfig()->GetController(int(i)))
               ->GetWiimoteGroup(WiimoteEmu::WiimoteGroup::Attachments))
-          ->SetSelectedAttachment(netplay_settings.m_WiimoteExtension[i]);
+          ->SetSelectedAttachment(netplay_settings.wiimote_extension[i]);
     }
   }
 }
@@ -2618,7 +2617,7 @@ std::string GetGBASavePath(int pad_num)
 {
   std::lock_guard lk(crit_netplay_client);
 
-  if (!netplay_client || netplay_client->GetNetSettings().m_IsHosting)
+  if (!netplay_client || netplay_client->GetNetSettings().is_hosting)
   {
 #ifdef HAS_LIBMGBA
     std::string rom_path = Config::Get(Config::MAIN_GBA_ROM_PATHS[pad_num]);
@@ -2628,7 +2627,7 @@ std::string GetGBASavePath(int pad_num)
 #endif
   }
 
-  if (!netplay_client->GetNetSettings().m_SyncSaveData)
+  if (!netplay_client->GetNetSettings().sync_save_data)
     return {};
 
   return fmt::format("{}{}{}.sav", File::GetUserPath(D_GBAUSER_IDX), GBA_SAVE_NETPLAY, pad_num + 1);
@@ -2664,7 +2663,7 @@ PadDetails GetPadDetails(int pad_num)
   }
   res.is_local = netplay_client->IsLocalPlayer(pad_map[pad_num]);
   res.local_pad = res.is_local ? local_pad : netplay_client->NumLocalPads() + non_local_pad;
-  res.hide_gba = !res.is_local && netplay_client->GetNetSettings().m_HideRemoteGBAs &&
+  res.hide_gba = !res.is_local && netplay_client->GetNetSettings().hide_remote_gbas &&
                  netplay_client->LocalPlayerHasControllerMapped();
   return res;
 }
diff --git a/Source/Core/Core/NetPlayProto.h b/Source/Core/Core/NetPlayProto.h
index 35f6dddf53..cc8eb77e23 100644
--- a/Source/Core/Core/NetPlayProto.h
+++ b/Source/Core/Core/NetPlayProto.h
@@ -30,85 +30,84 @@ namespace NetPlay
 {
 struct NetSettings
 {
-  bool m_CPUthread = false;
-  PowerPC::CPUCore m_CPUcore{};
-  bool m_EnableCheats = false;
-  int m_SelectedLanguage = 0;
-  bool m_OverrideRegionSettings = false;
-  bool m_DSPHLE = false;
-  bool m_DSPEnableJIT = false;
-  bool m_WriteToMemcard = false;
-  bool m_RAMOverrideEnable = false;
-  u32 m_Mem1Size = 0;
-  u32 m_Mem2Size = 0;
-  DiscIO::Region m_FallbackRegion{};
-  bool m_AllowSDWrites = false;
-  bool m_CopyWiiSave = false;
-  bool m_OCEnable = false;
-  float m_OCFactor = 0;
-  Common::EnumMap<ExpansionInterface::EXIDeviceType, ExpansionInterface::MAX_SLOT> m_EXIDevice{};
-  int m_MemcardSizeOverride = -1;
+  bool cpu_thread = false;
+  PowerPC::CPUCore cpu_core{};
+  bool enable_cheats = false;
+  int selected_language = 0;
+  bool override_region_settings = false;
+  bool dsp_hle = false;
+  bool dsp_enable_jit = false;
+  bool write_to_memcard = false;
+  bool ram_override_enable = false;
+  u32 mem1_size = 0;
+  u32 mem2_size = 0;
+  DiscIO::Region fallback_region{};
+  bool allow_sd_writes = false;
+  bool copy_wii_save = false;
+  bool oc_enable = false;
+  float oc_factor = 0;
+  Common::EnumMap<ExpansionInterface::EXIDeviceType, ExpansionInterface::MAX_SLOT> exi_device{};
+  int memcard_size_override = -1;
 
-  std::array<u32, Config::SYSCONF_SETTINGS.size()> m_SYSCONFSettings{};
+  std::array<u32, Config::SYSCONF_SETTINGS.size()> sysconf_settings{};
 
-  bool m_EFBAccessEnable = false;
-  bool m_BBoxEnable = false;
-  bool m_ForceProgressive = false;
-  bool m_EFBToTextureEnable = false;
-  bool m_XFBToTextureEnable = false;
-  bool m_DisableCopyToVRAM = false;
-  bool m_ImmediateXFBEnable = false;
-  bool m_EFBEmulateFormatChanges = false;
-  int m_SafeTextureCacheColorSamples = 0;
-  bool m_PerfQueriesEnable = false;
-  bool m_FloatExceptions = false;
-  bool m_DivideByZeroExceptions = false;
-  bool m_FPRF = false;
-  bool m_AccurateNaNs = false;
-  bool m_DisableICache = false;
-  bool m_SyncOnSkipIdle = false;
-  bool m_SyncGPU = false;
-  int m_SyncGpuMaxDistance = 0;
-  int m_SyncGpuMinDistance = 0;
-  float m_SyncGpuOverclock = 0;
-  bool m_JITFollowBranch = false;
-  bool m_FastDiscSpeed = false;
-  bool m_MMU = false;
-  bool m_Fastmem = false;
-  bool m_SkipIPL = false;
-  bool m_LoadIPLDump = false;
-  bool m_VertexRounding = false;
-  int m_InternalResolution = 0;
-  bool m_EFBScaledCopy = false;
-  bool m_FastDepthCalc = false;
-  bool m_EnablePixelLighting = false;
-  bool m_WidescreenHack = false;
-  bool m_ForceFiltering = false;
-  int m_MaxAnisotropy = 0;
-  bool m_ForceTrueColor = false;
-  bool m_DisableCopyFilter = false;
-  bool m_DisableFog = false;
-  bool m_ArbitraryMipmapDetection = false;
-  float m_ArbitraryMipmapDetectionThreshold = 0;
-  bool m_EnableGPUTextureDecoding = false;
-  bool m_DeferEFBCopies = false;
-  int m_EFBAccessTileSize = 0;
-  bool m_EFBAccessDeferInvalidation = false;
+  bool efb_access_enable = false;
+  bool bbox_enable = false;
+  bool force_progressive = false;
+  bool efb_to_texture_enable = false;
+  bool xfb_to_texture_enable = false;
+  bool disable_copy_to_vram = false;
+  bool immediate_xfb_enable = false;
+  bool efb_emulate_format_changes = false;
+  int safe_texture_cache_color_samples = 0;
+  bool perf_queries_enable = false;
+  bool float_exceptions = false;
+  bool divide_by_zero_exceptions = false;
+  bool fprf = false;
+  bool accurate_nans = false;
+  bool disable_icache = false;
+  bool sync_on_skip_idle = false;
+  bool sync_gpu = false;
+  int sync_gpu_max_distance = 0;
+  int sync_gpu_min_distance = 0;
+  float sync_gpu_overclock = 0;
+  bool jit_follow_branch = false;
+  bool fast_disc_speed = false;
+  bool mmu = false;
+  bool fastmem = false;
+  bool skip_ipl = false;
+  bool load_ipl_dump = false;
+  bool vertex_rounding = false;
+  int internal_resolution = 0;
+  bool efb_scaled_copy = false;
+  bool fast_depth_calc = false;
+  bool enable_pixel_lighting = false;
+  bool widescreen_hack = false;
+  bool force_filtering = false;
+  int max_anisotropy = 0;
+  bool force_true_color = false;
+  bool disable_copy_filter = false;
+  bool disable_fog = false;
+  bool arbitrary_mipmap_detection = false;
+  float arbitrary_mipmap_detection_threshold = 0;
+  bool enable_gpu_texture_decoding = false;
+  bool defer_efb_copies = false;
+  int efb_access_tile_size = 0;
+  bool efb_access_defer_invalidation = false;
 
-  bool m_StrictSettingsSync = false;
-  bool m_SyncSaveData = false;
-  bool m_SyncCodes = false;
-  std::string m_SaveDataRegion;
-  bool m_SyncAllWiiSaves = false;
-  std::array<int, 4> m_WiimoteExtension{};
-  bool m_GolfMode = false;
-  bool m_UseFMA = false;
-  bool m_HideRemoteGBAs = false;
+  bool strict_settings_sync = false;
+  bool sync_save_data = false;
+  bool sync_codes = false;
+  std::string save_data_region;
+  bool sync_all_wii_saves = false;
+  std::array<int, 4> wiimote_extension{};
+  bool golf_mode = false;
+  bool use_fma = false;
+  bool hide_remote_gbas = false;
 
   // These aren't sent over the network directly
-  bool m_IsHosting = false;
-  bool m_HostInputAuthority = false;
-  std::array<std::string, 4> m_GBARomPaths{};
+  bool is_hosting = false;
+  std::array<std::string, 4> gba_rom_paths{};
 };
 
 struct NetTraversalConfig
diff --git a/Source/Core/Core/NetPlayServer.cpp b/Source/Core/Core/NetPlayServer.cpp
index da69d1abfa..64656c64f3 100644
--- a/Source/Core/Core/NetPlayServer.cpp
+++ b/Source/Core/Core/NetPlayServer.cpp
@@ -862,7 +862,7 @@ unsigned int NetPlayServer::OnData(sf::Packet& packet, Client& player)
     if (!m_players.count(pid) || !PlayerHasControllerMapped(player.pid))
       break;
 
-    if (m_host_input_authority && m_settings.m_GolfMode && m_pending_golfer == 0 &&
+    if (m_host_input_authority && m_settings.golf_mode && m_pending_golfer == 0 &&
         m_current_golfer != pid && PlayerHasControllerMapped(pid))
     {
       m_pending_golfer = pid;
@@ -1254,22 +1254,22 @@ bool NetPlayServer::SetupNetSettings()
       ConfigLoaders::GenerateLocalGameConfigLoader(game->GetGameID(), game->GetRevision()));
 
   // Copy all relevant settings
-  settings.m_CPUthread = Config::Get(Config::MAIN_CPU_THREAD);
-  settings.m_CPUcore = Config::Get(Config::MAIN_CPU_CORE);
-  settings.m_EnableCheats = Config::Get(Config::MAIN_ENABLE_CHEATS);
-  settings.m_SelectedLanguage = Config::Get(Config::MAIN_GC_LANGUAGE);
-  settings.m_OverrideRegionSettings = Config::Get(Config::MAIN_OVERRIDE_REGION_SETTINGS);
-  settings.m_DSPHLE = Config::Get(Config::MAIN_DSP_HLE);
-  settings.m_DSPEnableJIT = Config::Get(Config::MAIN_DSP_JIT);
-  settings.m_WriteToMemcard = Config::Get(Config::NETPLAY_WRITE_SAVE_DATA);
-  settings.m_RAMOverrideEnable = Config::Get(Config::MAIN_RAM_OVERRIDE_ENABLE);
-  settings.m_Mem1Size = Config::Get(Config::MAIN_MEM1_SIZE);
-  settings.m_Mem2Size = Config::Get(Config::MAIN_MEM2_SIZE);
-  settings.m_FallbackRegion = Config::Get(Config::MAIN_FALLBACK_REGION);
-  settings.m_AllowSDWrites = Config::Get(Config::MAIN_ALLOW_SD_WRITES);
-  settings.m_CopyWiiSave = Config::Get(Config::NETPLAY_LOAD_WII_SAVE);
-  settings.m_OCEnable = Config::Get(Config::MAIN_OVERCLOCK_ENABLE);
-  settings.m_OCFactor = Config::Get(Config::MAIN_OVERCLOCK);
+  settings.cpu_thread = Config::Get(Config::MAIN_CPU_THREAD);
+  settings.cpu_core = Config::Get(Config::MAIN_CPU_CORE);
+  settings.enable_cheats = Config::Get(Config::MAIN_ENABLE_CHEATS);
+  settings.selected_language = Config::Get(Config::MAIN_GC_LANGUAGE);
+  settings.override_region_settings = Config::Get(Config::MAIN_OVERRIDE_REGION_SETTINGS);
+  settings.dsp_hle = Config::Get(Config::MAIN_DSP_HLE);
+  settings.dsp_enable_jit = Config::Get(Config::MAIN_DSP_JIT);
+  settings.write_to_memcard = Config::Get(Config::NETPLAY_WRITE_SAVE_DATA);
+  settings.ram_override_enable = Config::Get(Config::MAIN_RAM_OVERRIDE_ENABLE);
+  settings.mem1_size = Config::Get(Config::MAIN_MEM1_SIZE);
+  settings.mem2_size = Config::Get(Config::MAIN_MEM2_SIZE);
+  settings.fallback_region = Config::Get(Config::MAIN_FALLBACK_REGION);
+  settings.allow_sd_writes = Config::Get(Config::MAIN_ALLOW_SD_WRITES);
+  settings.copy_wii_save = Config::Get(Config::NETPLAY_LOAD_WII_SAVE);
+  settings.oc_enable = Config::Get(Config::MAIN_OVERCLOCK_ENABLE);
+  settings.oc_factor = Config::Get(Config::MAIN_OVERCLOCK);
 
   for (ExpansionInterface::Slot slot : ExpansionInterface::SLOTS)
   {
@@ -1283,75 +1283,75 @@ bool NetPlayServer::SetupNetSettings()
     {
       device = Config::Get(Config::GetInfoForEXIDevice(slot));
     }
-    settings.m_EXIDevice[slot] = device;
+    settings.exi_device[slot] = device;
   }
 
-  settings.m_MemcardSizeOverride = Config::Get(Config::MAIN_MEMORY_CARD_SIZE);
+  settings.memcard_size_override = Config::Get(Config::MAIN_MEMORY_CARD_SIZE);
 
   for (size_t i = 0; i < Config::SYSCONF_SETTINGS.size(); ++i)
   {
     std::visit(
         [&](auto* info) {
           static_assert(sizeof(info->GetDefaultValue()) <= sizeof(u32));
-          settings.m_SYSCONFSettings[i] = static_cast<u32>(Config::Get(*info));
+          settings.sysconf_settings[i] = static_cast<u32>(Config::Get(*info));
         },
         Config::SYSCONF_SETTINGS[i].config_info);
   }
 
-  settings.m_EFBAccessEnable = Config::Get(Config::GFX_HACK_EFB_ACCESS_ENABLE);
-  settings.m_BBoxEnable = Config::Get(Config::GFX_HACK_BBOX_ENABLE);
-  settings.m_ForceProgressive = Config::Get(Config::GFX_HACK_FORCE_PROGRESSIVE);
-  settings.m_EFBToTextureEnable = Config::Get(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM);
-  settings.m_XFBToTextureEnable = Config::Get(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM);
-  settings.m_DisableCopyToVRAM = Config::Get(Config::GFX_HACK_DISABLE_COPY_TO_VRAM);
-  settings.m_ImmediateXFBEnable = Config::Get(Config::GFX_HACK_IMMEDIATE_XFB);
-  settings.m_EFBEmulateFormatChanges = Config::Get(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES);
-  settings.m_SafeTextureCacheColorSamples =
+  settings.efb_access_enable = Config::Get(Config::GFX_HACK_EFB_ACCESS_ENABLE);
+  settings.bbox_enable = Config::Get(Config::GFX_HACK_BBOX_ENABLE);
+  settings.force_progressive = Config::Get(Config::GFX_HACK_FORCE_PROGRESSIVE);
+  settings.efb_to_texture_enable = Config::Get(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM);
+  settings.xfb_to_texture_enable = Config::Get(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM);
+  settings.disable_copy_to_vram = Config::Get(Config::GFX_HACK_DISABLE_COPY_TO_VRAM);
+  settings.immediate_xfb_enable = Config::Get(Config::GFX_HACK_IMMEDIATE_XFB);
+  settings.efb_emulate_format_changes = Config::Get(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES);
+  settings.safe_texture_cache_color_samples =
       Config::Get(Config::GFX_SAFE_TEXTURE_CACHE_COLOR_SAMPLES);
-  settings.m_PerfQueriesEnable = Config::Get(Config::GFX_PERF_QUERIES_ENABLE);
-  settings.m_FloatExceptions = Config::Get(Config::MAIN_FLOAT_EXCEPTIONS);
-  settings.m_DivideByZeroExceptions = Config::Get(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS);
-  settings.m_FPRF = Config::Get(Config::MAIN_FPRF);
-  settings.m_AccurateNaNs = Config::Get(Config::MAIN_ACCURATE_NANS);
-  settings.m_DisableICache = Config::Get(Config::MAIN_DISABLE_ICACHE);
-  settings.m_SyncOnSkipIdle = Config::Get(Config::MAIN_SYNC_ON_SKIP_IDLE);
-  settings.m_SyncGPU = Config::Get(Config::MAIN_SYNC_GPU);
-  settings.m_SyncGpuMaxDistance = Config::Get(Config::MAIN_SYNC_GPU_MAX_DISTANCE);
-  settings.m_SyncGpuMinDistance = Config::Get(Config::MAIN_SYNC_GPU_MIN_DISTANCE);
-  settings.m_SyncGpuOverclock = Config::Get(Config::MAIN_SYNC_GPU_OVERCLOCK);
-  settings.m_JITFollowBranch = Config::Get(Config::MAIN_JIT_FOLLOW_BRANCH);
-  settings.m_FastDiscSpeed = Config::Get(Config::MAIN_FAST_DISC_SPEED);
-  settings.m_MMU = Config::Get(Config::MAIN_MMU);
-  settings.m_Fastmem = Config::Get(Config::MAIN_FASTMEM);
-  settings.m_SkipIPL = Config::Get(Config::MAIN_SKIP_IPL) || !DoAllPlayersHaveIPLDump();
-  settings.m_LoadIPLDump = Config::Get(Config::SESSION_LOAD_IPL_DUMP) && DoAllPlayersHaveIPLDump();
-  settings.m_VertexRounding = Config::Get(Config::GFX_HACK_VERTEX_ROUNDING);
-  settings.m_InternalResolution = Config::Get(Config::GFX_EFB_SCALE);
-  settings.m_EFBScaledCopy = Config::Get(Config::GFX_HACK_COPY_EFB_SCALED);
-  settings.m_FastDepthCalc = Config::Get(Config::GFX_FAST_DEPTH_CALC);
-  settings.m_EnablePixelLighting = Config::Get(Config::GFX_ENABLE_PIXEL_LIGHTING);
-  settings.m_WidescreenHack = Config::Get(Config::GFX_WIDESCREEN_HACK);
-  settings.m_ForceFiltering = Config::Get(Config::GFX_ENHANCE_FORCE_FILTERING);
-  settings.m_MaxAnisotropy = Config::Get(Config::GFX_ENHANCE_MAX_ANISOTROPY);
-  settings.m_ForceTrueColor = Config::Get(Config::GFX_ENHANCE_FORCE_TRUE_COLOR);
-  settings.m_DisableCopyFilter = Config::Get(Config::GFX_ENHANCE_DISABLE_COPY_FILTER);
-  settings.m_DisableFog = Config::Get(Config::GFX_DISABLE_FOG);
-  settings.m_ArbitraryMipmapDetection = Config::Get(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION);
-  settings.m_ArbitraryMipmapDetectionThreshold =
+  settings.perf_queries_enable = Config::Get(Config::GFX_PERF_QUERIES_ENABLE);
+  settings.float_exceptions = Config::Get(Config::MAIN_FLOAT_EXCEPTIONS);
+  settings.divide_by_zero_exceptions = Config::Get(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS);
+  settings.fprf = Config::Get(Config::MAIN_FPRF);
+  settings.accurate_nans = Config::Get(Config::MAIN_ACCURATE_NANS);
+  settings.disable_icache = Config::Get(Config::MAIN_DISABLE_ICACHE);
+  settings.sync_on_skip_idle = Config::Get(Config::MAIN_SYNC_ON_SKIP_IDLE);
+  settings.sync_gpu = Config::Get(Config::MAIN_SYNC_GPU);
+  settings.sync_gpu_max_distance = Config::Get(Config::MAIN_SYNC_GPU_MAX_DISTANCE);
+  settings.sync_gpu_min_distance = Config::Get(Config::MAIN_SYNC_GPU_MIN_DISTANCE);
+  settings.sync_gpu_overclock = Config::Get(Config::MAIN_SYNC_GPU_OVERCLOCK);
+  settings.jit_follow_branch = Config::Get(Config::MAIN_JIT_FOLLOW_BRANCH);
+  settings.fast_disc_speed = Config::Get(Config::MAIN_FAST_DISC_SPEED);
+  settings.mmu = Config::Get(Config::MAIN_MMU);
+  settings.fastmem = Config::Get(Config::MAIN_FASTMEM);
+  settings.skip_ipl = Config::Get(Config::MAIN_SKIP_IPL) || !DoAllPlayersHaveIPLDump();
+  settings.load_ipl_dump = Config::Get(Config::SESSION_LOAD_IPL_DUMP) && DoAllPlayersHaveIPLDump();
+  settings.vertex_rounding = Config::Get(Config::GFX_HACK_VERTEX_ROUNDING);
+  settings.internal_resolution = Config::Get(Config::GFX_EFB_SCALE);
+  settings.efb_scaled_copy = Config::Get(Config::GFX_HACK_COPY_EFB_SCALED);
+  settings.fast_depth_calc = Config::Get(Config::GFX_FAST_DEPTH_CALC);
+  settings.enable_pixel_lighting = Config::Get(Config::GFX_ENABLE_PIXEL_LIGHTING);
+  settings.widescreen_hack = Config::Get(Config::GFX_WIDESCREEN_HACK);
+  settings.force_filtering = Config::Get(Config::GFX_ENHANCE_FORCE_FILTERING);
+  settings.max_anisotropy = Config::Get(Config::GFX_ENHANCE_MAX_ANISOTROPY);
+  settings.force_true_color = Config::Get(Config::GFX_ENHANCE_FORCE_TRUE_COLOR);
+  settings.disable_copy_filter = Config::Get(Config::GFX_ENHANCE_DISABLE_COPY_FILTER);
+  settings.disable_fog = Config::Get(Config::GFX_DISABLE_FOG);
+  settings.arbitrary_mipmap_detection = Config::Get(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION);
+  settings.arbitrary_mipmap_detection_threshold =
       Config::Get(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION_THRESHOLD);
-  settings.m_EnableGPUTextureDecoding = Config::Get(Config::GFX_ENABLE_GPU_TEXTURE_DECODING);
-  settings.m_DeferEFBCopies = Config::Get(Config::GFX_HACK_DEFER_EFB_COPIES);
-  settings.m_EFBAccessTileSize = Config::Get(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE);
-  settings.m_EFBAccessDeferInvalidation = Config::Get(Config::GFX_HACK_EFB_DEFER_INVALIDATION);
+  settings.enable_gpu_texture_decoding = Config::Get(Config::GFX_ENABLE_GPU_TEXTURE_DECODING);
+  settings.defer_efb_copies = Config::Get(Config::GFX_HACK_DEFER_EFB_COPIES);
+  settings.efb_access_tile_size = Config::Get(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE);
+  settings.efb_access_defer_invalidation = Config::Get(Config::GFX_HACK_EFB_DEFER_INVALIDATION);
 
-  settings.m_StrictSettingsSync = Config::Get(Config::NETPLAY_STRICT_SETTINGS_SYNC);
-  settings.m_SyncSaveData = Config::Get(Config::NETPLAY_SYNC_SAVES);
-  settings.m_SyncCodes = Config::Get(Config::NETPLAY_SYNC_CODES);
-  settings.m_SyncAllWiiSaves =
+  settings.strict_settings_sync = Config::Get(Config::NETPLAY_STRICT_SETTINGS_SYNC);
+  settings.sync_save_data = Config::Get(Config::NETPLAY_SYNC_SAVES);
+  settings.sync_codes = Config::Get(Config::NETPLAY_SYNC_CODES);
+  settings.sync_all_wii_saves =
       Config::Get(Config::NETPLAY_SYNC_ALL_WII_SAVES) && Config::Get(Config::NETPLAY_SYNC_SAVES);
-  settings.m_GolfMode = Config::Get(Config::NETPLAY_NETWORK_MODE) == "golf";
-  settings.m_UseFMA = DoAllPlayersHaveHardwareFMA();
-  settings.m_HideRemoteGBAs = Config::Get(Config::NETPLAY_HIDE_REMOTE_GBAS);
+  settings.golf_mode = Config::Get(Config::NETPLAY_NETWORK_MODE) == "golf";
+  settings.use_fma = DoAllPlayersHaveHardwareFMA();
+  settings.hide_remote_gbas = Config::Get(Config::NETPLAY_HIDE_REMOTE_GBAS);
 
   // Unload GameINI to restore things to normal
   Config::RemoveLayer(Config::LayerType::GlobalGame);
@@ -1382,7 +1382,7 @@ bool NetPlayServer::RequestStartGame()
 
   bool start_now = true;
 
-  if (m_settings.m_SyncSaveData && m_players.size() > 1)
+  if (m_settings.sync_save_data && m_players.size() > 1)
   {
     start_now = false;
     m_start_pending = true;
@@ -1395,7 +1395,7 @@ bool NetPlayServer::RequestStartGame()
   }
 
   // Check To Send Codes to Clients
-  if (m_settings.m_SyncCodes && m_players.size() > 1)
+  if (m_settings.sync_codes && m_players.size() > 1)
   {
     start_now = false;
     m_start_pending = true;
@@ -1455,82 +1455,82 @@ bool NetPlayServer::StartGame()
   sf::Packet spac;
   spac << MessageID::StartGame;
   spac << m_current_game;
-  spac << m_settings.m_CPUthread;
-  spac << m_settings.m_CPUcore;
-  spac << m_settings.m_EnableCheats;
-  spac << m_settings.m_SelectedLanguage;
-  spac << m_settings.m_OverrideRegionSettings;
-  spac << m_settings.m_DSPEnableJIT;
-  spac << m_settings.m_DSPHLE;
-  spac << m_settings.m_WriteToMemcard;
-  spac << m_settings.m_RAMOverrideEnable;
-  spac << m_settings.m_Mem1Size;
-  spac << m_settings.m_Mem2Size;
-  spac << m_settings.m_FallbackRegion;
-  spac << m_settings.m_AllowSDWrites;
-  spac << m_settings.m_CopyWiiSave;
-  spac << m_settings.m_OCEnable;
-  spac << m_settings.m_OCFactor;
+  spac << m_settings.cpu_thread;
+  spac << m_settings.cpu_core;
+  spac << m_settings.enable_cheats;
+  spac << m_settings.selected_language;
+  spac << m_settings.override_region_settings;
+  spac << m_settings.dsp_enable_jit;
+  spac << m_settings.dsp_hle;
+  spac << m_settings.write_to_memcard;
+  spac << m_settings.ram_override_enable;
+  spac << m_settings.mem1_size;
+  spac << m_settings.mem2_size;
+  spac << m_settings.fallback_region;
+  spac << m_settings.allow_sd_writes;
+  spac << m_settings.copy_wii_save;
+  spac << m_settings.oc_enable;
+  spac << m_settings.oc_factor;
 
   for (auto slot : ExpansionInterface::SLOTS)
-    spac << static_cast<int>(m_settings.m_EXIDevice[slot]);
+    spac << static_cast<int>(m_settings.exi_device[slot]);
 
-  spac << m_settings.m_MemcardSizeOverride;
+  spac << m_settings.memcard_size_override;
 
-  for (u32 value : m_settings.m_SYSCONFSettings)
+  for (u32 value : m_settings.sysconf_settings)
     spac << value;
 
-  spac << m_settings.m_EFBAccessEnable;
-  spac << m_settings.m_BBoxEnable;
-  spac << m_settings.m_ForceProgressive;
-  spac << m_settings.m_EFBToTextureEnable;
-  spac << m_settings.m_XFBToTextureEnable;
-  spac << m_settings.m_DisableCopyToVRAM;
-  spac << m_settings.m_ImmediateXFBEnable;
-  spac << m_settings.m_EFBEmulateFormatChanges;
-  spac << m_settings.m_SafeTextureCacheColorSamples;
-  spac << m_settings.m_PerfQueriesEnable;
-  spac << m_settings.m_FloatExceptions;
-  spac << m_settings.m_DivideByZeroExceptions;
-  spac << m_settings.m_FPRF;
-  spac << m_settings.m_AccurateNaNs;
-  spac << m_settings.m_DisableICache;
-  spac << m_settings.m_SyncOnSkipIdle;
-  spac << m_settings.m_SyncGPU;
-  spac << m_settings.m_SyncGpuMaxDistance;
-  spac << m_settings.m_SyncGpuMinDistance;
-  spac << m_settings.m_SyncGpuOverclock;
-  spac << m_settings.m_JITFollowBranch;
-  spac << m_settings.m_FastDiscSpeed;
-  spac << m_settings.m_MMU;
-  spac << m_settings.m_Fastmem;
-  spac << m_settings.m_SkipIPL;
-  spac << m_settings.m_LoadIPLDump;
-  spac << m_settings.m_VertexRounding;
-  spac << m_settings.m_InternalResolution;
-  spac << m_settings.m_EFBScaledCopy;
-  spac << m_settings.m_FastDepthCalc;
-  spac << m_settings.m_EnablePixelLighting;
-  spac << m_settings.m_WidescreenHack;
-  spac << m_settings.m_ForceFiltering;
-  spac << m_settings.m_MaxAnisotropy;
-  spac << m_settings.m_ForceTrueColor;
-  spac << m_settings.m_DisableCopyFilter;
-  spac << m_settings.m_DisableFog;
-  spac << m_settings.m_ArbitraryMipmapDetection;
-  spac << m_settings.m_ArbitraryMipmapDetectionThreshold;
-  spac << m_settings.m_EnableGPUTextureDecoding;
-  spac << m_settings.m_DeferEFBCopies;
-  spac << m_settings.m_EFBAccessTileSize;
-  spac << m_settings.m_EFBAccessDeferInvalidation;
-  spac << m_settings.m_StrictSettingsSync;
+  spac << m_settings.efb_access_enable;
+  spac << m_settings.bbox_enable;
+  spac << m_settings.force_progressive;
+  spac << m_settings.efb_to_texture_enable;
+  spac << m_settings.xfb_to_texture_enable;
+  spac << m_settings.disable_copy_to_vram;
+  spac << m_settings.immediate_xfb_enable;
+  spac << m_settings.efb_emulate_format_changes;
+  spac << m_settings.safe_texture_cache_color_samples;
+  spac << m_settings.perf_queries_enable;
+  spac << m_settings.float_exceptions;
+  spac << m_settings.divide_by_zero_exceptions;
+  spac << m_settings.fprf;
+  spac << m_settings.accurate_nans;
+  spac << m_settings.disable_icache;
+  spac << m_settings.sync_on_skip_idle;
+  spac << m_settings.sync_gpu;
+  spac << m_settings.sync_gpu_max_distance;
+  spac << m_settings.sync_gpu_min_distance;
+  spac << m_settings.sync_gpu_overclock;
+  spac << m_settings.jit_follow_branch;
+  spac << m_settings.fast_disc_speed;
+  spac << m_settings.mmu;
+  spac << m_settings.fastmem;
+  spac << m_settings.skip_ipl;
+  spac << m_settings.load_ipl_dump;
+  spac << m_settings.vertex_rounding;
+  spac << m_settings.internal_resolution;
+  spac << m_settings.efb_scaled_copy;
+  spac << m_settings.fast_depth_calc;
+  spac << m_settings.enable_pixel_lighting;
+  spac << m_settings.widescreen_hack;
+  spac << m_settings.force_filtering;
+  spac << m_settings.max_anisotropy;
+  spac << m_settings.force_true_color;
+  spac << m_settings.disable_copy_filter;
+  spac << m_settings.disable_fog;
+  spac << m_settings.arbitrary_mipmap_detection;
+  spac << m_settings.arbitrary_mipmap_detection_threshold;
+  spac << m_settings.enable_gpu_texture_decoding;
+  spac << m_settings.defer_efb_copies;
+  spac << m_settings.efb_access_tile_size;
+  spac << m_settings.efb_access_defer_invalidation;
+  spac << m_settings.strict_settings_sync;
   spac << initial_rtc;
-  spac << m_settings.m_SyncSaveData;
+  spac << m_settings.sync_save_data;
   spac << region;
-  spac << m_settings.m_SyncCodes;
-  spac << m_settings.m_SyncAllWiiSaves;
+  spac << m_settings.sync_codes;
+  spac << m_settings.sync_all_wii_saves;
 
-  for (size_t i = 0; i < m_settings.m_WiimoteExtension.size(); i++)
+  for (size_t i = 0; i < m_settings.wiimote_extension.size(); i++)
   {
     const int extension =
         static_cast<ControllerEmu::Attachments*>(
@@ -1540,9 +1540,9 @@ bool NetPlayServer::StartGame()
     spac << extension;
   }
 
-  spac << m_settings.m_GolfMode;
-  spac << m_settings.m_UseFMA;
-  spac << m_settings.m_HideRemoteGBAs;
+  spac << m_settings.golf_mode;
+  spac << m_settings.use_fma;
+  spac << m_settings.hide_remote_gbas;
 
   SendAsyncToClients(std::move(spac));
 
@@ -1574,7 +1574,7 @@ bool NetPlayServer::SyncSaveData()
 
   for (ExpansionInterface::Slot slot : ExpansionInterface::MEMCARD_SLOTS)
   {
-    if (m_settings.m_EXIDevice[slot] == ExpansionInterface::EXIDeviceType::MemoryCard ||
+    if (m_settings.exi_device[slot] == ExpansionInterface::EXIDeviceType::MemoryCard ||
         Config::Get(Config::GetInfoForEXIDevice(slot)) ==
             ExpansionInterface::EXIDeviceType::MemoryCardFolder)
     {
@@ -1590,7 +1590,7 @@ bool NetPlayServer::SyncSaveData()
   }
 
   bool wii_save = false;
-  if (m_settings.m_CopyWiiSave && (game->GetPlatform() == DiscIO::Platform::WiiDisc ||
+  if (m_settings.copy_wii_save && (game->GetPlatform() == DiscIO::Platform::WiiDisc ||
                                    game->GetPlatform() == DiscIO::Platform::WiiWAD ||
                                    game->GetPlatform() == DiscIO::Platform::ELFOrDOL))
   {
@@ -1635,9 +1635,9 @@ bool NetPlayServer::SyncSaveData()
   {
     const bool is_slot_a = slot == ExpansionInterface::Slot::A;
 
-    if (m_settings.m_EXIDevice[slot] == ExpansionInterface::EXIDeviceType::MemoryCard)
+    if (m_settings.exi_device[slot] == ExpansionInterface::EXIDeviceType::MemoryCard)
     {
-      const int size_override = m_settings.m_MemcardSizeOverride;
+      const int size_override = m_settings.memcard_size_override;
       const u16 card_size_mbits =
           size_override >= 0 && size_override <= 4 ?
               static_cast<u16>(Memcard::MBIT_SIZE_MEMORY_CARD_59 << size_override) :
@@ -1703,7 +1703,7 @@ bool NetPlayServer::SyncSaveData()
     const auto configured_fs = IOS::HLE::FS::MakeFileSystem(IOS::HLE::FS::Location::Configured);
 
     std::vector<std::pair<u64, WiiSave::StoragePointer>> saves;
-    if (m_settings.m_SyncAllWiiSaves)
+    if (m_settings.sync_all_wii_saves)
     {
       IOS::HLE::Kernel ios;
       for (const u64 title : ios.GetES()->GetInstalledTitles())
diff --git a/Source/Core/DolphinQt/NetPlay/NetPlayDialog.cpp b/Source/Core/DolphinQt/NetPlay/NetPlayDialog.cpp
index b994bd93f3..b86887873d 100644
--- a/Source/Core/DolphinQt/NetPlay/NetPlayDialog.cpp
+++ b/Source/Core/DolphinQt/NetPlay/NetPlayDialog.cpp
@@ -850,8 +850,7 @@ void NetPlayDialog::OnMsgStartGame()
   g_netplay_chat_ui =
       std::make_unique<NetPlayChatUI>([this](const std::string& message) { SendMessage(message); });
 
-  if (m_host_input_authority &&
-      Settings::Instance().GetNetPlayClient()->GetNetSettings().m_GolfMode)
+  if (m_host_input_authority && Settings::Instance().GetNetPlayClient()->GetNetSettings().golf_mode)
   {
     g_netplay_golf_ui = std::make_unique<NetPlayGolfUI>(Settings::Instance().GetNetPlayClient());
   }