3rdparty: Update xxHash to v0.8.3 (#12137 )

GS/GL: Properly name logs with GL prefix.
GS/D3D12: Properly name logs with D3D12 prefix.
2026-01-31 01:15:24 +01:00 · 2024-12-31 18:14:47 -05:00 · 2024-12-31 20:11:25 +01:00 · 2024-12-31 20:11:25 +01:00 · 2024-12-31 20:11:25 +01:00 · 2024-12-31 20:11:25 +01:00
76 changed files with 138565 additions and 89309 deletions
--- a/3rdparty/include/xxhash.h
+++ b/3rdparty/include/xxhash.h
--- a/bin/resources/game_controller_db.txt
+++ b/bin/resources/game_controller_db.txt
@@ -1117,6 +1117,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000172700004431000029010000,XiaoMi Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a6,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Mac OS X,
 03000000120c0000100e000000010000,Zeroplus P4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,
 03000000120c0000101e000000010000,Zeroplus P4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,
+03000000bc2000000155000000010000,SNK NEOGEO Arcade Stick Pro,a:b1,b:b4,x:b0,y:b3,back:b10,guide:b9,start:b11,leftshoulder:b2,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b6,righttrigger:b7,platform:Mac OS X,

 # Linux
 03000000c82d00000031000011010000,8BitDo Adapter,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
@@ -1324,7 +1325,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000000d0f00008501000015010000,Hori Switch Split Pad Pro,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000000d0f00006e00000011010000,Horipad 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f00006600000011010000,Horipad 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,
-030000000d0f0000ee00000011010000,Horipad Mini 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,
+030000000d0f0000ee00000011010000,Horipad Mini 4,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b13,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Linux,
 030000000d0f0000c100000011010000,Horipad Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f00006700000001010000,Horipad One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 050000000d0f0000f600000001000000,Horipad Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
@@ -1609,6 +1610,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000a30600001005000000010000,Saitek P150,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b7,lefttrigger:b6,rightshoulder:b2,righttrigger:b5,x:b3,y:b4,platform:Linux,
 03000000a30600000701000000010000,Saitek P220,a:b2,b:b3,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b4,righttrigger:b5,x:b0,y:b1,platform:Linux,
 03000000a30600000cff000010010000,Saitek P2500 Force Rumble,a:b2,b:b3,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b10,x:b0,y:b1,platform:Linux,
+03000000a30600000d5f000010010000,Saitek P2600,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a3,righty:a2,start:b8,x:b0,y:b3,platform:Linux,
 03000000a30600000c04000011010000,Saitek P2900,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b12,x:b0,y:b3,platform:Linux,
 03000000a306000018f5000010010000,Saitek P3200 Rumble,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Linux,
 03000000300f00001201000010010000,Saitek P380,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,
--- a/bin/utils/bulk_compression.py
+++ b/bin/utils/bulk_compression.py
@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+
+# PCSX2 - PS2 Emulator for PCs
+# Copyright (C) 2024 PCSX2 Dev Team
+#
+# PCSX2 is free software: you can redistribute it and/or modify it under the terms
+# of the GNU General Public License as published by the Free Software Found-
+# ation, either version 3 of the License, or (at your option) any later version.
+#
+# PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with PCSX2.
+# If not, see <https://www.gnu.org/licenses/>.
+
+import sys
+import os
+import re
+from subprocess import Popen, PIPE
+from os.path import exists
+
+gamecount = [0]
+
+# =================================================================================================
+
+def deletionChoice(source_extension):                               # Choose to delete source files
+
+    yesno = {
+        "n"   : 0,
+        "no"  : 0,
+        "y"   : 1,
+        "yes" : 1,
+    }
+
+    print("╟-------------------------------------------------------------------------------╢")
+    print(f"║ Do you want to delete the original {source_extension.upper()} files as they are converted?")
+    choice = input("║ Type Y or N then press ENTER: ").lower()
+
+    if (not choice in yesno):
+        exitInvalidOption()
+
+    return (yesno[choice])
+
+# -------------------------------------------------------------------------------------------------
+
+def blockSizeChoice(is_cd, decompressing):                          # Choose block size
+
+    if (decompressing):
+        return 0
+
+    sizes = {
+        "1" : 16384,
+        "2" : 131072,
+        "3" : 262144,
+    } if not is_cd else {
+        "1": 17136,
+        "2": 132192,
+        "3": 264384,
+    }
+
+    print("╟-------------------------------------------------------------------------------╢")
+    print("║ Please pick the block size you would like to use:")
+    print("║")
+    print("║   1 - 16 kB  (bigger files, faster access/less CPU, choose this if unsure)")
+    print("║   2 - 128 kB (balanced)")
+    print("║   3 - 256 kB (smaller files, slower access/more CPU)")
+    print("║")
+    blocksize = input("║ Type the number corresponding to your selection then press ENTER: ")
+
+    if (not blocksize in sizes):
+        exitInvalidOption()
+
+    return (sizes[blocksize])
+
+# =================================================================================================
+
+def checkSuccess(compressing, fname, extension, error_code): # Ensure file created properly
+
+    target_fname = f"{fname}.{extension}"
+    if (error_code):
+
+        print("╠===============================================================================╣")
+
+        if (compressing):
+            print(f"║ Compression to {extension.upper()} failed for the following:{(37 - len(extension)) * ' '}║")
+        else:
+            print(f"║ Extraction to {extension.upper()} failed for the following:{(38 - len(extension)) * ' '}║")
+
+        print(f"║ {target_fname}{(77 - len(target_fname)) * ' '}║")
+        print("╚===============================================================================╝")
+
+        sys.exit(1)
+
+    print(f"║ {target_fname} created.{(69 - len(target_fname)) * ' '}║")
+
+# -------------------------------------------------------------------------------------------------
+
+def checkProgramMissing(program):
+
+    if (sys.platform.startswith('win32') and exists(f"./{program}.exe")):
+        return                                                      # Windows
+
+    else:                                                           # Linux, macOS
+        from shutil import which
+        if (which(program) is not None):
+            return
+
+    print("╠===============================================================================╗")
+    print(f"║                   {program} failed, {program} is missing.{(39 - (len(program) * 2)) * ' '}║")
+    print("╚===============================================================================╝")
+    sys.exit(1)
+
+# -------------------------------------------------------------------------------------------------
+
+def checkBinCueMismatch(bin_files, cue_files):                      # Ensure all bins and cues match
+
+    if (len(bin_files) != len(cue_files)):                          # Ensure numerical parity
+        exitBinCueMismatch()
+
+    for fname in bin_files:                                         # Ensure filename parity
+        if (f"{fname[:-4]}.cue" not in cue_files):
+            exitBinCueMismatch()
+
+# -------------------------------------------------------------------------------------------------
+
+def checkDuplicates(source_files, target_extensions, crash_protection_type=0):
+
+    dupe_options = {
+        "s"          : 0,
+        "skip"       : 0,
+        "o"          : 1,
+        "overwrite"  : 1,
+    }
+
+    dupe_files = []
+    dupe_names = []
+    target_files = []
+
+    for extension in target_extensions:
+        target_files[len(target_files):] = returnFilteredPwdContents(extension)
+
+    for fname in source_files:
+        for extension in target_extensions:
+            target_fname = f"{fname[:-4]}.{extension}"
+            if (target_fname in target_files):
+                dupe_files.append(target_fname)
+
+    match crash_protection_type:
+        case 0:
+            pass
+        case 1:                                                     # Skip any dupe files no matter what
+            [dupe_names.append(fname[:-4]) for fname in dupe_files if fname[:-4] not in dupe_names]
+            return dupe_names
+        case 2:                                                     # Only skip if intermediate .iso present
+            [dupe_names.append(fname[:-4]) for fname in dupe_files if fname[:-4] not in dupe_names and fname[-4:] == ".iso"]
+        case _:
+            pass
+
+    if (not dupe_files):
+        return dupe_names
+
+    print("╟-------------------------------------------------------------------------------╢")
+    print("║ The following files were found which would be overwritten:")
+
+    for fname in dupe_files:
+        print(f"║  - {fname}")
+
+    print("║")
+    print("║ You may choose to OVERWRITE or SKIP all of these.")
+    if (crash_protection_type == 2):
+        print("║ NOTE: chdman cannot overwrite .cso files. These will be skipped regardless.")
+    choice = input("║ Press 'O' to overwrite or 'S' to skip and press ENTER: ").lower()
+
+    if (choice in dupe_options):
+        if (not dupe_options[choice]):                              # Skip
+            [dupe_names.append(fname[:-4]) for fname in dupe_files if fname[:-4] not in dupe_names]
+        return dupe_names
+    else:
+        exitInvalidOption()
+
+# =================================================================================================
+
+def printInitialStatus(decompressing, target_fname):
+
+    if (gamecount[0] != 0):
+        print("╟-------------------------------------------------------------------------------╢")
+    gamecount[0] += 1
+
+    if (decompressing):
+        print(f"║ Extracting to {target_fname}... ({gamecount[0]}){(58 - len(target_fname) - len(str(gamecount[0]))) * ' '}║")
+    else:
+        print(f"║ Compressing to {target_fname}... ({gamecount[0]}){(57 - len(target_fname) - len(str(gamecount[0]))) * ' '}║")
+
+# -------------------------------------------------------------------------------------------------
+
+def printSkip(target_fname):
+
+    if (gamecount[0] != 0):
+        print("╟-------------------------------------------------------------------------------╢")
+    gamecount[0] += 1
+    print(f"║ Skipping creation of {target_fname}{(57 - len(target_fname)) * ' '}║")
+
+# =================================================================================================
+
+def createCommandList(mode, source_fname, target_fname, blocksize=0):
+
+    match mode:
+        case 1:
+            return [["maxcso", f"--block={blocksize}", source_fname]]
+        case 2:
+            return [["chdman", "createraw", "-us", "2048", "-hs", f"{blocksize}", "-f", "-i", source_fname, "-o", target_fname]]
+        case 3:
+            return [["chdman", "createcd", "-hs", f"{blocksize}", "-i", source_fname, "-o", f"{source_fname[:-4]}.chd"]]
+        case 4:
+            return [["maxcso", "--decompress", source_fname],
+                    ["chdman", "createraw", "-us", "2048", "-hs", f"{blocksize}", "-f", "-i", f"{source_fname[:-4]}.iso", "-o", f"{source_fname[:-4]}.chd"]]
+        case 5:
+            return [["chdman", "extractraw", "-i", source_fname, "-o", f"{source_fname[:-4]}.iso"],
+                    ["maxcso", f"--block={blocksize}", f"{source_fname[:-4]}.iso"]]
+        case 6:
+            return [["chdman", "extractraw", "-i", source_fname, "-o", target_fname]]
+        case 7:
+            return [["chdman", "extractcd", "-i", source_fname, "-o", target_fname]]
+        case 8:
+            return [["maxcso", "--decompress", source_fname]]
+        case _:
+            print("You have somehow chosen an invalid mode, and this was not correctly caught by the program.\nPlease report this as a bug.")
+            sys.exit(1)
+
+# =================================================================================================
+
+def returnFilteredPwdContents(file_extension):                      # Get files in pwd with extension
+
+    extension_pattern = r".*\." + file_extension.lower()
+    extension_reg = re.compile(extension_pattern)
+    return [fname for fname in os.listdir('.') if extension_reg.match(fname)]
+
+# -------------------------------------------------------------------------------------------------
+
+def deleteFile(fname):                                              # Delete a file in pwd
+
+    print(f"║ Deleting {fname}...{(66 - len(fname)) * ' '}║")
+    os.remove(f"./{fname}")
+
+# =================================================================================================
+
+def exitInvalidOption():
+
+    print("╠===============================================================================╗")
+    print("║                              Invalid option.                                  ║")
+    print("╚===============================================================================╝")
+    sys.exit(1)
+
+# -------------------------------------------------------------------------------------------------
+
+def exitBinCueMismatch():
+
+    print("╠===============================================================================╗")
+    print("║                   All BIN files must have a matching CUE.                     ║")
+    print("╚===============================================================================╝")
+    sys.exit(1)
+
+# =================================================================================================
+# /////////////////////////////////////////////////////////////////////////////////////////////////
+# =================================================================================================
+
+options = {                                                         # Options listings
+    1 : "Convert ISO to CSO",
+    2 : "Convert ISO to CHD",
+    3 : "Convert CUE/BIN to CHD",
+    4 : "Convert CSO to CHD",
+    5 : "Convert DVD CHD to CSO",
+    6 : "Extract DVD CHD to ISO",
+    7 : "Extract CD CHD to CUE/BIN",
+    8 : "Extract CSO to ISO",
+    9 : "Exit script",
+}
+
+# -------------------------------------------------------------------------------------------------
+
+sources = {                                                         # Source file extensions
+    1 : "iso",
+    2 : "iso",
+    3 : "cue/bin",
+    4 : "cso",
+    5 : "chd",
+    6 : "chd",
+    7 : "chd",
+    8 : "cso",
+}
+
+# -------------------------------------------------------------------------------------------------
+
+targets = {                                                         # Target file extensions
+    1 : ["cso"],
+    2 : ["chd"],
+    3 : ["chd"],
+    4 : ["iso", "chd"],
+    5 : ["iso", "cso"],
+    6 : ["iso"],
+    7 : ["cue", "bin"],
+    8 : ["iso"],
+}
+
+# # -------------------------------------------------------------------------------------------------
+
+reqs = {                                                            # Selection dependencies
+    1 : ["maxcso"],
+    2 : ["chdman"],
+    3 : ["chdman"],
+    4 : ["maxcso", "chdman"],
+    5 : ["maxcso", "chdman"],
+    6 : ["chdman"],
+    7 : ["chdman"],
+    8 : ["maxcso"],
+}
+
+# -------------------------------------------------------------------------------------------------
+
+print("╔===============================================================================╗")
+print("║  CSO/CHD/ISO/CUEBIN Conversion by Refraction, RedDevilus and TheTechnician27  ║")
+print("║                           (Version Jul 16 2024)                               ║")
+print("╠===============================================================================╣")
+print("║                                                                               ║")
+print("║ PLEASE NOTE: This will affect all files in this folder!                       ║")
+print("║ Be sure to run this from the same directory as the files you wish to convert. ║")
+print("║                                                                               ║")
+
+for number, message in options.items():
+    print("║ ", number, " - ", message, f"{(70 - len(message)) * ' '}║")
+
+print("║                                                                               ║")
+print("╠===============================================================================╝")
+#print("║")
+mode = input("║ Type the number corresponding to your selection then press ENTER: ")
+
+# -------------------------------------------------------------------------------------------------
+
+try:
+    mode = int(mode)
+
+except ValueError:
+    exitInvalidOption()
+
+# -------------------------------------------------------------------------------------------------
+
+if (mode < 9 and mode > 0):
+
+    for program in reqs[mode]:                                  # Check for dependencies
+        checkProgramMissing(program)
+
+    delete = deletionChoice(sources[mode])                      # Choose to delete source files
+    blocksize = blockSizeChoice(mode == 3, mode > 5)            # Choose block size if compressing
+
+    match mode:
+        case 3:
+            bin_files = returnFilteredPwdContents("bin")        # Get all BIN files in pwd
+            source_files = returnFilteredPwdContents("cue")     # Get all CUE files in pwd
+            checkBinCueMismatch(bin_files, source_files)
+            dupe_list = checkDuplicates(source_files, targets[mode], 1)
+        case 5:
+            source_files = returnFilteredPwdContents(sources[mode]) # Get source files in pwd
+            dupe_list = checkDuplicates(source_files, targets[mode], 2)
+        case 6:
+            source_files = returnFilteredPwdContents(sources[mode]) # Get source files in pwd
+            dupe_list = checkDuplicates(source_files, targets[mode], 1)
+        case _:
+            source_files = returnFilteredPwdContents(sources[mode]) # Get source files in pwd
+            dupe_list = checkDuplicates(source_files, targets[mode])
+
+
+    print("╠===============================================================================╗")
+
+    # ---------------------------------------------------------------------------------------------
+
+    for fname in source_files:
+
+        target_fname = f"{fname[:-4]}.{targets[mode][0]}"
+        commands = createCommandList(mode, fname, target_fname, blocksize)
+        if (fname[:-4] in dupe_list):
+            printSkip(target_fname)
+            continue
+
+        printInitialStatus(mode > 5, f"{fname[:-4]}.{targets[mode][-1]}")
+
+        for step, command in enumerate (commands):
+
+            process = Popen(commands[step], stdout=PIPE, stderr=PIPE)   # Execute process
+            stdout, stderr = process.communicate()                      # Suppress output
+            checkSuccess(mode < 6, fname[:-4],                          # Ensure target creation
+                         targets[mode][step], process.returncode)
+
+            if (step == 1):                                             # Delete intermediate file
+                deleteFile(f"{fname[:-4]}.iso")
+
+        if (delete):                                                    # Delete source requested
+            deleteFile(fname)
+            if (mode == 3):
+                deleteFile(f"{fname[:-4]}.bin")
+
+# ===== EXIT SCRIPT ===============================================================================
+
+elif (mode == 9):
+    print("╠===============================================================================╗")
+    print("║                                Goodbye! :)                                    ║")
+    print("╚===============================================================================╝")
+    sys.exit(0)
+
+# ===== EXIT SCRIPT WITH ERROR ====================================================================
+
+else:
+    exitInvalidOption()
+
+# -------------------------------------------------------------------------------------------------
+
+print("╠===============================================================================╣")
+print("║                               Process complete!                               ║")
+print("╚===============================================================================╝")
+sys.exit(0)
--- a/pcsx2-qt/Settings/ControllerSettingsWindow.cpp
+++ b/pcsx2-qt/Settings/ControllerSettingsWindow.cpp
@@ -38,6 +38,7 @@ ControllerSettingsWindow::ControllerSettingsWindow()
 	connect(m_ui.buttonBox, &QDialogButtonBox::rejected, this, &ControllerSettingsWindow::close);
 	connect(m_ui.newProfile, &QPushButton::clicked, this, &ControllerSettingsWindow::onNewProfileClicked);
 	connect(m_ui.applyProfile, &QPushButton::clicked, this, &ControllerSettingsWindow::onApplyProfileClicked);
+	connect(m_ui.renameProfile, &QPushButton::clicked, this, &ControllerSettingsWindow::onRenameProfileClicked);
 	connect(m_ui.deleteProfile, &QPushButton::clicked, this, &ControllerSettingsWindow::onDeleteProfileClicked);
 	connect(m_ui.mappingSettings, &QPushButton::clicked, this, &ControllerSettingsWindow::onMappingSettingsClicked);
 	connect(m_ui.restoreDefaults, &QPushButton::clicked, this, &ControllerSettingsWindow::onRestoreDefaultsClicked);
@@ -176,6 +177,48 @@ void ControllerSettingsWindow::onApplyProfileClicked()
 	switchProfile({});
 }

+void ControllerSettingsWindow::onRenameProfileClicked()
+{
+	const QString profile_name(QInputDialog::getText(this, tr("Rename Input Profile"),
+		tr("Enter the new name for the input profile:").arg(m_profile_name)));
+
+	if (profile_name.isEmpty())
+		return;
+
+	std::string old_profile_name(m_profile_name.toStdString());
+	std::string old_profile_path(VMManager::GetInputProfilePath(m_profile_name.toStdString()));
+	std::string profile_path(VMManager::GetInputProfilePath(profile_name.toStdString()));
+	if (FileSystem::FileExists(profile_path.c_str()))
+	{
+		QMessageBox::critical(this, tr("Error"), tr("A profile with the name '%1' already exists.").arg(profile_name));
+		return;
+	}
+
+	if (!FileSystem::RenamePath(old_profile_path.c_str(), profile_path.c_str()))
+	{
+		QMessageBox::critical(this, tr("Error"), tr("Failed to rename '%1'.").arg(QString::fromStdString(old_profile_path)));
+		return;
+	}
+
+	FileSystem::FindResultsArray files;
+	FileSystem::FindFiles(EmuFolders::GameSettings.c_str(), "*", FILESYSTEM_FIND_FILES, &files);
+	for (const auto& game_settings : files)
+	{
+		std::string game_settings_path(game_settings.FileName.c_str());
+		std::unique_ptr<INISettingsInterface> update_sif(std::make_unique<INISettingsInterface>(std::move(game_settings_path)));
+		
+		update_sif->Load();
+
+		if (!old_profile_name.compare(update_sif->GetStringValue("EmuCore", "InputProfileName")))
+		{
+			update_sif->SetStringValue("EmuCore", "InputProfileName", profile_name.toUtf8());
+		}
+	}
+
+	refreshProfileList();
+	switchProfile({profile_name});
+}
+
 void ControllerSettingsWindow::onDeleteProfileClicked()
 {
 	if (QMessageBox::question(this, tr("Delete Input Profile"),
@@ -451,6 +494,7 @@ void ControllerSettingsWindow::createWidgets()
 	}

 	m_ui.applyProfile->setEnabled(isEditingProfile());
+	m_ui.renameProfile->setEnabled(isEditingProfile());
 	m_ui.deleteProfile->setEnabled(isEditingProfile());
 	m_ui.restoreDefaults->setEnabled(isEditingGlobalSettings());
 }
--- a/pcsx2-qt/Settings/ControllerSettingsWindow.h
+++ b/pcsx2-qt/Settings/ControllerSettingsWindow.h
@@ -76,6 +76,7 @@ private Q_SLOTS:
 	void onCurrentProfileChanged(int index);
 	void onNewProfileClicked();
 	void onApplyProfileClicked();
+	void onRenameProfileClicked();
 	void onDeleteProfileClicked();
 	void onMappingSettingsClicked();
 	void onRestoreDefaultsClicked();
--- a/pcsx2-qt/Settings/ControllerSettingsWindow.ui
+++ b/pcsx2-qt/Settings/ControllerSettingsWindow.ui
@@ -113,6 +113,16 @@
         </property>
        </widget>
       </item>
+       <item>
+        <widget class="QPushButton" name="renameProfile">
+         <property name="text">
+          <string>Rename Profile</string>
+         </property>
+         <property name="icon">
+          <iconset theme="pencil-line"/>
+         </property>
+        </widget>
+       </item>
       <item>
        <widget class="QPushButton" name="deleteProfile">
         <property name="text">
--- a/pcsx2-qt/Settings/GamePatchSettingsWidget.cpp
+++ b/pcsx2-qt/Settings/GamePatchSettingsWidget.cpp
@@ -16,7 +16,7 @@
 #include <algorithm>

 GamePatchDetailsWidget::GamePatchDetailsWidget(std::string name, const std::string& author,
-	const std::string& description, bool enabled, SettingsWindow* dialog, QWidget* parent)
+	const std::string& description, bool tristate, Qt::CheckState checkState, SettingsWindow* dialog, QWidget* parent)
 	: QWidget(parent)
 	, m_dialog(dialog)
 	, m_name(name)
@@ -30,7 +30,8 @@ GamePatchDetailsWidget::GamePatchDetailsWidget(std::string name, const std::stri
 			.arg(description.empty() ? tr("No description provided.") : QString::fromStdString(description)));

 	pxAssert(dialog->getSettingsInterface());
-	m_ui.enabled->setChecked(enabled);
+	m_ui.enabled->setTristate(tristate);
+	m_ui.enabled->setCheckState(checkState);
 	connect(m_ui.enabled, &QCheckBox::checkStateChanged, this, &GamePatchDetailsWidget::onEnabledStateChanged);
 }

@@ -40,9 +41,25 @@ void GamePatchDetailsWidget::onEnabledStateChanged(int state)
 {
 	SettingsInterface* si = m_dialog->getSettingsInterface();
 	if (state == Qt::Checked)
-		si->AddToStringList("Patches", "Enable", m_name.c_str());
+	{
+		si->AddToStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_ENABLE_CONFIG_KEY, m_name.c_str());
+		si->RemoveFromStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_DISABLE_CONFIG_KEY, m_name.c_str());
+	}
 	else
-		si->RemoveFromStringList("Patches", "Enable", m_name.c_str());
+	{
+		si->RemoveFromStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_ENABLE_CONFIG_KEY, m_name.c_str());
+		if (m_ui.enabled->isTristate())
+		{
+			if (state == Qt::Unchecked)
+			{
+				si->AddToStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_DISABLE_CONFIG_KEY, m_name.c_str());
+			}
+			else
+			{
+				si->RemoveFromStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_DISABLE_CONFIG_KEY, m_name.c_str());
+			}
+		}
+	}

 	si->Save();
 	g_emu_thread->reloadGameSettings();
@@ -56,6 +73,8 @@ GamePatchSettingsWidget::GamePatchSettingsWidget(SettingsWindow* dialog, QWidget
 	m_ui.scrollArea->setFrameShadow(QFrame::Sunken);

 	setUnlabeledPatchesWarningVisibility(false);
+	setGlobalWsPatchNoteVisibility(false);
+	setGlobalNiPatchNoteVisibility(false);

 	SettingsInterface* sif = m_dialog->getSettingsInterface();
 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.allCRCsCheckbox, "EmuCore", "ShowPatchesForAllCRCs", false);
@@ -88,14 +107,22 @@ void GamePatchSettingsWidget::disableAllPatches()

 void GamePatchSettingsWidget::reloadList()
 {
+	const SettingsInterface* si = m_dialog->getSettingsInterface();
 	// Patches shouldn't have any unlabelled patch groups, because they're new.
 	u32 number_of_unlabeled_patches = 0;
 	bool showAllCRCS = m_ui.allCRCsCheckbox->isChecked();
 	std::vector<Patch::PatchInfo> patches = Patch::GetPatchInfo(m_dialog->getSerial(), m_dialog->getDiscCRC(), false, showAllCRCS, &number_of_unlabeled_patches);
 	std::vector<std::string> enabled_list =
-		m_dialog->getSettingsInterface()->GetStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_ENABLE_CONFIG_KEY);
+		si->GetStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_ENABLE_CONFIG_KEY);
+	std::vector<std::string> disabled_list =
+		si->GetStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_DISABLE_CONFIG_KEY);
+
+	const bool ws_patches_enabled_globally = m_dialog->getEffectiveBoolValue("EmuCore", "EnableWideScreenPatches", false);
+	const bool ni_patches_enabled_globally = m_dialog->getEffectiveBoolValue("EmuCore", "EnableNoInterlacingPatches", false);

 	setUnlabeledPatchesWarningVisibility(number_of_unlabeled_patches > 0);
+	setGlobalWsPatchNoteVisibility(ws_patches_enabled_globally);
+	setGlobalNiPatchNoteVisibility(ni_patches_enabled_globally);
 	delete m_ui.scrollArea->takeWidget();

 	QWidget* container = new QWidget(m_ui.scrollArea);
@@ -106,7 +133,7 @@ void GamePatchSettingsWidget::reloadList()
 	{
 		bool first = true;

-		for (Patch::PatchInfo& pi : patches)
+		for (const Patch::PatchInfo& pi : patches)
 		{
 			if (!first)
 			{
@@ -120,9 +147,35 @@ void GamePatchSettingsWidget::reloadList()
 				first = false;
 			}

-			const bool enabled = (std::find(enabled_list.begin(), enabled_list.end(), pi.name) != enabled_list.end());
+			const bool is_on_enable_list = std::find(enabled_list.begin(), enabled_list.end(), pi.name) != enabled_list.end();
+			const bool is_on_disable_list = std::find(disabled_list.begin(), disabled_list.end(), pi.name) != disabled_list.end();
+			const bool globally_toggleable_option = Patch::IsGloballyToggleablePatch(pi);
+
+			Qt::CheckState check_state;
+			if (!globally_toggleable_option)
+			{
+				// Normal patches
+				check_state = is_on_enable_list && !is_on_disable_list ? Qt::CheckState::Checked : Qt::CheckState::Unchecked;
+			}
+			else
+			{
+				// WS/NI patches
+				if (is_on_disable_list)
+				{
+					check_state = Qt::CheckState::Unchecked;
+				}
+				else if (is_on_enable_list)
+				{
+					check_state = Qt::CheckState::Checked;
+				}
+				else
+				{
+					check_state = Qt::CheckState::PartiallyChecked;
+				}
+			}
+
 			GamePatchDetailsWidget* it =
-				new GamePatchDetailsWidget(std::move(pi.name), pi.author, pi.description, enabled, m_dialog, container);
+				new GamePatchDetailsWidget(std::move(pi.name), pi.author, pi.description, globally_toggleable_option, check_state, m_dialog, container);
 			layout->addWidget(it);
 		}
 	}
@@ -141,3 +194,13 @@ void GamePatchSettingsWidget::setUnlabeledPatchesWarningVisibility(bool visible)
 {
 	m_ui.unlabeledPatchWarning->setVisible(visible);
 }
+
+void GamePatchSettingsWidget::setGlobalWsPatchNoteVisibility(bool visible)
+{
+	m_ui.globalWsPatchState->setVisible(visible);
+}
+
+void GamePatchSettingsWidget::setGlobalNiPatchNoteVisibility(bool visible)
+{
+	m_ui.globalNiPatchState->setVisible(visible);
+}
--- a/pcsx2-qt/Settings/GamePatchSettingsWidget.h
+++ b/pcsx2-qt/Settings/GamePatchSettingsWidget.h
@@ -22,7 +22,7 @@ class GamePatchDetailsWidget : public QWidget
 	Q_OBJECT

 public:
-	GamePatchDetailsWidget(std::string name, const std::string& author, const std::string& description, bool enabled,
+	GamePatchDetailsWidget(std::string name, const std::string& author, const std::string& description, bool tristate, Qt::CheckState checkState,
 		SettingsWindow* dialog, QWidget* parent);
 	~GamePatchDetailsWidget();

@@ -50,6 +50,8 @@ private Q_SLOTS:
 private:
 	void reloadList();
 	void setUnlabeledPatchesWarningVisibility(bool visible);
+	void setGlobalWsPatchNoteVisibility(bool visible);
+	void setGlobalNiPatchNoteVisibility(bool visible);

 	Ui::GamePatchSettingsWidget m_ui;
 	SettingsWindow* m_dialog;
--- a/pcsx2-qt/Settings/GamePatchSettingsWidget.ui
+++ b/pcsx2-qt/Settings/GamePatchSettingsWidget.ui
@@ -38,6 +38,29 @@
     <property name="text">
      <string>Any patches bundled with PCSX2 for this game will be disabled since you have unlabeled patches loaded.</string>
     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLabel" name="globalWsPatchState">
+     <property name="text">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Widescreen patches are currently &lt;span style=&quot; font-weight:600;&quot;&gt;ENABLED&lt;/span&gt; globally.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLabel" name="globalNiPatchState">
+     <property name="text">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;No-Interlacing patches are currently &lt;span style=&quot; font-weight:600;&quot;&gt;ENABLED&lt;/span&gt; globally.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
    </widget>
   </item>
   <item>
--- a/pcsx2-qt/Settings/GraphicsSettingsWidget.cpp
+++ b/pcsx2-qt/Settings/GraphicsSettingsWidget.cpp
@@ -8,6 +8,7 @@
 #include <QtWidgets/QMessageBox>

 #include "pcsx2/Host.h"
+#include "pcsx2/Patch.h"
 #include "pcsx2/GS/GS.h"
 #include "pcsx2/GS/GSCapture.h"
 #include "pcsx2/GS/GSUtil.h"
@@ -88,6 +89,8 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
 	SettingWidgetBinder::BindWidgetToIntSetting(sif, m_ui.interlacing, "EmuCore/GS", "deinterlace_mode", DEFAULT_INTERLACE_MODE);
 	SettingWidgetBinder::BindWidgetToIntSetting(
 		sif, m_ui.bilinearFiltering, "EmuCore/GS", "linear_present_mode", static_cast<int>(GSPostBilinearMode::BilinearSmooth));
+	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.widescreenPatches, "EmuCore", "EnableWideScreenPatches", false);
+	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.noInterlacingPatches, "EmuCore", "EnableNoInterlacingPatches", false);
 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.integerScaling, "EmuCore/GS", "IntegerScaling", false);
 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.PCRTCOffsets, "EmuCore/GS", "pcrtc_offsets", false);
 	SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.PCRTCOverscan, "EmuCore/GS", "pcrtc_overscan", false);
@@ -319,22 +322,61 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
 	}
 #endif

-	// Prompt user to get rid of widescreen/no-interlace config from the ini if the user has enabled them before.
-	if ((m_dialog->getBoolValue("EmuCore", "EnableWideScreenPatches", false) == true ||
-		m_dialog->getBoolValue("EmuCore", "EnableWideScreenPatches", false) == true) &&
-		!m_dialog->containsSettingValue("UI", "UserHasDeniedWSPatchWarning"))
+	// Get rid of widescreen/no-interlace checkboxes from per-game settings, and migrate them to Patches if necessary.
+	if (m_dialog->isPerGameSettings())
 	{
-		if (QMessageBox::question(QtUtils::GetRootWidget(this), tr("Remove Unsupported Settings"),
-				tr("You previously had the <strong>Enable Widescreen Patches</strong> or <strong>Enable No-Interlacing Patches</strong> options enabled.<br><br>"
-				   "We no longer provide these options, instead <strong>you should go to the \"Patches\" section on the per-game settings, and explicitly enable the patches that you want.</strong><br><br>"
-				   "Do you want to remove these options from your configuration now?"),
-				QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
+		SettingsInterface* si = m_dialog->getSettingsInterface();
+		bool needs_save = false;
+
+		if (si->ContainsValue("EmuCore", "EnableWideScreenPatches"))
 		{
-			m_dialog->removeSettingValue("EmuCore", "EnableWideScreenPatches");
-			m_dialog->removeSettingValue("EmuCore", "EnableNoInterlacingPatches");
+			const bool ws_enabled = si->GetBoolValue("EmuCore", "EnableWideScreenPatches");
+			si->DeleteValue("EmuCore", "EnableWideScreenPatches");
+
+			const char* WS_PATCH_NAME = "Widescreen 16:9";
+			if (ws_enabled)
+			{
+				si->AddToStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_ENABLE_CONFIG_KEY, WS_PATCH_NAME);
+				si->RemoveFromStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_DISABLE_CONFIG_KEY, WS_PATCH_NAME);
+			}
+			else
+			{
+				si->AddToStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_DISABLE_CONFIG_KEY, WS_PATCH_NAME);
+				si->RemoveFromStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_ENABLE_CONFIG_KEY, WS_PATCH_NAME);
+			}
+			needs_save = true;
 		}
-		else
-			m_dialog->setBoolSettingValue("UI", "UserHasDeniedWSPatchWarning", true);
+
+		if (si->ContainsValue("EmuCore", "EnableNoInterlacingPatches"))
+		{
+			const bool ni_enabled = si->GetBoolValue("EmuCore", "EnableNoInterlacingPatches");
+			si->DeleteValue("EmuCore", "EnableNoInterlacingPatches");
+
+			const char* NI_PATCH_NAME = "No-Interlacing";
+			if (ni_enabled)
+			{
+				si->AddToStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_ENABLE_CONFIG_KEY, NI_PATCH_NAME);
+				si->RemoveFromStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_DISABLE_CONFIG_KEY, NI_PATCH_NAME);
+			}
+			else
+			{
+				si->AddToStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_DISABLE_CONFIG_KEY, NI_PATCH_NAME);
+				si->RemoveFromStringList(Patch::PATCHES_CONFIG_SECTION, Patch::PATCH_ENABLE_CONFIG_KEY, NI_PATCH_NAME);
+			}
+			needs_save = true;
+		}
+
+		if (needs_save)
+		{
+			m_dialog->saveAndReloadGameSettings();
+		}
+
+		m_ui.displayGridLayout->removeWidget(m_ui.widescreenPatches);
+		m_ui.displayGridLayout->removeWidget(m_ui.noInterlacingPatches);
+		m_ui.widescreenPatches->deleteLater();
+		m_ui.noInterlacingPatches->deleteLater();
+		m_ui.widescreenPatches = nullptr;
+		m_ui.noInterlacingPatches = nullptr;
 	}

 	// Hide advanced options by default.
@@ -427,6 +469,12 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*

 	// Display tab
 	{
+		dialog->registerWidgetHelp(m_ui.widescreenPatches, tr("Enable Widescreen Patches"), tr("Unchecked"),
+			tr("Automatically loads and applies widescreen patches on game start. Can cause issues."));
+
+		dialog->registerWidgetHelp(m_ui.noInterlacingPatches, tr("Enable No-Interlacing Patches"), tr("Unchecked"),
+			tr("Automatically loads and applies no-interlacing patches on game start. Can cause issues."));
+
 		dialog->registerWidgetHelp(m_ui.DisableInterlaceOffset, tr("Disable Interlace Offset"), tr("Unchecked"),
 			tr("Disables interlacing offset which may reduce blurring in some situations."));

--- a/pcsx2-qt/Settings/GraphicsSettingsWidget.ui
+++ b/pcsx2-qt/Settings/GraphicsSettingsWidget.ui
@@ -404,28 +404,28 @@
       </item>
       <item row="8" column="0" colspan="2">
        <layout class="QGridLayout" name="displayGridLayout">
-         <item row="0" column="1">
+         <item row="1" column="1">
          <widget class="QCheckBox" name="integerScaling">
           <property name="text">
            <string>Integer Scaling</string>
           </property>
          </widget>
         </item>
-         <item row="2" column="0">
-          <widget class="QCheckBox" name="PCRTCOverscan">
+         <item row="0" column="0">
+          <widget class="QCheckBox" name="widescreenPatches">
           <property name="text">
-            <string>Show Overscan</string>
+            <string>Apply Widescreen Patches</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="1">
+          <widget class="QCheckBox" name="noInterlacingPatches">
+           <property name="text">
+            <string>Apply No-Interlacing Patches</string>
           </property>
          </widget>
         </item>
         <item row="1" column="0">
-          <widget class="QCheckBox" name="PCRTCOffsets">
-           <property name="text">
-            <string>Screen Offsets</string>
-           </property>
-          </widget>
-         </item>
-         <item row="0" column="0">
          <widget class="QCheckBox" name="PCRTCAntiBlur">
           <property name="text">
            <string>Anti-Blur</string>
@@ -435,13 +435,27 @@
           </property>
          </widget>
         </item>
-         <item row="1" column="1">
+         <item row="2" column="1">
          <widget class="QCheckBox" name="DisableInterlaceOffset">
           <property name="text">
            <string>Disable Interlace Offset</string>
           </property>
          </widget>
         </item>
+         <item row="2" column="0">
+          <widget class="QCheckBox" name="PCRTCOffsets">
+           <property name="text">
+            <string>Screen Offsets</string>
+           </property>
+          </widget>
+         </item>
+         <item row="3" column="0">
+          <widget class="QCheckBox" name="PCRTCOverscan">
+           <property name="text">
+            <string>Show Overscan</string>
+           </property>
+          </widget>
+         </item>
        </layout>
       </item>
      </layout>
@@ -2111,7 +2125,7 @@
           </widget>
          </item>
          <item row="10" column="0" colspan="2">
-           <layout class="QGridLayout" name="advancedOptionsGrid">
+           <layout class="QGridLayout" name="gridLayout_9">
            <item row="2" column="0">
             <widget class="QCheckBox" name="disableMailboxPresentation">
              <property name="text">
--- a/pcsx2-qt/Translations/pcsx2-qt_af-ZA.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_af-ZA.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_ar-SA.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_ar-SA.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_bg-BG.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_bg-BG.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_ca-ES.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_ca-ES.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_cs-CZ.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_cs-CZ.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_da-DK.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_da-DK.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_de-DE.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_de-DE.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_el-GR.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_el-GR.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_en.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_en.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_es-419.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_es-419.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_es-ES.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_es-ES.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_fa-IR.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_fa-IR.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_fi-FI.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_fi-FI.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_fr-FR.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_fr-FR.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_gn-PY.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_gn-PY.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_he-IL.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_he-IL.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_hi-IN.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_hi-IN.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_hr-HR.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_hr-HR.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_hu-HU.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_hu-HU.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_id-ID.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_id-ID.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_it-IT.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_it-IT.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_ja-JP.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_ja-JP.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_ka-GE.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_ka-GE.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_ko-KR.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_ko-KR.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_lt-LT.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_lt-LT.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_lv-LV.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_lv-LV.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_nl-NL.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_nl-NL.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_no-NO.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_no-NO.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_pl-PL.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_pl-PL.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_pt-BR.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_pt-BR.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_pt-PT.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_pt-PT.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_qu-PE.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_qu-PE.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_ro-RO.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_ro-RO.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_ru-RU.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_ru-RU.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_sr-SP.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_sr-SP.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_sv-SE.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_sv-SE.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_tr-TR.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_tr-TR.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_uk-UA.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_uk-UA.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_vi-VN.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_vi-VN.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_zh-CN.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_zh-CN.ts
--- a/pcsx2-qt/Translations/pcsx2-qt_zh-TW.ts
+++ b/pcsx2-qt/Translations/pcsx2-qt_zh-TW.ts
--- a/pcsx2/Achievements.cpp
+++ b/pcsx2/Achievements.cpp
@@ -300,7 +300,7 @@ std::string Achievements::GetGameHash(const std::string& elf_path)
 	Error error;
 	if (!cdvdLoadElf(&elfo, elf_path, false, &error))
 	{
-		Console.Error(fmt::format("(Achievements) Failed to read ELF '{}' on disc: {}", elf_path, error.GetDescription()));
+		Console.Error(fmt::format("Achievements: Failed to read ELF '{}' on disc: {}", elf_path, error.GetDescription()));
 		return {};
 	}

@@ -441,7 +441,7 @@ bool Achievements::Initialize()
 	const std::string api_token = Host::GetBaseStringSettingValue("Achievements", "Token");
 	if (!username.empty() && !api_token.empty())
 	{
-		Console.WriteLn("(Achievements) Attempting login with user '%s'...", username.c_str());
+		Console.WriteLn("Achievements: Attempting login with user '%s'...", username.c_str());
 		s_login_request =
 			rc_client_begin_login_with_token(s_client, username.c_str(), api_token.c_str(), ClientLoginWithTokenCallback, nullptr);
 	}
@@ -608,7 +608,7 @@ void Achievements::EnsureCacheDirectoriesExist()

 void Achievements::ClientMessageCallback(const char* message, const rc_client_t* client)
 {
-	Console.WriteLn("(Achievements) %s", message);
+	Console.WriteLn("Achievements: %s", message);
 }

 uint32_t Achievements::ClientReadMemory(uint32_t address, uint8_t* buffer, uint32_t num_bytes, rc_client_t* client)
@@ -865,7 +865,7 @@ void Achievements::IdentifyGame(u32 disc_crc, u32 crc)
 	// bail out if we're not logged in, just save the hash
 	if (!IsLoggedInOrLoggingIn())
 	{
-		Console.WriteLn(Color_StrongYellow, "(Achievements) Skipping load game because we're not logged in.");
+		Console.WriteLn(Color_StrongYellow, "Achievements: Skipping load game because we're not logged in.");
 		DisableHardcoreMode();
 		return;
 	}
@@ -908,7 +908,7 @@ void Achievements::ClientLoadGameCallback(int result, const char* error_message,
 	if (result == RC_NO_GAME_LOADED)
 	{
 		// Unknown game.
-		Console.WriteLn(Color_StrongYellow, "(Achievements) Unknown game '%s', disabling achievements.", s_game_hash.c_str());
+		Console.WriteLn(Color_StrongYellow, "Achievements: Unknown game '%s', disabling achievements.", s_game_hash.c_str());
 		DisableHardcoreMode();
 		return;
 	}
@@ -1083,7 +1083,7 @@ void Achievements::HandleUnlockEvent(const rc_client_event_t* event)
 	const rc_client_achievement_t* cheevo = event->achievement;
 	pxAssert(cheevo);

-	Console.WriteLn("(Achievements) Achievement %s (%u) for game %u unlocked", cheevo->title, cheevo->id, s_game_id);
+	Console.WriteLn("Achievements: Achievement %s (%u) for game %u unlocked", cheevo->title, cheevo->id, s_game_id);
 	UpdateGameSummary();

 	if (EmuConfig.Achievements.Notifications)
@@ -1109,7 +1109,7 @@ void Achievements::HandleUnlockEvent(const rc_client_event_t* event)

 void Achievements::HandleGameCompleteEvent(const rc_client_event_t* event)
 {
-	Console.WriteLn("(Achievements) Game %u complete", s_game_id);
+	Console.WriteLn("Achievements: Game %u complete", s_game_id);
 	UpdateGameSummary();

 	if (EmuConfig.Achievements.Notifications)
@@ -1133,7 +1133,7 @@ void Achievements::HandleGameCompleteEvent(const rc_client_event_t* event)

 void Achievements::HandleLeaderboardStartedEvent(const rc_client_event_t* event)
 {
-	DevCon.WriteLn("(Achievements) Leaderboard %u (%s) started", event->leaderboard->id, event->leaderboard->title);
+	DevCon.WriteLn("Achievements: Leaderboard %u (%s) started", event->leaderboard->id, event->leaderboard->title);

 	if (EmuConfig.Achievements.LeaderboardNotifications)
 	{
@@ -1152,7 +1152,7 @@ void Achievements::HandleLeaderboardStartedEvent(const rc_client_event_t* event)

 void Achievements::HandleLeaderboardFailedEvent(const rc_client_event_t* event)
 {
-	DevCon.WriteLn("(Achievements) Leaderboard %u (%s) failed", event->leaderboard->id, event->leaderboard->title);
+	DevCon.WriteLn("Achievements: Leaderboard %u (%s) failed", event->leaderboard->id, event->leaderboard->title);

 	if (EmuConfig.Achievements.LeaderboardNotifications)
 	{
@@ -1171,7 +1171,7 @@ void Achievements::HandleLeaderboardFailedEvent(const rc_client_event_t* event)

 void Achievements::HandleLeaderboardSubmittedEvent(const rc_client_event_t* event)
 {
-	Console.WriteLn("(Achievements) Leaderboard %u (%s) submitted", event->leaderboard->id, event->leaderboard->title);
+	Console.WriteLn("Achievements: Leaderboard %u (%s) submitted", event->leaderboard->id, event->leaderboard->title);

 	if (EmuConfig.Achievements.LeaderboardNotifications)
 	{
@@ -1203,7 +1203,7 @@ void Achievements::HandleLeaderboardSubmittedEvent(const rc_client_event_t* even

 void Achievements::HandleLeaderboardScoreboardEvent(const rc_client_event_t* event)
 {
-	Console.WriteLn("(Achievements) Leaderboard %u scoreboard rank %u of %u", event->leaderboard_scoreboard->leaderboard_id,
+	Console.WriteLn("Achievements: Leaderboard %u scoreboard rank %u of %u", event->leaderboard_scoreboard->leaderboard_id,
 		event->leaderboard_scoreboard->new_rank, event->leaderboard_scoreboard->num_entries);

 	if (EmuConfig.Achievements.LeaderboardNotifications)
@@ -1234,7 +1234,7 @@ void Achievements::HandleLeaderboardScoreboardEvent(const rc_client_event_t* eve
 void Achievements::HandleLeaderboardTrackerShowEvent(const rc_client_event_t* event)
 {
 	DevCon.WriteLn(
-		"(Achievements) Showing leaderboard tracker: %u: %s", event->leaderboard_tracker->id, event->leaderboard_tracker->display);
+		"Achievements: Showing leaderboard tracker: %u: %s", event->leaderboard_tracker->id, event->leaderboard_tracker->display);

 	LeaderboardTrackerIndicator indicator;
 	indicator.tracker_id = event->leaderboard_tracker->id;
@@ -1251,7 +1251,7 @@ void Achievements::HandleLeaderboardTrackerHideEvent(const rc_client_event_t* ev
 	if (it == s_active_leaderboard_trackers.end())
 		return;

-	DevCon.WriteLn("(Achievements) Hiding leaderboard tracker: %u", id);
+	DevCon.WriteLn("Achievements: Hiding leaderboard tracker: %u", id);
 	it->active = false;
 	it->show_hide_time.Reset();
 }
@@ -1265,7 +1265,7 @@ void Achievements::HandleLeaderboardTrackerUpdateEvent(const rc_client_event_t*
 		return;

 	DevCon.WriteLn(
-		"(Achievements) Updating leaderboard tracker: %u: %s", event->leaderboard_tracker->id, event->leaderboard_tracker->display);
+		"Achievements: Updating leaderboard tracker: %u: %s", event->leaderboard_tracker->id, event->leaderboard_tracker->display);

 	it->text = event->leaderboard_tracker->display;
 	it->active = true;
@@ -1288,7 +1288,7 @@ void Achievements::HandleAchievementChallengeIndicatorShowEvent(const rc_client_
 	indicator.active = true;
 	s_active_challenge_indicators.push_back(std::move(indicator));

-	DevCon.WriteLn("(Achievements) Show challenge indicator for %u (%s)", event->achievement->id, event->achievement->title);
+	DevCon.WriteLn("Achievements: Show challenge indicator for %u (%s)", event->achievement->id, event->achievement->title);
 }

 void Achievements::HandleAchievementChallengeIndicatorHideEvent(const rc_client_event_t* event)
@@ -1298,14 +1298,14 @@ void Achievements::HandleAchievementChallengeIndicatorHideEvent(const rc_client_
 	if (it == s_active_challenge_indicators.end())
 		return;

-	DevCon.WriteLn("(Achievements) Hide challenge indicator for %u (%s)", event->achievement->id, event->achievement->title);
+	DevCon.WriteLn("Achievements: Hide challenge indicator for %u (%s)", event->achievement->id, event->achievement->title);
 	it->show_hide_time.Reset();
 	it->active = false;
 }

 void Achievements::HandleAchievementProgressIndicatorShowEvent(const rc_client_event_t* event)
 {
-	DevCon.WriteLn("(Achievements) Showing progress indicator: %u (%s): %s", event->achievement->id, event->achievement->title,
+	DevCon.WriteLn("Achievements: Showing progress indicator: %u (%s): %s", event->achievement->id, event->achievement->title,
 		event->achievement->measured_progress);

 	if (!s_active_progress_indicator.has_value())
@@ -1323,14 +1323,14 @@ void Achievements::HandleAchievementProgressIndicatorHideEvent(const rc_client_e
 	if (!s_active_progress_indicator.has_value())
 		return;

-	DevCon.WriteLn("(Achievements) Hiding progress indicator");
+	DevCon.WriteLn("Achievements: Hiding progress indicator");
 	s_active_progress_indicator->show_hide_time.Reset();
 	s_active_progress_indicator->active = false;
 }

 void Achievements::HandleAchievementProgressIndicatorUpdateEvent(const rc_client_event_t* event)
 {
-	DevCon.WriteLn("(Achievements) Updating progress indicator: %u (%s): %s", event->achievement->id, event->achievement->title,
+	DevCon.WriteLn("Achievements: Updating progress indicator: %u (%s): %s", event->achievement->id, event->achievement->title,
 		event->achievement->measured_progress);
 	s_active_progress_indicator->achievement = event->achievement;
 	s_active_progress_indicator->active = true;
@@ -1341,13 +1341,13 @@ void Achievements::HandleServerErrorEvent(const rc_client_event_t* event)
 	std::string message = fmt::format(TRANSLATE_FS("Achievements", "Server error in {0}:\n{1}"),
 		event->server_error->api ? event->server_error->api : "UNKNOWN",
 		event->server_error->error_message ? event->server_error->error_message : "UNKNOWN");
-	Console.Error("(Achievements) %s", message.c_str());
+	Console.Error("Achievements: %s", message.c_str());
 	Host::AddOSDMessage(std::move(message), Host::OSD_ERROR_DURATION);
 }

 void Achievements::HandleServerDisconnectedEvent(const rc_client_event_t* event)
 {
-	Console.Warning("(Achievements) Server disconnected.");
+	Console.Warning("Achievements: Server disconnected.");

 	MTGS::RunOnGSThread([]() {
 		if (ImGuiManager::InitializeFullscreenUI())
@@ -1360,7 +1360,7 @@ void Achievements::HandleServerDisconnectedEvent(const rc_client_event_t* event)

 void Achievements::HandleServerReconnectedEvent(const rc_client_event_t* event)
 {
-	Console.Warning("(Achievements) Server reconnected.");
+	Console.Warning("Achievements: Server reconnected.");

 	MTGS::RunOnGSThread([]() {
 		if (ImGuiManager::InitializeFullscreenUI())
@@ -1385,7 +1385,7 @@ void Achievements::ResetClient()
 	if (!IsActive())
 		return;

-	Console.WriteLn("(Achievements) Reset client");
+	Console.WriteLn("Achievements: Reset client");
 	rc_client_reset(s_client);
 }

@@ -1811,11 +1811,11 @@ void Achievements::Logout()
 		if (HasActiveGame())
 			ClearGameInfo();

-		Console.WriteLn("(Achievements) Logging out...");
+		Console.WriteLn("Achievements: Logging out...");
 		rc_client_logout(s_client);
 	}

-	Console.WriteLn("(Achievements) Clearing credentials...");
+	Console.WriteLn("Achievements: Clearing credentials...");
 	Host::RemoveBaseSettingValue("Achievements", "Username");
 	Host::RemoveBaseSettingValue("Achievements", "Token");
 	Host::RemoveBaseSettingValue("Achievements", "LoginTimestamp");
@@ -1961,7 +1961,7 @@ void Achievements::DrawGameOverlays()

 			if (!indicator.active && opacity <= 0.01f)
 			{
-				DevCon.WriteLn("(Achievements) Remove challenge indicator");
+				DevCon.WriteLn("Achievements: Remove challenge indicator");
 				it = s_active_challenge_indicators.erase(it);
 			}
 			else
@@ -2004,7 +2004,7 @@ void Achievements::DrawGameOverlays()

 		if (!indicator.active && opacity <= 0.01f)
 		{
-			DevCon.WriteLn("(Achievements) Remove progress indicator");
+			DevCon.WriteLn("Achievements: Remove progress indicator");
 			s_active_progress_indicator.reset();
 		}

@@ -2046,7 +2046,7 @@ void Achievements::DrawGameOverlays()

 			if (!indicator.active && opacity <= 0.01f)
 			{
-				DevCon.WriteLn("(Achievements) Remove tracker indicator");
+				DevCon.WriteLn("Achievements: Remove tracker indicator");
 				it = s_active_leaderboard_trackers.erase(it);
 			}
 			else
@@ -2151,7 +2151,7 @@ bool Achievements::PrepareAchievementsWindow()
 		RC_CLIENT_ACHIEVEMENT_LIST_GROUPING_PROGRESS /*RC_CLIENT_ACHIEVEMENT_LIST_GROUPING_LOCK_STATE*/);
 	if (!s_achievement_list)
 	{
-		Console.Error("(Achievements) rc_client_create_achievement_list() returned null");
+		Console.Error("Achievements: rc_client_create_achievement_list() returned null");
 		return false;
 	}

@@ -2489,7 +2489,7 @@ bool Achievements::PrepareLeaderboardsWindow()
 	s_leaderboard_list = rc_client_create_leaderboard_list(client, RC_CLIENT_LEADERBOARD_LIST_GROUPING_NONE);
 	if (!s_leaderboard_list)
 	{
-		Console.Error("(Achievements) rc_client_create_leaderboard_list() returned null");
+		Console.Error("Achievements: rc_client_create_leaderboard_list() returned null");
 		return false;
 	}

@@ -2920,7 +2920,7 @@ void Achievements::DrawLeaderboardListEntry(const rc_client_leaderboard_t* lboar

 void Achievements::OpenLeaderboard(const rc_client_leaderboard_t* lboard)
 {
-	Console.WriteLn("(Achievements) Opening leaderboard '%s' (%u)", lboard->title, lboard->id);
+	Console.WriteLn("Achievements: Opening leaderboard '%s' (%u)", lboard->title, lboard->id);

 	CloseLeaderboard();

@@ -2974,7 +2974,7 @@ void Achievements::FetchNextLeaderboardEntries()
 	for (rc_client_leaderboard_entry_list_t* list : s_leaderboard_entry_lists)
 		start += list->num_entries;

-	Console.WriteLn("(Achievements) Fetching entries %u to %u", start, start + LEADERBOARD_ALL_FETCH_SIZE);
+	Console.WriteLn("Achievements: Fetching entries %u to %u", start, start + LEADERBOARD_ALL_FETCH_SIZE);

 	if (s_leaderboard_fetch_handle)
 		rc_client_abort_async(s_client, s_leaderboard_fetch_handle);
--- a/pcsx2/Config.h
+++ b/pcsx2/Config.h
@@ -1268,6 +1268,8 @@ struct Pcsx2Config
 		EnablePatches : 1, // enables patch detection and application
 		EnableCheats : 1, // enables cheat detection and application
 		EnablePINE : 1, // enables inter-process communication
+		EnableWideScreenPatches : 1,
+		EnableNoInterlacingPatches : 1,
 		EnableFastBoot : 1,
 		EnableFastBootFastForward : 1,
 		EnableThreadPinning : 1,
--- a/pcsx2/Counters.cpp
+++ b/pcsx2/Counters.cpp
@@ -403,7 +403,7 @@ void UpdateVSyncRate(bool force)
 		vSyncInfoCalc(&vSyncInfo, frames_per_second, total_scanlines);

 		if (video_mode_initialized)
-			Console.WriteLn(Color_Green, "(UpdateVSyncRate) Mode Changed to %s.", ReportVideoMode());
+			Console.WriteLn(Color_Green, "UpdateVSyncRate: Mode Changed to %s.", ReportVideoMode());

 		if (custom && video_mode_initialized)
 			Console.WriteLn(Color_StrongGreen, "  ... with user configured refresh rate: %.02f Hz", vertical_frequency);
--- a/pcsx2/GS/GSXXH.cpp
+++ b/pcsx2/GS/GSXXH.cpp
@@ -22,7 +22,7 @@ MULTI_ISA_UNSHARED_IMPL;
 u64 __noinline CURRENT_ISA::GSXXH3_64_Long(const void* data, size_t len)
 {
 	// XXH marks its function that calls this noinline, and it would be silly to stack noinline functions, so call the internal function directly
-	return XXH3_hashLong_64b_internal(data, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate_512, XXH3_scrambleAcc);
+	return XXH3_hashLong_64b_internal(data, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate, XXH3_scrambleAcc);
 }

 u32 CURRENT_ISA::GSXXH3_64_Update(void* state, const void* data, size_t len)
--- a/pcsx2/GS/Renderers/DX11/GSDevice11.cpp
+++ b/pcsx2/GS/Renderers/DX11/GSDevice11.cpp
@@ -112,7 +112,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 	{
 		Host::ReportErrorAsync("GS",
 			fmt::format(
-				TRANSLATE_FS("GS", "Failed to create D3D device: 0x{:08X}. A GPU which supports Direct3D Feature Level 10.0 is required."),
+				TRANSLATE_FS("GS", "Failed to create D3D11 device: 0x{:08X}. A GPU which supports Direct3D Feature Level 10.0 is required."),
 				hr));
 		return false;
 	}
@@ -149,10 +149,10 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 	if (m_dev.try_query_to(&dxgi_device) && SUCCEEDED(dxgi_device->GetParent(IID_PPV_ARGS(dxgi_adapter.put()))))
 	{
 		m_name = D3D::GetAdapterName(dxgi_adapter.get());
-		Console.WriteLn(fmt::format("D3D Adapter: {}", m_name));
+		Console.WriteLn(fmt::format("D3D11: Adapter: {}", m_name));
 	}
 	else
-		Console.Error("Failed to obtain D3D adapter name.");
+		Console.Error("D3D11: Failed to obtain adapter name.");

 	BOOL allow_tearing_supported = false;
 	hr = m_dxgi_factory->CheckFeatureSupport(
@@ -172,7 +172,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 		m_annotation = m_ctx.try_query<ID3DUserDefinedAnnotation>();

 	if (!m_shader_cache.Open(m_feature_level, GSConfig.UseDebugDevice))
-		Console.Warning("Shader cache failed to open.");
+		Console.Warning("D3D11: Shader cache failed to open.");

 	{
 		// HACK: check AMD
@@ -341,7 +341,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 	bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
 	if (FAILED(m_dev->CreateBuffer(&bd, nullptr, m_vb.put())))
 	{
-		Console.Error("Failed to create vertex buffer.");
+		Console.Error("D3D11: Failed to create vertex buffer.");
 		return false;
 	}

@@ -349,7 +349,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 	bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
 	if (FAILED(m_dev->CreateBuffer(&bd, nullptr, m_ib.put())))
 	{
-		Console.Error("Failed to create index buffer.");
+		Console.Error("D3D11: Failed to create index buffer.");
 		return false;
 	}
 	IASetIndexBuffer(m_ib.get());
@@ -363,7 +363,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)

 		if (FAILED(m_dev->CreateBuffer(&bd, nullptr, m_expand_vb.put())))
 		{
-			Console.Error("Failed to create expand vertex buffer.");
+			Console.Error("D3D11: Failed to create expand vertex buffer.");
 			return false;
 		}

@@ -371,7 +371,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 			D3D11_SRV_DIMENSION_BUFFER, DXGI_FORMAT_UNKNOWN, 0, VERTEX_BUFFER_SIZE / sizeof(GSVertex));
 		if (FAILED(m_dev->CreateShaderResourceView(m_expand_vb.get(), &vb_srv_desc, m_expand_vb_srv.put())))
 		{
-			Console.Error("Failed to create expand vertex buffer SRV.");
+			Console.Error("D3D11: Failed to create expand vertex buffer SRV.");
 			return false;
 		}

@@ -388,7 +388,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 		const D3D11_SUBRESOURCE_DATA srd = {expand_data.get()};
 		if (FAILED(m_dev->CreateBuffer(&bd, &srd, m_expand_ib.put())))
 		{
-			Console.Error("Failed to create expand index buffer.");
+			Console.Error("D3D11: Failed to create expand index buffer.");
 			return false;
 		}
 	}
@@ -440,7 +440,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)

 	if (FAILED(m_dev->CreateBuffer(&bd, nullptr, m_vs_cb.put())))
 	{
-		Console.Error("Failed to create vertex shader constant buffer.");
+		Console.Error("D3D11: Failed to create vertex shader constant buffer.");
 		return false;
 	}

@@ -452,7 +452,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)

 	if (FAILED(m_dev->CreateBuffer(&bd, nullptr, m_ps_cb.put())))
 	{
-		Console.Error("Failed to create pixel shader constant buffer.");
+		Console.Error("D3D11: Failed to create pixel shader constant buffer.");
 		return false;
 	}

@@ -511,7 +511,7 @@ bool GSDevice11::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 	if (m_feature_level < D3D_FEATURE_LEVEL_11_0)
 	{
 		Host::AddIconOSDMessage("d3d11_feature_level_warning", ICON_FA_EXCLAMATION_TRIANGLE,
-			TRANSLATE_SV("GS", "The Direct3D renderer is running at feature level 10.0. This is an UNSUPPORTED configuration.\n"
+			TRANSLATE_SV("GS", "The Direct3D11 renderer is running at feature level 10.0. This is an UNSUPPORTED configuration.\n"
 							   "Do not request support, please upgrade your hardware/drivers first."),
 			Host::OSD_WARNING_DURATION);
 	}
@@ -594,7 +594,7 @@ void GSDevice11::SetFeatures(IDXGIAdapter1* adapter)
 		if (SUCCEEDED(m_dev->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS2, &options, sizeof(options))) &&
 			!options.TypedUAVLoadAdditionalFormats)
 		{
-			Console.Warning("Disabling VS expand due to potentially buggy NVIDIA driver.");
+			Console.Warning("D3D11: Disabling VS expand due to potentially buggy NVIDIA driver.");
 			m_features.vs_expand = false;
 		}
 	}
@@ -616,7 +616,7 @@ void GSDevice11::SetVSyncMode(GSVSyncMode mode, bool allow_present_throttle)
 	// Using mailbox-style no-allow-tearing causes tearing in exclusive fullscreen.
 	if (mode == GSVSyncMode::Mailbox && m_is_exclusive_fullscreen)
 	{
-		WARNING_LOG("Using FIFO instead of Mailbox vsync due to exclusive fullscreen.");
+		WARNING_LOG("D3D11: Using FIFO instead of Mailbox vsync due to exclusive fullscreen.");
 		mode = GSVSyncMode::FIFO;
 	}

@@ -632,7 +632,7 @@ void GSDevice11::SetVSyncMode(GSVSyncMode mode, bool allow_present_throttle)
 	{
 		DestroySwapChain();
 		if (!CreateSwapChain())
-			pxFailRel("Failed to recreate swap chain after vsync change.");
+			pxFailRel("D3D11: Failed to recreate swap chain after vsync change.");
 	}
 }

@@ -669,7 +669,7 @@ bool GSDevice11::CreateSwapChain()
 		// Using mailbox-style no-allow-tearing causes tearing in exclusive fullscreen.
 		if (m_vsync_mode == GSVSyncMode::Mailbox && m_is_exclusive_fullscreen)
 		{
-			WARNING_LOG("Using FIFO instead of Mailbox vsync due to exclusive fullscreen.");
+			WARNING_LOG("D3D11: Using FIFO instead of Mailbox vsync due to exclusive fullscreen.");
 			m_vsync_mode = GSVSyncMode::FIFO;
 		}
 	}
@@ -709,12 +709,12 @@ bool GSDevice11::CreateSwapChain()
 		fs_desc.Scaling = fullscreen_mode.Scaling;
 		fs_desc.Windowed = FALSE;

-		Console.WriteLn("Creating a %dx%d exclusive fullscreen swap chain", fs_sd_desc.Width, fs_sd_desc.Height);
+		Console.WriteLn("D3D11: Creating a %dx%d exclusive fullscreen swap chain", fs_sd_desc.Width, fs_sd_desc.Height);
 		hr = m_dxgi_factory->CreateSwapChainForHwnd(
 			m_dev.get(), window_hwnd, &fs_sd_desc, &fs_desc, fullscreen_output.get(), m_swap_chain.put());
 		if (FAILED(hr))
 		{
-			Console.Warning("Failed to create fullscreen swap chain, trying windowed.");
+			Console.Warning("D3D11: Failed to create fullscreen swap chain, trying windowed.");
 			m_is_exclusive_fullscreen = false;
 			m_using_allow_tearing = m_allow_tearing_supported && m_using_flip_model_swap_chain;
 		}
@@ -722,7 +722,7 @@ bool GSDevice11::CreateSwapChain()

 	if (!m_is_exclusive_fullscreen)
 	{
-		Console.WriteLn("Creating a %dx%d %s windowed swap chain", swap_chain_desc.Width, swap_chain_desc.Height,
+		Console.WriteLn("D3D11: Creating a %dx%d %s windowed swap chain", swap_chain_desc.Width, swap_chain_desc.Height,
 			m_using_flip_model_swap_chain ? "flip-discard" : "discard");
 		hr = m_dxgi_factory->CreateSwapChainForHwnd(
 			m_dev.get(), window_hwnd, &swap_chain_desc, nullptr, nullptr, m_swap_chain.put());
@@ -730,7 +730,7 @@ bool GSDevice11::CreateSwapChain()

 	if (FAILED(hr) && m_using_flip_model_swap_chain)
 	{
-		Console.Warning("Failed to create a flip-discard swap chain, trying discard.");
+		Console.Warning("D3D11: Failed to create a flip-discard swap chain, trying discard.");
 		swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
 		swap_chain_desc.Flags = 0;
 		m_using_flip_model_swap_chain = false;
@@ -740,7 +740,7 @@ bool GSDevice11::CreateSwapChain()
 			m_dev.get(), window_hwnd, &swap_chain_desc, nullptr, nullptr, m_swap_chain.put());
 		if (FAILED(hr))
 		{
-			Console.Error("CreateSwapChainForHwnd failed: 0x%08X", hr);
+			Console.Error("D3D11: CreateSwapChainForHwnd failed: 0x%08X", hr);
 			return false;
 		}
 	}
@@ -752,11 +752,11 @@ bool GSDevice11::CreateSwapChain()
 	{
 		hr = swap_chain_factory->MakeWindowAssociation(window_hwnd, DXGI_MWA_NO_WINDOW_CHANGES);
 		if (FAILED(hr))
-			Console.ErrorFmt("MakeWindowAssociation() to disable ALT+ENTER failed: {}", Error::CreateHResult(hr).GetDescription());
+			Console.ErrorFmt("D3D11: MakeWindowAssociation() to disable ALT+ENTER failed: {}", Error::CreateHResult(hr).GetDescription());
 	}
 	else
 	{
-		Console.ErrorFmt("GetParent() on swap chain to get factory failed: {}", Error::CreateHResult(hr).GetDescription());
+		Console.ErrorFmt("D3D11: GetParent() on swap chain to get factory failed: {}", Error::CreateHResult(hr).GetDescription());
 	}	

 	if (!CreateSwapChainRTV())
@@ -777,7 +777,7 @@ bool GSDevice11::CreateSwapChainRTV()
 	HRESULT hr = m_swap_chain->GetBuffer(0, IID_PPV_ARGS(backbuffer.put()));
 	if (FAILED(hr))
 	{
-		Console.Error("GetBuffer for RTV failed: 0x%08X", hr);
+		Console.Error("D3D11: GetBuffer for RTV failed: 0x%08X", hr);
 		return false;
 	}

@@ -789,14 +789,14 @@ bool GSDevice11::CreateSwapChainRTV()
 	hr = m_dev->CreateRenderTargetView(backbuffer.get(), &rtv_desc, m_swap_chain_rtv.put());
 	if (FAILED(hr))
 	{
-		Console.Error("CreateRenderTargetView for swap chain failed: 0x%08X", hr);
+		Console.Error("D3D11: CreateRenderTargetView for swap chain failed: 0x%08X", hr);
 		m_swap_chain_rtv.reset();
 		return false;
 	}

 	m_window_info.surface_width = backbuffer_desc.Width;
 	m_window_info.surface_height = backbuffer_desc.Height;
-	DevCon.WriteLn("Swap chain buffer size: %ux%u", m_window_info.surface_width, m_window_info.surface_height);
+	DevCon.WriteLn("D3D11: Swap chain buffer size: %ux%u", m_window_info.surface_width, m_window_info.surface_height);

 	if (m_window_info.type == WindowInfo::Type::Win32)
 	{
@@ -838,7 +838,7 @@ bool GSDevice11::UpdateWindow()

 	if (m_window_info.type != WindowInfo::Type::Surfaceless && !CreateSwapChain())
 	{
-		Console.WriteLn("Failed to create swap chain on updated window");
+		Console.WriteLn("D3D11: Failed to create swap chain on updated window");
 		return false;
 	}

@@ -911,7 +911,7 @@ void GSDevice11::ResizeWindow(s32 new_window_width, s32 new_window_height, float
 	HRESULT hr = m_swap_chain->ResizeBuffers(
 		0, 0, 0, DXGI_FORMAT_UNKNOWN, m_using_allow_tearing ? DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING : 0);
 	if (FAILED(hr))
-		Console.Error("ResizeBuffers() failed: 0x%08X", hr);
+		Console.Error("D3D11: ResizeBuffers() failed: 0x%08X", hr);

 	if (!CreateSwapChainRTV())
 		pxFailRel("Failed to recreate swap chain RTV after resize");
@@ -1031,7 +1031,7 @@ void GSDevice11::PopTimestampQuery()

 		if (disjoint.Disjoint)
 		{
-			DevCon.WriteLn("GPU timing disjoint, resetting.");
+			DevCon.WriteLn("D3D11: GPU timing disjoint, resetting.");
 			m_read_timestamp_query = 0;
 			m_write_timestamp_query = 0;
 			m_waiting_timestamp_queries = 0;
@@ -1217,7 +1217,7 @@ GSTexture* GSDevice11::CreateSurface(GSTexture::Type type, int width, int height
 	HRESULT hr = m_dev->CreateTexture2D(&desc, nullptr, texture.put());
 	if (FAILED(hr))
 	{
-		Console.Error("DX11: Failed to allocate %dx%d surface", width, height);
+		Console.Error("D3D11: Failed to allocate %dx%d surface", width, height);
 		return nullptr;
 	}

@@ -1630,7 +1630,7 @@ void GSDevice11::DoFXAA(GSTexture* sTex, GSTexture* dTex)
 		const std::optional<std::string> shader = ReadShaderSource("shaders/common/fxaa.fx");
 		if (!shader.has_value())
 		{
-			Console.Error("FXAA shader is missing");
+			Console.Error("D3D11: FXAA shader is missing");
 			return;
 		}

@@ -1957,7 +1957,7 @@ bool GSDevice11::CreateCASShaders()
 	m_cas.cs_upscale = m_shader_cache.GetComputeShader(m_dev.get(), cas_source.value(), nullptr, "main");
 	if (!m_cas.cs_sharpen || !m_cas.cs_upscale)
 	{
-		Console.Error("Failed to create CAS compute shaders.");
+		Console.Error("D3D11: Failed to create CAS compute shaders.");
 		return false;
 	}

@@ -1996,7 +1996,7 @@ bool GSDevice11::CreateImGuiResources()
 	const std::optional<std::string> hlsl = ReadShaderSource("shaders/dx11/imgui.fx");
 	if (!hlsl.has_value())
 	{
-		Console.Error("Failed to read imgui.fx");
+		Console.Error("D3D11: Failed to read imgui.fx");
 		return false;
 	}

@@ -2013,7 +2013,7 @@ bool GSDevice11::CreateImGuiResources()
 			std::size(layout), hlsl.value(), nullptr, "vs_main") ||
 		!(m_imgui.ps = m_shader_cache.GetPixelShader(m_dev.get(), hlsl.value(), nullptr, "ps_main")))
 	{
-		Console.Error("Failed to compile ImGui shaders");
+		Console.Error("D3D11: Failed to compile ImGui shaders");
 		return false;
 	}

@@ -2029,7 +2029,7 @@ bool GSDevice11::CreateImGuiResources()
 	hr = m_dev->CreateBlendState(&blend_desc, m_imgui.bs.put());
 	if (FAILED(hr))
 	{
-		Console.Error("CreateImGuiResources(): CreateBlendState() failed: %08X", hr);
+		Console.Error("D3D11: CreateImGuiResources(): CreateBlendState() failed: %08X", hr);
 		return false;
 	}

@@ -2040,7 +2040,7 @@ bool GSDevice11::CreateImGuiResources()
 	hr = m_dev->CreateBuffer(&buffer_desc, nullptr, m_imgui.vs_cb.put());
 	if (FAILED(hr))
 	{
-		Console.Error("CreateImGuiResources(): CreateBlendState() failed: %08X", hr);
+		Console.Error("D3D11: CreateImGuiResources(): CreateBlendState() failed: %08X", hr);
 		return false;
 	}

@@ -2566,7 +2566,7 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config)
 	{
 		if (!IASetExpandVertexBuffer(config.verts, sizeof(*config.verts), config.nverts))
 		{
-			Console.Error("Failed to upload structured vertices (%u)", config.nverts);
+			Console.Error("D3D11: Failed to upload structured vertices (%u)", config.nverts);
 			return;
 		}

@@ -2576,7 +2576,7 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config)
 	{
 		if (!IASetVertexBuffer(config.verts, sizeof(*config.verts), config.nverts))
 		{
-			Console.Error("Failed to upload vertices (%u)", config.nverts);
+			Console.Error("D3D11: Failed to upload vertices (%u)", config.nverts);
 			return;
 		}
 	}
@@ -2591,7 +2591,7 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config)
 	{
 		if (!IASetIndexBuffer(config.indices, config.nindices))
 		{
-			Console.Error("Failed to upload indices (%u)", config.nindices);
+			Console.Error("D3D11: Failed to upload indices (%u)", config.nindices);
 			return;
 		}
 	}
--- a/pcsx2/GS/Renderers/DX12/GSDevice12.cpp
+++ b/pcsx2/GS/Renderers/DX12/GSDevice12.cpp
@@ -121,7 +121,7 @@ GSDevice12::ComPtr<ID3D12RootSignature> GSDevice12::CreateRootSignature(const D3
 		m_device->CreateRootSignature(0, blob->GetBufferPointer(), blob->GetBufferSize(), IID_PPV_ARGS(rs.put()));
 	if (FAILED(hr))
 	{
-		Console.Error("CreateRootSignature() failed: %08X", hr);
+		Console.Error("D3D12: CreateRootSignature() failed: %08X", hr);
 		return {};
 	}

@@ -173,7 +173,7 @@ bool GSDevice12::CreateDevice(u32& vendor_id)
 		}
 		else
 		{
-			Console.Error("Debug layer requested but not available.");
+			Console.Error("D3D12: Debug layer requested but not available.");
 			enable_debug_layer = false;
 		}
 	}
@@ -185,7 +185,7 @@ bool GSDevice12::CreateDevice(u32& vendor_id)
 	hr = D3D12CreateDevice(m_adapter.get(), isIntel ? D3D_FEATURE_LEVEL_12_0 : D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device));
 	if (FAILED(hr))
 	{
-		Console.Error("Failed to create D3D12 device: %08X", hr);
+		Console.Error("D3D12: Failed to create device: %08X", hr);
 		return false;
 	}

@@ -193,7 +193,7 @@ bool GSDevice12::CreateDevice(u32& vendor_id)
 	{
 		const LUID luid(m_device->GetAdapterLuid());
 		if (FAILED(m_dxgi_factory->EnumAdapterByLuid(luid, IID_PPV_ARGS(m_adapter.put()))))
-			Console.Error("Failed to get lookup adapter by device LUID");
+			Console.Error("D3D12: Failed to get lookup adapter by device LUID");
 	}

 	if (enable_debug_layer)
@@ -226,7 +226,7 @@ bool GSDevice12::CreateDevice(u32& vendor_id)
 	hr = m_device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&m_command_queue));
 	if (FAILED(hr))
 	{
-		Console.Error("Failed to create command queue: %08X", hr);
+		Console.Error("D3D12: Failed to create command queue: %08X", hr);
 		return false;
 	}

@@ -240,21 +240,21 @@ bool GSDevice12::CreateDevice(u32& vendor_id)
 	hr = D3D12MA::CreateAllocator(&allocatorDesc, m_allocator.put());
 	if (FAILED(hr))
 	{
-		Console.Error("D3D12MA::CreateAllocator() failed with HRESULT %08X", hr);
+		Console.Error("D3D12: CreateAllocator() failed with HRESULT %08X", hr);
 		return false;
 	}

 	hr = m_device->CreateFence(m_completed_fence_value, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_fence));
 	if (FAILED(hr))
 	{
-		Console.Error("Failed to create fence: %08X", hr);
+		Console.Error("D3D12: Failed to create fence: %08X", hr);
 		return false;
 	}

 	m_fence_event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
 	if (m_fence_event == NULL)
 	{
-		Console.Error("Failed to create fence event: %08X", GetLastError());
+		Console.Error("D3D12: Failed to create fence event: %08X", GetLastError());
 		return false;
 	}

@@ -312,7 +312,7 @@ bool GSDevice12::CreateCommandLists()
 				nullptr, IID_PPV_ARGS(res.command_lists[i].put()));
 			if (FAILED(hr))
 			{
-				Console.Error("Failed to create command list: %08X", hr);
+				Console.Error("D3D12: Failed to create command list: %08X", hr);
 				return false;
 			}

@@ -325,13 +325,13 @@ bool GSDevice12::CreateCommandLists()

 		if (!res.descriptor_allocator.Create(m_device.get(), D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, MAX_GPU_SRVS))
 		{
-			Console.Error("Failed to create per frame descriptor allocator");
+			Console.Error("D3D12: Failed to create per frame descriptor allocator");
 			return false;
 		}

 		if (!res.sampler_allocator.Create(m_device.get(), MAX_GPU_SAMPLERS))
 		{
-			Console.Error("Failed to create per frame sampler allocator");
+			Console.Error("D3D12: Failed to create per frame sampler allocator");
 			return false;
 		}
 	}
@@ -378,7 +378,7 @@ void GSDevice12::MoveToNextCommandList()
 		}
 		else
 		{
-			Console.Warning("Map() for timestamp query failed: %08X", hr);
+			Console.Warning("D3D12: Map() for timestamp query failed: %08X", hr);
 		}
 	}

@@ -432,7 +432,7 @@ bool GSDevice12::ExecuteCommandList(WaitType wait_for_completion)
 		hr = res.command_lists[0]->Close();
 		if (FAILED(hr))
 		{
-			Console.Error("Closing init command list failed with HRESULT %08X", hr);
+			Console.Error("D3D12: Closing init command list failed with HRESULT %08X", hr);
 			return false;
 		}
 	}
@@ -441,7 +441,7 @@ bool GSDevice12::ExecuteCommandList(WaitType wait_for_completion)
 	hr = res.command_lists[1]->Close();
 	if (FAILED(hr))
 	{
-		Console.Error("Closing main command list failed with HRESULT %08X", hr);
+		Console.Error("D3D12: Closing main command list failed with HRESULT %08X", hr);
 		return false;
 	}

@@ -581,7 +581,7 @@ bool GSDevice12::CreateTimestampQuery()
 	HRESULT hr = m_device->CreateQueryHeap(&desc, IID_PPV_ARGS(m_timestamp_query_heap.put()));
 	if (FAILED(hr))
 	{
-		Console.Error("CreateQueryHeap() for timestamp failed with %08X", hr);
+		Console.Error("D3D12: CreateQueryHeap() for timestamp failed with %08X", hr);
 		return false;
 	}

@@ -592,7 +592,7 @@ bool GSDevice12::CreateTimestampQuery()
 		m_timestamp_query_allocation.put(), IID_PPV_ARGS(m_timestamp_query_buffer.put()));
 	if (FAILED(hr))
 	{
-		Console.Error("CreateResource() for timestamp failed with %08X", hr);
+		Console.Error("D3D12: CreateResource() for timestamp failed with %08X", hr);
 		return false;
 	}

@@ -600,7 +600,7 @@ bool GSDevice12::CreateTimestampQuery()
 	hr = m_command_queue->GetTimestampFrequency(&frequency);
 	if (FAILED(hr))
 	{
-		Console.Error("GetTimestampFrequency() failed: %08X", hr);
+		Console.Error("D3D12: GetTimestampFrequency() failed: %08X", hr);
 		return false;
 	}

@@ -691,7 +691,7 @@ bool GSDevice12::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)

 	if (!CheckFeatures(vendor_id))
 	{
-		Console.Error("Your GPU does not support the required D3D12 features.");
+		Console.Error("D3D12: Your GPU does not support the required D3D12 features.");
 		return false;
 	}

@@ -715,7 +715,7 @@ bool GSDevice12::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 	}

 	if (!m_shader_cache.Open(m_feature_level, GSConfig.UseDebugDevice))
-		Console.Warning("Shader cache failed to open.");
+		Console.Warning("D3D12: Shader cache failed to open.");

 	if (!CreateNullTexture())
 	{
@@ -769,7 +769,7 @@ void GSDevice12::SetVSyncMode(GSVSyncMode mode, bool allow_present_throttle)
 	// Using mailbox-style no-allow-tearing causes tearing in exclusive fullscreen.
 	if (mode == GSVSyncMode::Mailbox && m_is_exclusive_fullscreen)
 	{
-		WARNING_LOG("Using FIFO instead of Mailbox vsync due to exclusive fullscreen.");
+		WARNING_LOG("D3D12: Using FIFO instead of Mailbox vsync due to exclusive fullscreen.");
 		mode = GSVSyncMode::FIFO;
 	}

@@ -822,7 +822,7 @@ bool GSDevice12::CreateSwapChain()
 		// Using mailbox-style no-allow-tearing causes tearing in exclusive fullscreen.
 		if (m_vsync_mode == GSVSyncMode::Mailbox && m_is_exclusive_fullscreen)
 		{
-			WARNING_LOG("Using FIFO instead of Mailbox vsync due to exclusive fullscreen.");
+			WARNING_LOG("D3D12: Using FIFO instead of Mailbox vsync due to exclusive fullscreen.");
 			m_vsync_mode = GSVSyncMode::FIFO;
 		}
 	}
@@ -859,12 +859,12 @@ bool GSDevice12::CreateSwapChain()
 		fs_desc.Scaling = fullscreen_mode.Scaling;
 		fs_desc.Windowed = FALSE;

-		Console.WriteLn("Creating a %dx%d exclusive fullscreen swap chain", fs_sd_desc.Width, fs_sd_desc.Height);
+		Console.WriteLn("D3D12: Creating a %dx%d exclusive fullscreen swap chain", fs_sd_desc.Width, fs_sd_desc.Height);
 		hr = m_dxgi_factory->CreateSwapChainForHwnd(m_command_queue.get(), window_hwnd, &fs_sd_desc,
 			&fs_desc, fullscreen_output.get(), m_swap_chain.put());
 		if (FAILED(hr))
 		{
-			Console.Warning("Failed to create fullscreen swap chain, trying windowed.");
+			Console.Warning("D3D12: Failed to create fullscreen swap chain, trying windowed.");
 			m_is_exclusive_fullscreen = false;
 			m_using_allow_tearing = m_allow_tearing_supported;
 		}
@@ -872,12 +872,12 @@ bool GSDevice12::CreateSwapChain()

 	if (!m_is_exclusive_fullscreen)
 	{
-		Console.WriteLn("Creating a %dx%d windowed swap chain", swap_chain_desc.Width, swap_chain_desc.Height);
+		Console.WriteLn("D3D12: Creating a %dx%d windowed swap chain", swap_chain_desc.Width, swap_chain_desc.Height);
 		hr = m_dxgi_factory->CreateSwapChainForHwnd(
 			m_command_queue.get(), window_hwnd, &swap_chain_desc, nullptr, nullptr, m_swap_chain.put());

 		if (FAILED(hr))
-			Console.Warning("Failed to create windowed swap chain.");
+			Console.Warning("D3D12: Failed to create windowed swap chain.");
 	}

 	// MWA needs to be called on the correct factory.
@@ -887,11 +887,11 @@ bool GSDevice12::CreateSwapChain()
 	{
 		hr = swap_chain_factory->MakeWindowAssociation(window_hwnd, DXGI_MWA_NO_WINDOW_CHANGES);
 		if (FAILED(hr))
-			Console.ErrorFmt("MakeWindowAssociation() to disable ALT+ENTER failed: {}", Error::CreateHResult(hr).GetDescription());
+			Console.ErrorFmt("D3D12: MakeWindowAssociation() to disable ALT+ENTER failed: {}", Error::CreateHResult(hr).GetDescription());
 	}
 	else
 	{
-		Console.ErrorFmt("GetParent() on swap chain to get factory failed: {}", Error::CreateHResult(hr).GetDescription());
+		Console.ErrorFmt("D3D12: GetParent() on swap chain to get factory failed: {}", Error::CreateHResult(hr).GetDescription());
 	}

 	if (!CreateSwapChainRTV())
@@ -926,7 +926,7 @@ bool GSDevice12::CreateSwapChainRTV()
 		hr = m_swap_chain->GetBuffer(i, IID_PPV_ARGS(backbuffer.put()));
 		if (FAILED(hr))
 		{
-			Console.Error("GetBuffer for RTV failed: 0x%08X", hr);
+			Console.Error("D3D12: GetBuffer for RTV failed: 0x%08X", hr);
 			m_swap_chain_buffers.clear();
 			return false;
 		}
@@ -946,7 +946,7 @@ bool GSDevice12::CreateSwapChainRTV()

 	m_window_info.surface_width = swap_chain_desc.BufferDesc.Width;
 	m_window_info.surface_height = swap_chain_desc.BufferDesc.Height;
-	DevCon.WriteLn("Swap chain buffer size: %ux%u", m_window_info.surface_width, m_window_info.surface_height);
+	DevCon.WriteLn("D3D12: Swap chain buffer size: %ux%u", m_window_info.surface_width, m_window_info.surface_height);

 	if (m_window_info.type == WindowInfo::Type::Win32)
 	{
@@ -998,7 +998,7 @@ bool GSDevice12::UpdateWindow()

 	if (m_window_info.type != WindowInfo::Type::Surfaceless && !CreateSwapChain())
 	{
-		Console.WriteLn("Failed to create swap chain on updated window");
+		Console.WriteLn("D3D12: Failed to create swap chain on updated window");
 		return false;
 	}

@@ -1066,7 +1066,7 @@ void GSDevice12::ResizeWindow(s32 new_window_width, s32 new_window_height, float
 	HRESULT hr = m_swap_chain->ResizeBuffers(
 		0, 0, 0, DXGI_FORMAT_UNKNOWN, m_using_allow_tearing ? DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING : 0);
 	if (FAILED(hr))
-		Console.Error("ResizeBuffers() failed: 0x%08X", hr);
+		Console.Error("D3D12: ResizeBuffers() failed: 0x%08X", hr);

 	if (!CreateSwapChainRTV())
 		pxFailRel("Failed to recreate swap chain RTV after resize");
@@ -1931,7 +1931,7 @@ bool GSDevice12::CompileCASPipelines()
 	m_cas_sharpen_pipeline = cpb.Create(m_device.get(), m_shader_cache, false);
 	if (!m_cas_upscale_pipeline || !m_cas_sharpen_pipeline)
 	{
-		Console.Error("Failed to create CAS pipelines");
+		Console.Error("D3D12: Failed to create CAS pipelines");
 		return false;
 	}

@@ -1943,7 +1943,7 @@ bool GSDevice12::CompileImGuiPipeline()
 	const std::optional<std::string> hlsl = ReadShaderSource("shaders/dx11/imgui.fx");
 	if (!hlsl.has_value())
 	{
-		Console.Error("Failed to read imgui.fx");
+		Console.Error("D3D12: Failed to read imgui.fx");
 		return false;
 	}

@@ -1951,7 +1951,7 @@ bool GSDevice12::CompileImGuiPipeline()
 	const ComPtr<ID3DBlob> ps = m_shader_cache.GetPixelShader(hlsl.value(), nullptr, "ps_main");
 	if (!vs || !ps)
 	{
-		Console.Error("Failed to compile ImGui shaders");
+		Console.Error("D3D12: Failed to compile ImGui shaders");
 		return false;
 	}

@@ -1972,7 +1972,7 @@ bool GSDevice12::CompileImGuiPipeline()
 	m_imgui_pipeline = gpb.Create(m_device.get(), m_shader_cache, false);
 	if (!m_imgui_pipeline)
 	{
-		Console.Error("Failed to compile ImGui pipeline");
+		Console.Error("D3D12: Failed to compile ImGui pipeline");
 		return false;
 	}

@@ -2015,7 +2015,7 @@ void GSDevice12::RenderImGui()
 		// just skip if we run out.. we can't resume the present render pass :/
 		if (!GetSamplerAllocator().LookupSingle(&m_utility_sampler_gpu, m_linear_sampler_cpu))
 		{
-			Console.Warning("Skipping ImGui draw because of no descriptors");
+			Console.Warning("D3D12: Skipping ImGui draw because of no descriptors");
 			return;
 		}
 	}
@@ -2032,7 +2032,7 @@ void GSDevice12::RenderImGui()
 			const u32 size = sizeof(ImDrawVert) * static_cast<u32>(cmd_list->VtxBuffer.Size);
 			if (!m_vertex_stream_buffer.ReserveMemory(size, sizeof(ImDrawVert)))
 			{
-				Console.Warning("Skipping ImGui draw because of no vertex buffer space");
+				Console.Warning("D3D12: Skipping ImGui draw because of no vertex buffer space");
 				return;
 			}

@@ -2072,7 +2072,7 @@ void GSDevice12::RenderImGui()

 				if (!GetTextureGroupDescriptors(&m_utility_texture_gpu, &handle, 1))
 				{
-					Console.Warning("Skipping ImGui draw because of no descriptors");
+					Console.Warning("D3D12: Skipping ImGui draw because of no descriptors");
 					return;
 				}
 			}
@@ -2103,7 +2103,7 @@ bool GSDevice12::DoCAS(
 		if (!GetTextureGroupDescriptors(&sTexDH, &sTex12->GetSRVDescriptor(), 1) ||
 			!GetTextureGroupDescriptors(&dTexDH, &dTex12->GetUAVDescriptor(), 1))
 		{
-			Console.Error("Failed to allocate CAS descriptors.");
+			Console.Error("D3D12: Failed to allocate CAS descriptors.");
 			return false;
 		}
 	}
@@ -3567,7 +3567,7 @@ bool GSDevice12::ApplyTFXState(bool already_execed)
 		{
 			if (already_execed)
 			{
-				Console.Error("Failed to reserve vertex uniform space");
+				Console.Error("D3D12: Failed to reserve vertex uniform space");
 				return false;
 			}

@@ -3588,7 +3588,7 @@ bool GSDevice12::ApplyTFXState(bool already_execed)
 		{
 			if (already_execed)
 			{
-				Console.Error("Failed to reserve pixel uniform space");
+				Console.Error("D3D12: Failed to reserve pixel uniform space");
 				return false;
 			}

@@ -3846,7 +3846,7 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config)
 		date_image = SetupPrimitiveTrackingDATE(config, pipe);
 		if (!date_image)
 		{
-			Console.WriteLn("Failed to allocate DATE image, aborting draw.");
+			Console.WriteLn("D3D12: Failed to allocate DATE image, aborting draw.");
 			return;
 		}
 	}
@@ -3874,7 +3874,7 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config)
 		hdr_rt = static_cast<GSTexture12*>(CreateRenderTarget(rtsize.x, rtsize.y, GSTexture::Format::HDRColor, false));
 		if (!hdr_rt)
 		{
-			Console.WriteLn("Failed to allocate HDR render target, aborting draw.");
+			Console.WriteLn("D3D12: Failed to allocate HDR render target, aborting draw.");
 			if (date_image)
 				Recycle(date_image);
 			return;
--- a/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp
+++ b/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp
@@ -170,13 +170,13 @@ bool GSDeviceOGL::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 	m_gl_context = GLContext::Create(m_window_info, &error);
 	if (!m_gl_context)
 	{
-		Console.ErrorFmt("Failed to create any GL context: {}", error.GetDescription());
+		Console.ErrorFmt("GL: Failed to create any context: {}", error.GetDescription());
 		return false;
 	}

 	if (!m_gl_context->MakeCurrent())
 	{
-		Console.Error("Failed to make GL context current");
+		Console.Error("GL: Failed to make context current");
 		return false;
 	}

@@ -196,11 +196,11 @@ bool GSDeviceOGL::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 	if (!GSConfig.DisableShaderCache)
 	{
 		if (!m_shader_cache.Open())
-			Console.Warning("Shader cache failed to open.");
+			Console.Warning("GL: Shader cache failed to open.");
 	}
 	else
 	{
-		Console.WriteLn("Not using shader cache.");
+		Console.WriteLn("GL: Not using shader cache.");
 	}

 	// because of fbo bindings below...
@@ -544,7 +544,7 @@ bool GSDeviceOGL::Create(GSVSyncMode vsync_mode, bool allow_present_throttle)
 		}
 		else
 		{
-			Console.Error("Failed to create texture upload buffer. Using slow path.");
+			Console.Error("GL: Failed to create texture upload buffer. Using slow path.");
 		}
 	}

@@ -617,17 +617,17 @@ bool GSDeviceOGL::CheckFeatures(bool& buggy_pbo)
 	if (std::strstr(vendor, "Advanced Micro Devices") || std::strstr(vendor, "ATI Technologies Inc.") ||
 		std::strstr(vendor, "ATI"))
 	{
-		Console.WriteLn(Color_StrongRed, "OGL: AMD GPU detected.");
+		Console.WriteLn(Color_StrongRed, "GL: AMD GPU detected.");
 		//vendor_id_amd = true;
 	}
 	else if (std::strstr(vendor, "NVIDIA Corporation"))
 	{
-		Console.WriteLn(Color_StrongGreen, "OGL: NVIDIA GPU detected.");
+		Console.WriteLn(Color_StrongGreen, "GL: NVIDIA GPU detected.");
 		vendor_id_nvidia = true;
 	}
 	else if (std::strstr(vendor, "Intel"))
 	{
-		Console.WriteLn(Color_StrongBlue, "OGL: Intel GPU detected.");
+		Console.WriteLn(Color_StrongBlue, "GL: Intel GPU detected.");
 		//vendor_id_intel = true;
 	}

@@ -706,13 +706,13 @@ bool GSDeviceOGL::CheckFeatures(bool& buggy_pbo)
 	// using the normal texture update routines and letting the driver take care of it.
 	buggy_pbo = !GLAD_GL_VERSION_4_4 && !GLAD_GL_ARB_buffer_storage && !GLAD_GL_EXT_buffer_storage;
 	if (buggy_pbo)
-		Console.Warning("Not using PBOs for texture uploads because buffer_storage is unavailable.");
+		Console.Warning("GL: Not using PBOs for texture uploads because buffer_storage is unavailable.");

 	// Give the user the option to disable PBO usage for downloads.
 	// Most drivers seem to be faster with PBO.
 	m_disable_download_pbo = Host::GetBoolSettingValue("EmuCore/GS", "DisableGLDownloadPBO", false);
 	if (m_disable_download_pbo)
-		Console.Warning("Not using PBOs for texture downloads, this may reduce performance.");
+		Console.Warning("GL: Not using PBOs for texture downloads, this may reduce performance.");

 	// optional features based on context
 	m_features.broken_point_sampler = false;
@@ -751,7 +751,7 @@ bool GSDeviceOGL::CheckFeatures(bool& buggy_pbo)
 	const bool buggy_vs_expand =
 		vendor_id_nvidia && (!GLAD_GL_ARB_bindless_texture && !GLAD_GL_NV_bindless_texture);
 	if (buggy_vs_expand)
-		Console.Warning("Disabling vertex shader expand due to broken NVIDIA driver.");
+		Console.Warning("GL: Disabling vertex shader expand due to broken NVIDIA driver.");

 	if (GLAD_GL_ARB_shader_storage_buffer_object)
 	{
@@ -762,7 +762,7 @@ bool GSDeviceOGL::CheckFeatures(bool& buggy_pbo)
 								GLAD_GL_ARB_gpu_shader5);
 	}
 	if (!m_features.vs_expand)
-		Console.Warning("Vertex expansion is not supported. This will reduce performance.");
+		Console.Warning("GL: Vertex expansion is not supported. This will reduce performance.");

 	GLint point_range[2] = {};
 	glGetIntegerv(GL_ALIASED_POINT_SIZE_RANGE, point_range);
@@ -774,7 +774,7 @@ bool GSDeviceOGL::CheckFeatures(bool& buggy_pbo)
 	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
 	m_max_texture_size = std::max(1024u, static_cast<u32>(max_texture_size));

-	Console.WriteLn("Using %s for point expansion, %s for line expansion and %s for sprite expansion.",
+	Console.WriteLn("GL: Using %s for point expansion, %s for line expansion and %s for sprite expansion.",
 		m_features.point_expand ? "hardware" : (m_features.vs_expand ? "vertex expanding" : "UNSUPPORTED"),
 		m_features.line_expand ? "hardware" : (m_features.vs_expand ? "vertex expanding" : "UNSUPPORTED"),
 		m_features.vs_expand ? "vertex expanding" : "CPU");
@@ -798,7 +798,7 @@ void GSDeviceOGL::SetSwapInterval()
 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);

 	if (!m_gl_context->SetSwapInterval(interval))
-		WARNING_LOG("Failed to set swap interval to {}", interval);
+		WARNING_LOG("GL: Failed to set swap interval to {}", interval);

 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, current_fbo);
 }
@@ -881,7 +881,7 @@ bool GSDeviceOGL::UpdateWindow()

 	if (!m_gl_context->ChangeSurface(m_window_info))
 	{
-		Console.Error("Failed to change surface");
+		Console.Error("GL: Failed to change surface");
 		return false;
 	}

@@ -920,7 +920,7 @@ void GSDeviceOGL::DestroySurface()
 {
 	m_window_info = {};
 	if (!m_gl_context->ChangeSurface(m_window_info))
-		Console.Error("Failed to switch to surfaceless");
+		Console.Error("GL: Failed to switch to surfaceless");
 }

 std::string GSDeviceOGL::GetDriverInfo() const
@@ -1336,7 +1336,7 @@ std::string GSDeviceOGL::GenGlslHeader(const std::string_view entry, GLenum type

 std::string GSDeviceOGL::GetVSSource(VSSelector sel)
 {
-	DevCon.WriteLn("Compiling new vertex shader with selector 0x%" PRIX64, sel.key);
+	DevCon.WriteLn("GL: Compiling new vertex shader with selector 0x%" PRIX64, sel.key);

 	std::string macro = fmt::format("#define VS_FST {}\n", static_cast<u32>(sel.fst))
 		+ fmt::format("#define VS_IIP {}\n", static_cast<u32>(sel.iip))
@@ -1350,7 +1350,7 @@ std::string GSDeviceOGL::GetVSSource(VSSelector sel)

 std::string GSDeviceOGL::GetPSSource(const PSSelector& sel)
 {
-	DevCon.WriteLn("Compiling new pixel shader with selector 0x%" PRIX64 "%08X", sel.key_hi, sel.key_lo);
+	DevCon.WriteLn("GL: Compiling new pixel shader with selector 0x%" PRIX64 "%08X", sel.key_hi, sel.key_lo);

 	std::string macro = fmt::format("#define PS_FST {}\n", sel.fst)
 		+ fmt::format("#define PS_WMS {}\n", sel.wms)
@@ -1834,7 +1834,7 @@ bool GSDeviceOGL::CompileFXAAProgram()
 	const std::optional<std::string> shader = ReadShaderSource("shaders/common/fxaa.fx");
 	if (!shader.has_value())
 	{
-		Console.Error("Failed to read fxaa.fs");
+		Console.Error("GL: Failed to read fxaa.fs");
 		return false;
 	}

@@ -1842,7 +1842,7 @@ bool GSDeviceOGL::CompileFXAAProgram()
 	std::optional<GLProgram> prog = m_shader_cache.GetProgram(m_convert.vs, ps);
 	if (!prog.has_value())
 	{
-		Console.Error("Failed to compile FXAA fragment shader");
+		Console.Error("GL: Failed to compile FXAA fragment shader");
 		return false;
 	}

@@ -2065,7 +2065,7 @@ bool GSDeviceOGL::CreateImGuiProgram()
 	const std::optional<std::string> glsl = ReadShaderSource("shaders/opengl/imgui.glsl");
 	if (!glsl.has_value())
 	{
-		Console.Error("Failed to read imgui.glsl");
+		Console.Error("GL: Failed to read imgui.glsl");
 		return false;
 	}

@@ -2074,7 +2074,7 @@ bool GSDeviceOGL::CreateImGuiProgram()
 		GetShaderSource("ps_main", GL_FRAGMENT_SHADER, glsl.value()));
 	if (!prog.has_value())
 	{
-		Console.Error("Failed to compile imgui shaders");
+		Console.Error("GL: Failed to compile imgui shaders");
 		return false;
 	}

--- a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp
+++ b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp
@@ -157,7 +157,7 @@ bool GSDeviceVK::SelectInstanceExtensions(ExtensionList* extension_list, const W

 	if (extension_count == 0)
 	{
-		Console.Error("Vulkan: No extensions supported by instance.");
+		Console.Error("VK: No extensions supported by instance.");
 		return false;
 	}

@@ -170,13 +170,13 @@ bool GSDeviceVK::SelectInstanceExtensions(ExtensionList* extension_list, const W
 				[name](const VkExtensionProperties& properties) { return !strcmp(name, properties.extensionName); }) !=
 			available_extension_list.end())
 		{
-			DevCon.WriteLn("Enabling extension: %s", name);
+			DevCon.WriteLn("VK: Enabling extension: %s", name);
 			extension_list->push_back(name);
 			return true;
 		}

 		if (required)
-			Console.Error("Vulkan: Missing required extension %s.", name);
+			Console.Error("VK: Missing required extension %s.", name);

 		return false;
 	};
@@ -204,7 +204,7 @@ bool GSDeviceVK::SelectInstanceExtensions(ExtensionList* extension_list, const W

 	// VK_EXT_debug_utils
 	if (enable_debug_utils && !SupportsExtension(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, false))
-		Console.Warning("Vulkan: Debug report requested, but extension is not available.");
+		Console.Warning("VK: Debug report requested, but extension is not available.");

 	oe->vk_ext_swapchain_maintenance1 = (wi.type != WindowInfo::Type::Surfaceless &&
 										 SupportsExtension(VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME, false));
@@ -231,7 +231,7 @@ GSDeviceVK::GPUList GSDeviceVK::EnumerateGPUs(VkInstance instance)
 	res = vkEnumeratePhysicalDevices(instance, &gpu_count, physical_devices.data());
 	if (res == VK_INCOMPLETE)
 	{
-		Console.Warning("First vkEnumeratePhysicalDevices() call returned %zu devices, but second returned %u",
+		Console.Warning("VK: First vkEnumeratePhysicalDevices() call returned %zu devices, but second returned %u",
 			physical_devices.size(), gpu_count);
 	}
 	else if (res != VK_SUCCESS)
@@ -254,7 +254,7 @@ GSDeviceVK::GPUList GSDeviceVK::EnumerateGPUs(VkInstance instance)
 		if (VK_API_VERSION_VARIANT(props.apiVersion) == 0 && VK_API_VERSION_MAJOR(props.apiVersion) <= 1 &&
 			VK_API_VERSION_MINOR(props.apiVersion) < 1)
 		{
-			Console.Warning(fmt::format("Ignoring Vulkan GPU '{}' because it only claims support for Vulkan {}.{}.{}",
+			Console.Warning(fmt::format("VK: Ignoring GPU '{}' because it only claims support for Vulkan {}.{}.{}",
 				props.deviceName, VK_API_VERSION_MAJOR(props.apiVersion), VK_API_VERSION_MINOR(props.apiVersion),
 				VK_API_VERSION_PATCH(props.apiVersion)));
 			continue;
@@ -265,7 +265,7 @@ GSDeviceVK::GPUList GSDeviceVK::EnumerateGPUs(VkInstance instance)
 		res = vkEnumerateDeviceExtensionProperties(device, nullptr, &extension_count, nullptr);
 		if (res != VK_SUCCESS)
 		{
-			Console.Warning(fmt::format("Ignoring Vulkan GPU '{}' because vkEnumerateInstanceExtensionProperties() failed: ",
+			Console.Warning(fmt::format("VK: Ignoring GPU '{}' because vkEnumerateInstanceExtensionProperties() failed: ",
 				props.deviceName, Vulkan::VkResultToString(res)));
 			continue;
 		}
@@ -283,7 +283,7 @@ GSDeviceVK::GPUList GSDeviceVK::EnumerateGPUs(VkInstance instance)
 					return (std::strcmp(required_extension_name, ext.extensionName) == 0);
 				}) == available_extension_list.end())
 			{
-				Console.Warning(fmt::format("Ignoring Vulkan GPU '{}' because is is missing required extension {}",
+				Console.Warning(fmt::format("VK: Ignoring GPU '{}' because is is missing required extension {}",
 					props.deviceName, required_extension_name));
 				has_missing_extension = true;
 			}
@@ -360,7 +360,7 @@ bool GSDeviceVK::SelectDeviceExtensions(ExtensionList* extension_list, bool enab

 	if (extension_count == 0)
 	{
-		Console.Error("Vulkan: No extensions supported by device.");
+		Console.Error("VK: No extensions supported by device.");
 		return false;
 	}

@@ -377,7 +377,7 @@ bool GSDeviceVK::SelectDeviceExtensions(ExtensionList* extension_list, bool enab
 			if (std::none_of(extension_list->begin(), extension_list->end(),
 					[name](const char* existing_name) { return (std::strcmp(existing_name, name) == 0); }))
 			{
-				DevCon.WriteLn("Enabling extension: %s", name);
+				DevCon.WriteLn("VK: Enabling extension: %s", name);
 				extension_list->push_back(name);
 			}

@@ -385,7 +385,7 @@ bool GSDeviceVK::SelectDeviceExtensions(ExtensionList* extension_list, bool enab
 		}

 		if (required)
-			Console.Error("Vulkan: Missing required extension %s.", name);
+			Console.Error("VK: Missing required extension %s.", name);

 		return false;
 	};
@@ -531,12 +531,12 @@ bool GSDeviceVK::CreateDevice(VkSurfaceKHR surface, bool enable_validation_layer
 	}
 	if (m_graphics_queue_family_index == queue_family_count)
 	{
-		Console.Error("Vulkan: Failed to find an acceptable graphics queue.");
+		Console.Error("VK: Failed to find an acceptable graphics queue.");
 		return false;
 	}
 	if (surface != VK_NULL_HANDLE && m_present_queue_family_index == queue_family_count)
 	{
-		Console.Error("Vulkan: Failed to find an acceptable present queue.");
+		Console.Error("VK: Failed to find an acceptable present queue.");
 		return false;
 	}

@@ -758,7 +758,7 @@ bool GSDeviceVK::ProcessDeviceExtensions()
 	// confirm we actually support it
 	if (push_descriptor_properties.maxPushDescriptors < NUM_TFX_TEXTURES)
 	{
-		Console.Error("maxPushDescriptors (%u) is below required (%u)", push_descriptor_properties.maxPushDescriptors,
+		Console.Error("VK: maxPushDescriptors (%u) is below required (%u)", push_descriptor_properties.maxPushDescriptors,
 			NUM_TFX_TEXTURES);
 		return false;
 	}
@@ -766,7 +766,7 @@ bool GSDeviceVK::ProcessDeviceExtensions()
 	if (!line_rasterization_feature.bresenhamLines)
 	{
 		// See note in SelectDeviceExtensions().
-		Console.Error("bresenhamLines is not supported.");
+		Console.Error("VK: bresenhamLines is not supported.");
 #ifndef __APPLE__
 		return false;
 #else
@@ -870,7 +870,7 @@ bool GSDeviceVK::CreateAllocator()

 			if (heap_size_limits[type.heapIndex] == VK_WHOLE_SIZE)
 			{
-				Console.Warning("Disabling allocation from upload heap #%u (%.2f MB) due to debug device.",
+				Console.Warning("VK: Disabling allocation from upload heap #%u (%.2f MB) due to debug device.",
 					type.heapIndex, static_cast<float>(heap.size) / 1048576.0f);
 				heap_size_limits[type.heapIndex] = 0;
 				has_upload_heap = true;
@@ -1447,22 +1447,22 @@ VKAPI_ATTR VkBool32 VKAPI_CALL DebugMessengerCallback(VkDebugUtilsMessageSeverit
 {
 	if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
 	{
-		Console.Error("Vulkan debug report: (%s) %s",
+		Console.Error("VK: debug report: (%s) %s",
 			pCallbackData->pMessageIdName ? pCallbackData->pMessageIdName : "", pCallbackData->pMessage);
 	}
 	else if (severity & (VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT))
 	{
-		Console.Warning("Vulkan debug report: (%s) %s",
+		Console.Warning("VK: debug report: (%s) %s",
 			pCallbackData->pMessageIdName ? pCallbackData->pMessageIdName : "", pCallbackData->pMessage);
 	}
 	else if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT)
 	{
-		Console.WriteLn("Vulkan debug report: (%s) %s",
+		Console.WriteLn("VK: debug report: (%s) %s",
 			pCallbackData->pMessageIdName ? pCallbackData->pMessageIdName : "", pCallbackData->pMessage);
 	}
 	else
 	{
-		DevCon.WriteLn("Vulkan debug report: (%s) %s",
+		DevCon.WriteLn("VK: debug report: (%s) %s",
 			pCallbackData->pMessageIdName ? pCallbackData->pMessageIdName : "", pCallbackData->pMessage);
 	}

@@ -2173,7 +2173,7 @@ bool GSDeviceVK::UpdateWindow()
 	VkSurfaceKHR surface = VKSwapChain::CreateVulkanSurface(m_instance, m_physical_device, &m_window_info);
 	if (surface == VK_NULL_HANDLE)
 	{
-		Console.Error("Failed to create new surface for swap chain");
+		Console.Error("VK: Failed to create new surface for swap chain");
 		return false;
 	}

@@ -2182,7 +2182,7 @@ bool GSDeviceVK::UpdateWindow()
 		!(m_swap_chain = VKSwapChain::Create(m_window_info, surface, present_mode,
 			  Pcsx2Config::GSOptions::TriStateToOptionalBoolean(GSConfig.ExclusiveFullscreenControl))))
 	{
-		Console.Error("Failed to create swap chain");
+		Console.Error("VK: Failed to create swap chain");
 		VKSwapChain::DestroyVulkanSurface(m_instance, &m_window_info, surface);
 		return false;
 	}
@@ -2210,7 +2210,7 @@ void GSDeviceVK::ResizeWindow(s32 new_window_width, s32 new_window_height, float
 	if (!m_swap_chain->ResizeSwapChain(new_window_width, new_window_height, new_window_scale))
 	{
 		// AcquireNextImage() will fail, and we'll recreate the surface.
-		Console.Error("Failed to resize swap chain. Next present will fail.");
+		Console.Error("VK: Failed to resize swap chain. Next present will fail.");
 		return;
 	}

@@ -2316,10 +2316,10 @@ GSDevice::PresentResult GSDeviceVK::BeginPresent(bool frame_skip)
 		}
 		else if (res == VK_ERROR_SURFACE_LOST_KHR)
 		{
-			Console.Warning("Surface lost, attempting to recreate");
+			Console.Warning("VK: Surface lost, attempting to recreate");
 			if (!m_swap_chain->RecreateSurface(m_window_info))
 			{
-				Console.Error("Failed to recreate surface after loss");
+				Console.Error("VK: Failed to recreate surface after loss");
 				ExecuteCommandBuffer(false);
 				return PresentResult::FrameSkipped;
 			}
@@ -2494,7 +2494,7 @@ bool GSDeviceVK::CreateDeviceAndSwapChain()
 				return false;
 			}

-			ERROR_LOG("Vulkan validation/debug layers requested but are unavailable. Creating non-debug device.");
+			ERROR_LOG("VK: validation/debug layers requested but are unavailable. Creating non-debug device.");
 		}
 	}

@@ -2624,7 +2624,7 @@ bool GSDeviceVK::CheckFeatures()
 	m_features.vs_expand = !GSConfig.DisableVertexShaderExpand;

 	if (!m_features.texture_barrier)
-		Console.Warning("Texture buffers are disabled. This may break some graphical effects.");
+		Console.Warning("VK: Texture buffers are disabled. This may break some graphical effects.");

 	// Test for D32S8 support.
 	{
@@ -2670,7 +2670,7 @@ bool GSDeviceVK::CheckFeatures()
 		vkGetPhysicalDeviceFormatProperties(m_physical_device, vkfmt, &props);
 		if ((props.optimalTilingFeatures & bits) != bits)
 		{
-			Host::ReportFormattedErrorAsync("Vulkan Renderer Unavailable",
+			Host::ReportFormattedErrorAsync("VK: Renderer Unavailable",
 				"Required format %u is missing bits, you may need to update your driver. (vk:%u, has:0x%x, needs:0x%x)",
 				fmt, static_cast<unsigned>(vkfmt), props.optimalTilingFeatures, bits);
 			return false;
@@ -4387,14 +4387,14 @@ bool GSDeviceVK::CompileImGuiPipeline()
 	const std::optional<std::string> glsl = ReadShaderSource("shaders/vulkan/imgui.glsl");
 	if (!glsl.has_value())
 	{
-		Console.Error("Failed to read imgui.glsl");
+		Console.Error("VK: Failed to read imgui.glsl");
 		return false;
 	}

 	VkShaderModule vs = GetUtilityVertexShader(glsl.value(), "vs_main");
 	if (vs == VK_NULL_HANDLE)
 	{
-		Console.Error("Failed to compile ImGui vertex shader");
+		Console.Error("VK: Failed to compile ImGui vertex shader");
 		return false;
 	}
 	ScopedGuard vs_guard([this, &vs]() { vkDestroyShaderModule(m_device, vs, nullptr); });
@@ -4402,7 +4402,7 @@ bool GSDeviceVK::CompileImGuiPipeline()
 	VkShaderModule ps = GetUtilityFragmentShader(glsl.value(), "ps_main");
 	if (ps == VK_NULL_HANDLE)
 	{
-		Console.Error("Failed to compile ImGui pixel shader");
+		Console.Error("VK: Failed to compile ImGui pixel shader");
 		return false;
 	}
 	ScopedGuard ps_guard([this, &ps]() { vkDestroyShaderModule(m_device, ps, nullptr); });
@@ -4429,7 +4429,7 @@ bool GSDeviceVK::CompileImGuiPipeline()
 	m_imgui_pipeline = gpb.Create(m_device, g_vulkan_shader_cache->GetPipelineCache(), false);
 	if (!m_imgui_pipeline)
 	{
-		Console.Error("Failed to compile ImGui pipeline");
+		Console.Error("VK: Failed to compile ImGui pipeline");
 		return false;
 	}

@@ -4474,7 +4474,7 @@ void GSDeviceVK::RenderImGui()
 			const u32 size = sizeof(ImDrawVert) * static_cast<u32>(cmd_list->VtxBuffer.Size);
 			if (!m_vertex_stream_buffer.ReserveMemory(size, sizeof(ImDrawVert)))
 			{
-				Console.Warning("Skipping ImGui draw because of no vertex buffer space");
+				Console.Warning("VK: Skipping ImGui draw because of no vertex buffer space");
 				return;
 			}

@@ -4518,7 +4518,7 @@ void GSDeviceVK::RenderBlankFrame()
 	VkResult res = m_swap_chain->AcquireNextImage();
 	if (res != VK_SUCCESS)
 	{
-		Console.Error("Failed to acquire image for blank frame present");
+		Console.Error("VK: Failed to acquire image for blank frame present");
 		return;
 	}

@@ -5021,13 +5021,13 @@ void GSDeviceVK::ExecuteCommandBuffer(bool wait_for_completion, const char* reas
 	const std::string reason_str(StringUtil::StdStringFromFormatV(reason, ap));
 	va_end(ap);

-	Console.Warning("Vulkan: Executing command buffer due to '%s'", reason_str.c_str());
+	Console.Warning("VK: Executing command buffer due to '%s'", reason_str.c_str());
 	ExecuteCommandBuffer(wait_for_completion);
 }

 void GSDeviceVK::ExecuteCommandBufferAndRestartRenderPass(bool wait_for_completion, const char* reason)
 {
-	Console.Warning("Vulkan: Executing command buffer due to '%s'", reason);
+	Console.Warning("VK: Executing command buffer due to '%s'", reason);

 	const VkRenderPass render_pass = m_current_render_pass;
 	const GSVector4i render_pass_area = m_current_render_pass_area;
@@ -5344,7 +5344,7 @@ bool GSDeviceVK::ApplyTFXState(bool already_execed)
 		{
 			if (already_execed)
 			{
-				Console.Error("Failed to reserve vertex uniform space");
+				Console.Error("VK: Failed to reserve vertex uniform space");
 				return false;
 			}

@@ -5365,7 +5365,7 @@ bool GSDeviceVK::ApplyTFXState(bool already_execed)
 		{
 			if (already_execed)
 			{
-				Console.Error("Failed to reserve pixel uniform space");
+				Console.Error("VK: Failed to reserve pixel uniform space");
 				return false;
 			}

@@ -5991,7 +5991,7 @@ void GSDeviceVK::SendHWDraw(const GSHWDrawConfig& config, GSTextureVK* draw_rt,

 #ifdef PCSX2_DEVBUILD
 	if ((one_barrier || full_barrier) && !m_pipeline_selector.ps.IsFeedbackLoop()) [[unlikely]]
-		Console.Warning("GS: Possible unnecessary barrier detected.");
+		Console.Warning("VK: Possible unnecessary barrier detected.");
 #endif
 	const VkDependencyFlags barrier_flags = GetColorBufferBarrierFlags();
 	if (full_barrier)
--- a/pcsx2/GameDatabase.cpp
+++ b/pcsx2/GameDatabase.cpp
@@ -118,7 +118,7 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::
 			if (eeVal >= 0 && eeVal < static_cast<int>(FPRoundMode::MaxCount))
 				gameEntry.eeRoundMode = static_cast<FPRoundMode>(eeVal);
 			else
-				Console.Error(fmt::format("[GameDB] Invalid EE round mode '{}', specified for serial: '{}'.", eeVal, serial));
+				Console.Error(fmt::format("GameDB: Invalid EE round mode '{}', specified for serial: '{}'.", eeVal, serial));
 		}
 		if (node["roundModes"].has_child("eeDivRoundMode"))
 		{
@@ -127,7 +127,7 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::
 			if (eeVal >= 0 && eeVal < static_cast<int>(FPRoundMode::MaxCount))
 				gameEntry.eeDivRoundMode = static_cast<FPRoundMode>(eeVal);
 			else
-				Console.Error(fmt::format("[GameDB] Invalid EE division round mode '{}', specified for serial: '{}'.", eeVal, serial));
+				Console.Error(fmt::format("GameDB: Invalid EE division round mode '{}', specified for serial: '{}'.", eeVal, serial));
 		}
 		if (node["roundModes"].has_child("vuRoundMode"))
 		{
@@ -140,7 +140,7 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::
 			}
 			else
 			{
-				Console.Error(fmt::format("[GameDB] Invalid VU round mode '{}', specified for serial: '{}'.", vuVal, serial));
+				Console.Error(fmt::format("GameDB: Invalid VU round mode '{}', specified for serial: '{}'.", vuVal, serial));
 			}
 		}
 		if (node["roundModes"].has_child("vu0RoundMode"))
@@ -150,7 +150,7 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::
 			if (vuVal >= 0 && vuVal < static_cast<int>(FPRoundMode::MaxCount))
 				gameEntry.vu0RoundMode = static_cast<FPRoundMode>(vuVal);
 			else
-				Console.Error(fmt::format("[GameDB] Invalid VU0 round mode '{}', specified for serial: '{}'.", vuVal, serial));
+				Console.Error(fmt::format("GameDB: Invalid VU0 round mode '{}', specified for serial: '{}'.", vuVal, serial));
 		}
 		if (node["roundModes"].has_child("vu1RoundMode"))
 		{
@@ -159,7 +159,7 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::
 			if (vuVal >= 0 && vuVal < static_cast<int>(FPRoundMode::MaxCount))
 				gameEntry.vu1RoundMode = static_cast<FPRoundMode>(vuVal);
 			else
-				Console.Error(fmt::format("[GameDB] Invalid VU1 round mode '{}', specified for serial: '{}'.", vuVal, serial));
+				Console.Error(fmt::format("GameDB: Invalid VU1 round mode '{}', specified for serial: '{}'.", vuVal, serial));
 		}
 	}
 	if (node.has_child("clampModes"))
@@ -217,7 +217,7 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::

 			if (!fixValidated)
 			{
-				Console.Error(fmt::format("[GameDB] Invalid gamefix: '{}', specified for serial: '{}'. Dropping!", fix, serial));
+				Console.Error(fmt::format("GameDB: Invalid gamefix: '{}', specified for serial: '{}'. Dropping!", fix, serial));
 			}
 		}
 	}
@@ -239,7 +239,7 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::
 			}
 			else
 			{
-				Console.Error(fmt::format("[GameDB] Invalid speedhack: '{}={}', specified for serial: '{}'. Dropping!",
+				Console.Error(fmt::format("GameDB: Invalid speedhack: '{}={}', specified for serial: '{}'. Dropping!",
 					id_view, value_view, serial));
 			}
 		}
@@ -266,7 +266,7 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::

 				if (value.value_or(-1) < 0)
 				{
-					Console.Error(fmt::format("[GameDB] Invalid GS HW Fix Value for '{}' in '{}': '{}'", id_name, serial, str_value));
+					Console.Error(fmt::format("GameDB: Invalid GS HW Fix Value for '{}' in '{}': '{}'", id_name, serial, str_value));
 					continue;
 				}
 			}
@@ -276,7 +276,7 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::
 			}
 			if (!id.has_value() || !value.has_value())
 			{
-				Console.Error(fmt::format("[GameDB] Invalid GS HW Fix: '{}' specified for serial '{}'. Dropping!", id_name, serial));
+				Console.Error(fmt::format("GameDB: Invalid GS HW Fix: '{}' specified for serial '{}'. Dropping!", id_name, serial));
 				continue;
 			}

@@ -305,12 +305,12 @@ void GameDatabase::parseAndInsert(const std::string_view serial, const c4::yml::
 			const std::optional<u32> crc = (StringUtil::compareNoCase(crc_str, "default")) ? std::optional<u32>(0) : StringUtil::FromChars<u32>(crc_str, 16);
 			if (!crc.has_value())
 			{
-				Console.Error(fmt::format("[GameDB] Invalid CRC '{}' found for serial: '{}'. Skipping!", crc_str, serial));
+				Console.Error(fmt::format("GameDB: Invalid CRC '{}' found for serial: '{}'. Skipping!", crc_str, serial));
 				continue;
 			}
 			if (gameEntry.patches.find(crc.value()) != gameEntry.patches.end())
 			{
-				Console.Error(fmt::format("[GameDB] Duplicate CRC '{}' found for serial: '{}'. Skipping, CRCs are case-insensitive!", crc_str, serial));
+				Console.Error(fmt::format("GameDB: Duplicate CRC '{}' found for serial: '{}'. Skipping, CRCs are case-insensitive!", crc_str, serial));
 				continue;
 			}

@@ -442,18 +442,18 @@ void GameDatabaseSchema::GameEntry::applyGameFixes(Pcsx2Config& config, bool app
 {
 	// Only apply core game fixes if the user has enabled them.
 	if (!applyAuto)
-		Console.Warning("[GameDB] Game Fixes are disabled");
+		Console.Warning("GameDB: Game Fixes are disabled");

 	if (eeRoundMode < FPRoundMode::MaxCount)
 	{
 		if (applyAuto)
 		{
-			Console.WriteLn("(GameDB) Changing EE/FPU roundmode to %d [%s]", eeRoundMode, s_round_modes[static_cast<u8>(eeRoundMode)]);
+			Console.WriteLn("GameDB: Changing EE/FPU roundmode to %d [%s]", eeRoundMode, s_round_modes[static_cast<u8>(eeRoundMode)]);
 			config.Cpu.FPUFPCR.SetRoundMode(eeRoundMode);
 		}
 		else
 		{
-			Console.Warning("[GameDB] Skipping changing EE/FPU roundmode to %d [%s]", eeRoundMode, s_round_modes[static_cast<u8>(eeRoundMode)]);
+			Console.Warning("GameDB: Skipping changing EE/FPU roundmode to %d [%s]", eeRoundMode, s_round_modes[static_cast<u8>(eeRoundMode)]);
 		}
 	}

@@ -461,12 +461,12 @@ void GameDatabaseSchema::GameEntry::applyGameFixes(Pcsx2Config& config, bool app
 	{
 		if (applyAuto)
 		{
-			Console.WriteLn("(GameDB) Changing EE/FPU divison roundmode to %d [%s]", eeRoundMode, s_round_modes[static_cast<u8>(eeDivRoundMode)]);
+			Console.WriteLn("GameDB: Changing EE/FPU divison roundmode to %d [%s]", eeRoundMode, s_round_modes[static_cast<u8>(eeDivRoundMode)]);
 			config.Cpu.FPUDivFPCR.SetRoundMode(eeDivRoundMode);
 		}
 		else
 		{
-			Console.Warning("[GameDB] Skipping changing EE/FPU roundmode to %d [%s]", eeRoundMode, s_round_modes[static_cast<u8>(eeRoundMode)]);
+			Console.Warning("GameDB: Skipping changing EE/FPU roundmode to %d [%s]", eeRoundMode, s_round_modes[static_cast<u8>(eeRoundMode)]);
 		}
 	}

@@ -474,12 +474,12 @@ void GameDatabaseSchema::GameEntry::applyGameFixes(Pcsx2Config& config, bool app
 	{
 		if (applyAuto)
 		{
-			Console.WriteLn("(GameDB) Changing VU0 roundmode to %d [%s]", vu0RoundMode, s_round_modes[static_cast<u8>(vu0RoundMode)]);
+			Console.WriteLn("GameDB: Changing VU0 roundmode to %d [%s]", vu0RoundMode, s_round_modes[static_cast<u8>(vu0RoundMode)]);
 			config.Cpu.VU0FPCR.SetRoundMode(vu0RoundMode);
 		}
 		else
 		{
-			Console.Warning("[GameDB] Skipping changing VU0 roundmode to %d [%s]", vu0RoundMode, s_round_modes[static_cast<u8>(vu0RoundMode)]);
+			Console.Warning("GameDB: Skipping changing VU0 roundmode to %d [%s]", vu0RoundMode, s_round_modes[static_cast<u8>(vu0RoundMode)]);
 		}
 	}

@@ -487,12 +487,12 @@ void GameDatabaseSchema::GameEntry::applyGameFixes(Pcsx2Config& config, bool app
 	{
 		if (applyAuto)
 		{
-			Console.WriteLn("(GameDB) Changing VU1 roundmode to %d [%s]", vu1RoundMode, s_round_modes[static_cast<u8>(vu1RoundMode)]);
+			Console.WriteLn("GameDB: Changing VU1 roundmode to %d [%s]", vu1RoundMode, s_round_modes[static_cast<u8>(vu1RoundMode)]);
 			config.Cpu.VU1FPCR.SetRoundMode(vu1RoundMode);
 		}
 		else
 		{
-			Console.Warning("[GameDB] Skipping changing VU1 roundmode to %d [%s]", vu1RoundMode, s_round_modes[static_cast<u8>(vu1RoundMode)]);
+			Console.Warning("GameDB: Skipping changing VU1 roundmode to %d [%s]", vu1RoundMode, s_round_modes[static_cast<u8>(vu1RoundMode)]);
 		}
 	}

@@ -501,13 +501,13 @@ void GameDatabaseSchema::GameEntry::applyGameFixes(Pcsx2Config& config, bool app
 		const int clampMode = enum_cast(eeClampMode);
 		if (applyAuto)
 		{
-			Console.WriteLn("(GameDB) Changing EE/FPU clamp mode [mode=%d]", clampMode);
+			Console.WriteLn("GameDB: Changing EE/FPU clamp mode [mode=%d]", clampMode);
 			config.Cpu.Recompiler.fpuOverflow = (clampMode >= 1);
 			config.Cpu.Recompiler.fpuExtraOverflow = (clampMode >= 2);
 			config.Cpu.Recompiler.fpuFullMode = (clampMode >= 3);
 		}
 		else
-			Console.Warning("[GameDB] Skipping changing EE/FPU clamp mode [mode=%d]", clampMode);
+			Console.Warning("GameDB: Skipping changing EE/FPU clamp mode [mode=%d]", clampMode);
 	}

 	if (vu0ClampMode != GameDatabaseSchema::ClampMode::Undefined)
@@ -515,13 +515,13 @@ void GameDatabaseSchema::GameEntry::applyGameFixes(Pcsx2Config& config, bool app
 		const int clampMode = enum_cast(vu0ClampMode);
 		if (applyAuto)
 		{
-			Console.WriteLn("(GameDB) Changing VU0 clamp mode [mode=%d]", clampMode);
+			Console.WriteLn("GameDB: Changing VU0 clamp mode [mode=%d]", clampMode);
 			config.Cpu.Recompiler.vu0Overflow = (clampMode >= 1);
 			config.Cpu.Recompiler.vu0ExtraOverflow = (clampMode >= 2);
 			config.Cpu.Recompiler.vu0SignOverflow = (clampMode >= 3);
 		}
 		else
-			Console.Warning("[GameDB] Skipping changing VU0 clamp mode [mode=%d]", clampMode);
+			Console.Warning("GameDB: Skipping changing VU0 clamp mode [mode=%d]", clampMode);
 	}

 	if (vu1ClampMode != GameDatabaseSchema::ClampMode::Undefined)
@@ -529,13 +529,13 @@ void GameDatabaseSchema::GameEntry::applyGameFixes(Pcsx2Config& config, bool app
 		const int clampMode = enum_cast(vu1ClampMode);
 		if (applyAuto)
 		{
-			Console.WriteLn("(GameDB) Changing VU1 clamp mode [mode=%d]", clampMode);
+			Console.WriteLn("GameDB: Changing VU1 clamp mode [mode=%d]", clampMode);
 			config.Cpu.Recompiler.vu1Overflow = (clampMode >= 1);
 			config.Cpu.Recompiler.vu1ExtraOverflow = (clampMode >= 2);
 			config.Cpu.Recompiler.vu1SignOverflow = (clampMode >= 3);
 		}
 		else
-			Console.Warning("[GameDB] Skipping changing VU1 clamp mode [mode=%d]", clampMode);
+			Console.Warning("GameDB: Skipping changing VU1 clamp mode [mode=%d]", clampMode);
 	}

 	// TODO - config - this could be simplified with maps instead of bitfields and enums
@@ -543,14 +543,14 @@ void GameDatabaseSchema::GameEntry::applyGameFixes(Pcsx2Config& config, bool app
 	{
 		if (!applyAuto)
 		{
-			Console.Warning("[GameDB] Skipping setting Speedhack '%s' to [mode=%d]",
+			Console.Warning("GameDB: Skipping setting Speedhack '%s' to [mode=%d]",
 				Pcsx2Config::SpeedhackOptions::GetSpeedHackName(it.first), it.second);
 			continue;
 		}
 		// Legacy note - speedhacks are setup in the GameDB as integer values, but
 		// are effectively booleans like the gamefixes
 		config.Speedhacks.Set(it.first, it.second);
-		Console.WriteLn("(GameDB) Setting Speedhack '%s' to [mode=%d]",
+		Console.WriteLn("GameDB: Setting Speedhack '%s' to [mode=%d]",
 			Pcsx2Config::SpeedhackOptions::GetSpeedHackName(it.first), it.second);
 	}

@@ -559,12 +559,12 @@ void GameDatabaseSchema::GameEntry::applyGameFixes(Pcsx2Config& config, bool app
 	{
 		if (!applyAuto)
 		{
-			Console.Warning("[GameDB] Skipping Gamefix: %s", Pcsx2Config::GamefixOptions::GetGameFixName(id));
+			Console.Warning("GameDB: Skipping Gamefix: %s", Pcsx2Config::GamefixOptions::GetGameFixName(id));
 			continue;
 		}
 		// if the fix is present, it is said to be enabled
 		config.Gamefixes.Set(id, true);
-		Console.WriteLn("(GameDB) Enabled Gamefix: %s", Pcsx2Config::GamefixOptions::GetGameFixName(id));
+		Console.WriteLn("GameDB: Enabled Gamefix: %s", Pcsx2Config::GamefixOptions::GetGameFixName(id));

 		// The LUT is only used for 1 game so we allocate it only when the gamefix is enabled (save 4MB)
 		if (id == Fix_GoemonTlbMiss && true)
@@ -694,7 +694,7 @@ void GameDatabaseSchema::GameEntry::applyGSHardwareFixes(Pcsx2Config::GSOptions&
 	const bool apply_auto_fixes = !config.ManualUserHacks;
 	const bool is_sw_renderer = EmuConfig.GS.Renderer == GSRendererType::SW;
 	if (!apply_auto_fixes)
-		Console.Warning("[GameDB] Manual GS hardware renderer fixes are enabled, not using automatic hardware renderer fixes from GameDB.");
+		Console.Warning("GameDB: Manual GS hardware renderer fixes are enabled, not using automatic hardware renderer fixes from GameDB.");

 	for (const auto& [id, value] : gsHWFixes)
 	{
@@ -703,7 +703,7 @@ void GameDatabaseSchema::GameEntry::applyGSHardwareFixes(Pcsx2Config::GSOptions&
 			if (configMatchesHWFix(config, id, value))
 				continue;

-			Console.Warning("[GameDB] Skipping GS Hardware Fix: %s to [mode=%d]", getHWFixName(id), value);
+			Console.Warning("GameDB: Skipping GS Hardware Fix: %s to [mode=%d]", getHWFixName(id), value);
 			fmt::format_to(std::back_inserter(disabled_fixes), "{} {} = {}", disabled_fixes.empty() ? "  " : "\n  ", getHWFixName(id), value);
 			continue;
 		}
@@ -790,7 +790,7 @@ void GameDatabaseSchema::GameEntry::applyGSHardwareFixes(Pcsx2Config::GSOptions&
 					if (config.TriFilter == TriFiltering::Automatic)
 						config.TriFilter = static_cast<TriFiltering>(value);
 					else if (config.TriFilter > TriFiltering::Off)
-						Console.Warning("[GameDB] Game requires trilinear filtering to be disabled.");
+						Console.Warning("GameDB: Game requires trilinear filtering to be disabled.");
 				}
 			}
 			break;
@@ -832,7 +832,7 @@ void GameDatabaseSchema::GameEntry::applyGSHardwareFixes(Pcsx2Config::GSOptions&
 					if (config.InterlaceMode == GSInterlaceMode::Automatic)
 						config.InterlaceMode = static_cast<GSInterlaceMode>(value);
 					else
-						Console.Warning("[GameDB] Game requires different deinterlace mode but it has been overridden by user setting.");
+						Console.Warning("GameDB: Game requires different deinterlace mode but it has been overridden by user setting.");
 				}
 			}
 			break;
@@ -919,7 +919,7 @@ void GameDatabaseSchema::GameEntry::applyGSHardwareFixes(Pcsx2Config::GSOptions&
 				break;
 		}

-		Console.WriteLn("[GameDB] Enabled GS Hardware Fix: %s to [mode=%d]", getHWFixName(id), value);
+		Console.WriteLn("GameDB: Enabled GS Hardware Fix: %s to [mode=%d]", getHWFixName(id), value);
 	}

 	// fixup skipdraw range just in case the db has a bad range (but the linter should catch this)
@@ -954,7 +954,7 @@ void GameDatabase::initDatabase()
 	auto buf = FileSystem::ReadFileToString(Path::Combine(EmuFolders::Resources, GAMEDB_YAML_FILE_NAME).c_str());
 	if (!buf.has_value())
 	{
-		Console.Error("[GameDB] Unable to open GameDB file, file does not exist.");
+		Console.Error("GameDB: Unable to open GameDB file, file does not exist.");
 		return;
 	}

@@ -971,7 +971,7 @@ void GameDatabase::initDatabase()
 		// However, YAML's keys are as expected case-sensitive, so we have to explicitly do our own duplicate checking
 		if (s_game_db.count(serial) == 1)
 		{
-			Console.Error(fmt::format("[GameDB] Duplicate serial '{}' found in GameDB. Skipping, Serials are case-insensitive!", serial));
+			Console.Error(fmt::format("GameDB: Duplicate serial '{}' found in GameDB. Skipping, Serials are case-insensitive!", serial));
 			continue;
 		}

@@ -988,9 +988,9 @@ void GameDatabase::ensureLoaded()
 {
 	std::call_once(s_load_once_flag, []() {
 		Common::Timer timer;
-		Console.WriteLn(fmt::format("[GameDB] Has not been initialized yet, initializing..."));
+		Console.WriteLn(fmt::format("GameDB: Has not been initialized yet, initializing..."));
 		initDatabase();
-		Console.WriteLn("[GameDB] %zu games on record (loaded in %.2fms)", s_game_db.size(), timer.GetTimeMilliseconds());
+		Console.WriteLn("GameDB: %zu games on record (loaded in %.2fms)", s_game_db.size(), timer.GetTimeMilliseconds());
 	});
 }

@@ -1115,7 +1115,7 @@ bool GameDatabase::loadHashDatabase()
 	auto buf = FileSystem::ReadFileToString(Path::Combine(EmuFolders::Resources, HASHDB_YAML_FILE_NAME).c_str());
 	if (!buf.has_value())
 	{
-		Console.Error("[GameDB] Unable to open hash database file, file does not exist.");
+		Console.Error("GameDB: Unable to open hash database file, file does not exist.");
 		return false;
 	}

--- a/pcsx2/ImGui/FullscreenUI.cpp
+++ b/pcsx2/ImGui/FullscreenUI.cpp
@@ -3705,6 +3705,15 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 		"EmuCore/GS", "StretchY", 100, 10, 300, FSUI_CSTR("%d%%"));
 	DrawIntRectSetting(bsi, FSUI_CSTR("Crop"), FSUI_CSTR("Crops the image, while respecting aspect ratio."), "EmuCore/GS", "CropLeft", 0,
 		"CropTop", 0, "CropRight", 0, "CropBottom", 0, 0, 720, 1, FSUI_CSTR("%dpx"));
+
+	if (!IsEditingGameSettings(bsi))
+	{
+		DrawToggleSetting(bsi, FSUI_CSTR("Enable Widescreen Patches"), FSUI_CSTR("Enables loading widescreen patches from pnach files."),
+			"EmuCore", "EnableWideScreenPatches", false);
+		DrawToggleSetting(bsi, FSUI_CSTR("Enable No-Interlacing Patches"),
+			FSUI_CSTR("Enables loading no-interlacing patches from pnach files."), "EmuCore", "EnableNoInterlacingPatches", false);
+	}
+
 	DrawIntListSetting(bsi, FSUI_CSTR("Bilinear Upscaling"), FSUI_CSTR("Smooths out the image when upscaling the console to the screen."),
 		"EmuCore/GS", "linear_present_mode", static_cast<int>(GSPostBilinearMode::BilinearSharp), s_bilinear_present_options,
 		std::size(s_bilinear_present_options), true);
@@ -7050,6 +7059,10 @@ TRANSLATE_NOOP("FullscreenUI", "Increases or decreases the virtual picture size
 TRANSLATE_NOOP("FullscreenUI", "Crop");
 TRANSLATE_NOOP("FullscreenUI", "Crops the image, while respecting aspect ratio.");
 TRANSLATE_NOOP("FullscreenUI", "%dpx");
+TRANSLATE_NOOP("FullscreenUI", "Enable Widescreen Patches");
+TRANSLATE_NOOP("FullscreenUI", "Enables loading widescreen patches from pnach files.");
+TRANSLATE_NOOP("FullscreenUI", "Enable No-Interlacing Patches");
+TRANSLATE_NOOP("FullscreenUI", "Enables loading no-interlacing patches from pnach files.");
 TRANSLATE_NOOP("FullscreenUI", "Bilinear Upscaling");
 TRANSLATE_NOOP("FullscreenUI", "Smooths out the image when upscaling the console to the screen.");
 TRANSLATE_NOOP("FullscreenUI", "Integer Upscaling");
--- a/pcsx2/ImGui/ImGuiOverlays.cpp
+++ b/pcsx2/ImGui/ImGuiOverlays.cpp
@@ -397,9 +397,10 @@ __ri void ImGuiManager::DrawSettingsOverlay(float scale, float margin, float spa
 		EmuConfig.Cpu.Recompiler.GetEEClampMode(), static_cast<unsigned>(EmuConfig.Cpu.VU0FPCR.GetRoundMode()),
 		EmuConfig.Cpu.Recompiler.GetVUClampMode(), EmuConfig.GS.VsyncQueueSize);

-	if (EmuConfig.EnableCheats)
+	if (EmuConfig.EnableCheats || EmuConfig.EnableWideScreenPatches || EmuConfig.EnableNoInterlacingPatches)
 	{
-		APPEND("CHT ");
+		APPEND("C={}{}{} ", EmuConfig.EnableCheats ? "C" : "", EmuConfig.EnableWideScreenPatches ? "W" : "",
+			EmuConfig.EnableNoInterlacingPatches ? "N" : "");
 	}

 	if (GSIsHardwareRenderer())
--- a/pcsx2/Input/SDLInputSource.cpp
+++ b/pcsx2/Input/SDLInputSource.cpp
@@ -540,14 +540,14 @@ bool SDLInputSource::ProcessSDLEvent(const SDL_Event* event)
 	{
 		case SDL_CONTROLLERDEVICEADDED:
 		{
-			Console.WriteLn("(SDLInputSource) Controller %d inserted", event->cdevice.which);
+			Console.WriteLn("SDLInputSource: Controller %d inserted", event->cdevice.which);
 			OpenDevice(event->cdevice.which, true);
 			return true;
 		}

 		case SDL_CONTROLLERDEVICEREMOVED:
 		{
-			Console.WriteLn("(SDLInputSource) Controller %d removed", event->cdevice.which);
+			Console.WriteLn("SDLInputSource: Controller %d removed", event->cdevice.which);
 			CloseDevice(event->cdevice.which);
 			return true;
 		}
@@ -558,7 +558,7 @@ bool SDLInputSource::ProcessSDLEvent(const SDL_Event* event)
 			if (SDL_IsGameController(event->jdevice.which))
 				return false;

-			Console.WriteLn("(SDLInputSource) Joystick %d inserted", event->jdevice.which);
+			Console.WriteLn("SDLInputSource: Joystick %d inserted", event->jdevice.which);
 			OpenDevice(event->cdevice.which, false);
 			return true;
 		}
@@ -569,7 +569,7 @@ bool SDLInputSource::ProcessSDLEvent(const SDL_Event* event)
 			if (auto it = GetControllerDataForJoystickId(event->cdevice.which); it != m_controllers.end() && it->game_controller)
 				return false;

-			Console.WriteLn("(SDLInputSource) Joystick %d removed", event->jdevice.which);
+			Console.WriteLn("SDLInputSource: Joystick %d removed", event->jdevice.which);
 			CloseDevice(event->cdevice.which);
 			return true;
 		}
@@ -657,7 +657,7 @@ bool SDLInputSource::OpenDevice(int index, bool is_gamecontroller)

 	if (!gcontroller && !joystick)
 	{
-		ERROR_LOG("(SDLInputSource) Failed to open controller {}", index);
+		ERROR_LOG("SDLInputSource: Failed to open controller {}", index);
 		return false;
 	}

@@ -667,7 +667,7 @@ bool SDLInputSource::OpenDevice(int index, bool is_gamecontroller)
 	{
 		if (it->joystick_id == joystick_id)
 		{
-			ERROR_LOG("(SDLInputSource) Controller {}, instance {}, player {} already connected, ignoring.", index, joystick_id, player_id);
+			ERROR_LOG("SDLInputSource: Controller {}, instance {}, player {} already connected, ignoring.", index, joystick_id, player_id);
 			if (gcontroller)
 				SDL_GameControllerClose(gcontroller);
 			else
@@ -680,7 +680,7 @@ bool SDLInputSource::OpenDevice(int index, bool is_gamecontroller)
 	if (player_id < 0 || GetControllerDataForPlayerId(player_id) != m_controllers.end())
 	{
 		const int free_player_id = GetFreePlayerId();
-		WARNING_LOG("(SDLInputSource) Controller {} (joystick {}) returned player ID {}, which is invalid or in "
+		WARNING_LOG("SDLInputSource: Controller {} (joystick {}) returned player ID {}, which is invalid or in "
 					"use. Using ID {} instead.",
 			index, joystick_id, player_id, free_player_id);
 		player_id = free_player_id;
@@ -690,7 +690,7 @@ bool SDLInputSource::OpenDevice(int index, bool is_gamecontroller)
 	if (!name)
 		name = "Unknown Device";

-	INFO_LOG("(SDLInputSource) Opened {} {} (instance id {}, player id {}): {}", is_gamecontroller ? "game controller" : "joystick",
+	INFO_LOG("SDLInputSource: Opened {} {} (instance id {}, player id {}): {}", is_gamecontroller ? "game controller" : "joystick",
 		index, joystick_id, player_id, name);

 	ControllerData cd = {};
@@ -717,7 +717,7 @@ bool SDLInputSource::OpenDevice(int index, bool is_gamecontroller)
 		for (size_t i = 0; i < std::size(s_sdl_button_names); i++)
 			mark_bind(SDL_GameControllerGetBindForButton(gcontroller, static_cast<SDL_GameControllerButton>(i)));

-		INFO_LOG("(SDLInputSource) Controller {} has {} axes and {} buttons", player_id, num_axes, num_buttons);
+		INFO_LOG("SDLInputSource: Controller {} has {} axes and {} buttons", player_id, num_axes, num_buttons);
 	}
 	else
 	{
@@ -726,14 +726,14 @@ bool SDLInputSource::OpenDevice(int index, bool is_gamecontroller)
 		if (num_hats > 0)
 			cd.last_hat_state.resize(static_cast<size_t>(num_hats), u8(0));

-		INFO_LOG("(SDLInputSource) Joystick {} has {} axes, {} buttons and {} hats", player_id,
+		INFO_LOG("SDLInputSource: Joystick {} has {} axes, {} buttons and {} hats", player_id,
 			SDL_JoystickNumAxes(joystick), SDL_JoystickNumButtons(joystick), num_hats);
 	}

 	cd.use_game_controller_rumble = (gcontroller && SDL_GameControllerRumble(gcontroller, 0, 0, 0) == 0);
 	if (cd.use_game_controller_rumble)
 	{
-		INFO_LOG("(SDLInputSource) Rumble is supported on '{}' via gamecontroller", name);
+		INFO_LOG("SDLInputSource: Rumble is supported on '{}' via gamecontroller", name);
 	}
 	else
 	{
@@ -752,25 +752,25 @@ bool SDLInputSource::OpenDevice(int index, bool is_gamecontroller)
 			}
 			else
 			{
-				ERROR_LOG("(SDLInputSource) Failed to create haptic left/right effect: {}", SDL_GetError());
+				ERROR_LOG("SDLInputSource: Failed to create haptic left/right effect: {}", SDL_GetError());
 				if (SDL_HapticRumbleSupported(haptic) && SDL_HapticRumbleInit(haptic) != 0)
 				{
 					cd.haptic = haptic;
 				}
 				else
 				{
-					ERROR_LOG("(SDLInputSource) No haptic rumble supported: {}", SDL_GetError());
+					ERROR_LOG("SDLInputSource: No haptic rumble supported: {}", SDL_GetError());
 					SDL_HapticClose(haptic);
 				}
 			}
 		}

 		if (cd.haptic)
-			INFO_LOG("(SDLInputSource) Rumble is supported on '{}' via haptic", name);
+			INFO_LOG("SDLInputSource: Rumble is supported on '{}' via haptic", name);
 	}

 	if (!cd.haptic && !cd.use_game_controller_rumble)
-		WARNING_LOG("(SDLInputSource) Rumble is not supported on '{}'", name);
+		WARNING_LOG("SDLInputSource: Rumble is not supported on '{}'", name);

 	if (player_id >= 0 && static_cast<u32>(player_id) < MAX_LED_COLORS && gcontroller && SDL_GameControllerHasLED(gcontroller))
 	{
--- a/pcsx2/Patch.cpp
+++ b/pcsx2/Patch.cpp
@@ -163,11 +163,15 @@ namespace Patch
 	static void writeCheat();
 	static void handle_extended_t(const PatchCommand* p);

+	// Name of patches which will be auto-enabled based on global options.
+	static constexpr std::string_view WS_PATCH_NAME = "Widescreen 16:9";
+	static constexpr std::string_view NI_PATCH_NAME = "No-Interlacing";
 	static constexpr std::string_view PATCHES_ZIP_NAME = "patches.zip";

 	const char* PATCHES_CONFIG_SECTION = "Patches";
 	const char* CHEATS_CONFIG_SECTION = "Cheats";
 	const char* PATCH_ENABLE_CONFIG_KEY = "Enable";
+	const char* PATCH_DISABLE_CONFIG_KEY = "Disable";

 	static zip_t* s_patches_zip;
 	static PatchList s_gamedb_patches;
@@ -585,6 +589,38 @@ void Patch::ReloadEnabledLists()
 		s_enabled_cheats = {};

 	s_enabled_patches = Host::GetStringListSetting(PATCHES_CONFIG_SECTION, PATCH_ENABLE_CONFIG_KEY);
+
+	const EnablePatchList disabled_patches = Host::GetStringListSetting(PATCHES_CONFIG_SECTION, PATCH_DISABLE_CONFIG_KEY);
+
+	// Name based matching for widescreen/NI settings.
+	if (EmuConfig.EnableWideScreenPatches)
+	{
+		if (std::none_of(s_enabled_patches.begin(), s_enabled_patches.end(),
+				[](const std::string& it) { return (it == WS_PATCH_NAME); }))
+		{
+			s_enabled_patches.emplace_back(WS_PATCH_NAME);
+		}
+	}
+	if (EmuConfig.EnableNoInterlacingPatches)
+	{
+		if (std::none_of(s_enabled_patches.begin(), s_enabled_patches.end(),
+				[](const std::string& it) { return (it == NI_PATCH_NAME); }))
+		{
+			s_enabled_patches.emplace_back(NI_PATCH_NAME);
+		}
+	}
+
+	for (auto it = s_enabled_patches.begin(); it != s_enabled_patches.end();)
+	{
+		if (std::find(disabled_patches.begin(), disabled_patches.end(), *it) != disabled_patches.end())
+		{
+			it = s_enabled_patches.erase(it);
+		}
+		else
+		{
+			++it;
+		}
+	}
 }

 u32 Patch::EnablePatches(const PatchList& patches, const EnablePatchList& enable_list)
@@ -1006,6 +1042,11 @@ void Patch::ApplyLoadedPatches(patch_place_type place)
 	}
 }

+bool Patch::IsGloballyToggleablePatch(const PatchInfo& patch_info)
+{
+	return patch_info.name == WS_PATCH_NAME || patch_info.name == NI_PATCH_NAME;
+}
+
 void Patch::ApplyDynamicPatches(u32 pc)
 {
 	for (const auto& dynpatch : s_active_pnach_dynamic_patches)
--- a/pcsx2/Patch.h
+++ b/pcsx2/Patch.h
@@ -78,6 +78,7 @@ namespace Patch
 	extern const char* PATCHES_CONFIG_SECTION;
 	extern const char* CHEATS_CONFIG_SECTION;
 	extern const char* PATCH_ENABLE_CONFIG_KEY;
+	extern const char* PATCH_DISABLE_CONFIG_KEY;

 	extern PatchInfoList GetPatchInfo(const std::string_view serial, u32 crc, bool cheats, bool showAllCRCS, u32* num_unlabelled_patches);

@@ -103,4 +104,6 @@ namespace Patch
 	// and then it loads only the ones which are enabled according to the current config
 	// (this happens at AppCoreThread::ApplySettings(...) )
 	extern void ApplyLoadedPatches(patch_place_type place);
+
+	extern bool IsGloballyToggleablePatch(const PatchInfo& patch_info);
 } // namespace Patch
--- a/pcsx2/Pcsx2Config.cpp
+++ b/pcsx2/Pcsx2Config.cpp
@@ -1922,6 +1922,8 @@ void Pcsx2Config::LoadSaveCore(SettingsWrapper& wrap)
 	SettingsWrapBitBool(EnablePatches);
 	SettingsWrapBitBool(EnableCheats);
 	SettingsWrapBitBool(EnablePINE);
+	SettingsWrapBitBool(EnableWideScreenPatches);
+	SettingsWrapBitBool(EnableNoInterlacingPatches);
 	SettingsWrapBitBool(EnableFastBoot);
 	SettingsWrapBitBool(EnableFastBootFastForward);
 	SettingsWrapBitBool(EnableThreadPinning);
--- a/pcsx2/R3000AInterpreter.cpp
+++ b/pcsx2/R3000AInterpreter.cpp
@@ -237,7 +237,7 @@ static void doBranch(s32 tar) {
 	// This detects when SYSMEM is called and clears the modules then
 	if(tar == 0x890)
 	{
-		DevCon.WriteLn(Color_Gray, "[R3000 Debugger] Branch to 0x890 (SYSMEM). Clearing modules.");
+		DevCon.WriteLn(Color_Gray, "R3000 Debugger: Branch to 0x890 (SYSMEM). Clearing modules.");
 		R3000SymbolGuardian.ClearIrxModules();
 	}

--- a/pcsx2/SIO/Memcard/MemoryCardFolder.cpp
+++ b/pcsx2/SIO/Memcard/MemoryCardFolder.cpp
@@ -260,11 +260,11 @@ void FolderMemoryCard::LoadMemoryCardData(const u32 sizeInClusters, const bool e
 	{
 		if (enableFiltering)
 		{
-			Console.WriteLn(Color_Green, "(FolderMcd) Indexing slot %u with filter \"%s\".", m_slot, filter.c_str());
+			Console.WriteLn(Color_Green, "FolderMcd: Indexing slot %u with filter \"%s\".", m_slot, filter.c_str());
 		}
 		else
 		{
-			Console.WriteLn(Color_Green, "(FolderMcd) Indexing slot %u without filter.", m_slot);
+			Console.WriteLn(Color_Green, "FolderMcd: Indexing slot %u without filter.", m_slot);
 		}

 		CreateFat();
@@ -636,7 +636,7 @@ bool FolderMemoryCard::AddFile(MemoryCardFileEntry* const dirEntry, const std::s
 	}
 	else
 	{
-		Console.WriteLn("(FolderMcd) Could not open file: %s", relativeFilePath.c_str());
+		Console.WriteLn("FolderMcd: Could not open file: %s", relativeFilePath.c_str());
 		return false;
 	}
 }
@@ -1082,7 +1082,7 @@ void FolderMemoryCard::Flush()
 	WriteToFile(m_folderName.GetFullPath().RemoveLast() + L"-debug_" + wxDateTime::Now().Format(L"%Y-%m-%d-%H-%M-%S") + L"_pre-flush.ps2");
 #endif

-	Console.WriteLn("(FolderMcd) Writing data for slot %u to file system...", m_slot);
+	Console.WriteLn("FolderMcd: Writing data for slot %u to file system...", m_slot);
 	Common::Timer timeFlushStart;

 	// Keep a copy of the old file entries so we can figure out which files and directories, if any, have been deleted from the memory card.
@@ -1104,7 +1104,7 @@ void FolderMemoryCard::Flush()
 	FlushBlock(m_superBlock.data.backup_block2);
 	if (m_backupBlock2.programmedBlock != 0xFFFFFFFFu)
 	{
-		Console.Warning("(FolderMcd) Aborting flush of slot %u, emulation was interrupted during save process!", m_slot);
+		Console.Warning("FolderMcd: Aborting flush of slot %u, emulation was interrupted during save process!", m_slot);
 		return;
 	}

@@ -1150,7 +1150,7 @@ void FolderMemoryCard::Flush()
 	m_lastAccessedFile.ClearMetadataWriteState();
 	m_oldDataCache.clear();

-	Console.WriteLn("(FolderMcd) Done! Took %.2f ms.", timeFlushStart.GetTimeMilliseconds());
+	Console.WriteLn("FolderMcd: Done! Took %.2f ms.", timeFlushStart.GetTimeMilliseconds());

 #ifdef DEBUG_WRITE_FOLDER_CARD_IN_MEMORY_TO_FILE_ON_CHANGE
 	WriteToFile(m_folderName.GetFullPath().RemoveLast() + L"-debug_" + wxDateTime::Now().Format(L"%Y-%m-%d-%H-%M-%S") + L"_post-flush.ps2");
@@ -1763,7 +1763,7 @@ std::string FolderMemoryCard::GetDisabledMessage(uint slot) const

 std::string FolderMemoryCard::GetCardFullMessage(const std::string& filePath) const
 {
-	return fmt::format("(FolderMcd) Memory Card is full, could not add: {}", filePath);
+	return fmt::format("FolderMcd: Memory Card is full, could not add: {}", filePath);
 }

 std::vector<FolderMemoryCard::EnumeratedFileEntry> FolderMemoryCard::GetOrderedFiles(const std::string& dirPath) const
--- a/pcsx2/SIO/Pad/PadDualshock2.cpp
+++ b/pcsx2/SIO/Pad/PadDualshock2.cpp
@@ -145,7 +145,7 @@ void PadDualshock2::ConfigLog()
 	// VS: Vibration Small (how is the small vibration motor mapped)
 	// VL: Vibration Large (how is the large vibration motor mapped)
 	// RB: Response Bytes (what data is included in the controller's responses - D = Digital, A = Analog, P = Pressure)
-	Console.WriteLn(fmt::format("[Pad] DS2 Config Finished - P{0}/S{1} - AL: {2} - AB: {3} - VS: {4} - VL: {5} - RB: {6} (0x{7:08X})",
+	Console.WriteLn(fmt::format("Pad: DS2 Config Finished - P{0}/S{1} - AL: {2} - AB: {3} - VS: {4} - VL: {5} - RB: {6} (0x{7:08X})",
 		port + 1,
 		slot + 1,
 		(this->analogLight ? "On" : "Off"),
--- a/pcsx2/SIO/Pad/PadGuitar.cpp
+++ b/pcsx2/SIO/Pad/PadGuitar.cpp
@@ -47,7 +47,7 @@ void PadGuitar::ConfigLog()

 	// AL: Analog Light (is it turned on right now)
 	// AB: Analog Button (is it useable or is it locked in its current state)
-	Console.WriteLn(fmt::format("[Pad] Guitar Config Finished - P{0}/S{1} - AL: {2} - AB: {3}",
+	Console.WriteLn(fmt::format("Pad: Guitar Config Finished - P{0}/S{1} - AL: {2} - AB: {3}",
 		port + 1,
 		slot + 1,
 		(this->analogLight ? "On" : "Off"),
--- a/pcsx2/SIO/Pad/PadJogcon.cpp
+++ b/pcsx2/SIO/Pad/PadJogcon.cpp
@@ -53,7 +53,7 @@ void PadJogcon::ConfigLog()

 	// AL: Analog Light (is it turned on right now)
 	// AB: Analog Button (is it useable or is it locked in its current state)
-	Console.WriteLn(fmt::format("[Pad] Jogcon Config Finished - P{0}/S{1} - AL: {2} - AB: {3}",
+	Console.WriteLn(fmt::format("Pad: Jogcon Config Finished - P{0}/S{1} - AL: {2} - AB: {3}",
 		port + 1,
 		slot + 1,
 		(this->analogLight ? "On" : "Off"),
--- a/pcsx2/SIO/Pad/PadNegcon.cpp
+++ b/pcsx2/SIO/Pad/PadNegcon.cpp
@@ -50,7 +50,7 @@ void PadNegcon::ConfigLog()

 	// AL: Analog Light (is it turned on right now)
 	// AB: Analog Button (is it useable or is it locked in its current state)
-	Console.WriteLn(fmt::format("[Pad] Negcon Config Finished - P{0}/S{1} - AL: {2} - AB: {3}",
+	Console.WriteLn(fmt::format("Pad: Negcon Config Finished - P{0}/S{1} - AL: {2} - AB: {3}",
 		port + 1,
 		slot + 1,
 		(this->analogLight ? "On" : "Off"),
--- a/pcsx2/SIO/Pad/PadPopn.cpp
+++ b/pcsx2/SIO/Pad/PadPopn.cpp
@@ -56,7 +56,7 @@ void PadPopn::ConfigLog()
 	// AL: Analog Light (is it turned on right now)
 	// AB: Analog Button (is it useable or is it locked in its current state)
 	// RB: Response Bytes (what data is included in the controller's responses - D = Digital, A = Analog, P = Pressure)
-	Console.WriteLn(fmt::format("[Pad] Pop'n Config Finished - P{0}/S{1} - AL: {2} - AB: {3} - RB: {4} (0x{5:08X})",
+	Console.WriteLn(fmt::format("Pad: Pop'n Config Finished - P{0}/S{1} - AL: {2} - AB: {3} - RB: {4} (0x{5:08X})",
 		port + 1,
 		slot + 1,
 		(this->analogLight ? "On" : "Off"),
--- a/pcsx2/VMManager.cpp
+++ b/pcsx2/VMManager.cpp
@@ -415,6 +415,10 @@ bool VMManager::Internal::CPUThreadInitialize()
 	if (EmuConfig.EnableDiscordPresence)
 		InitializeDiscordPresence();

+	// Check for advanced settings status and warn the user if its enabled
+	if (Host::GetBaseBoolSettingValue("UI", "ShowAdvancedSettings", false))
+		Console.Warning("Settings: Advanced Settings are enabled; only proceed if you know what you're doing! No support will be provided if you have the option enabled.");
+
 	return true;
 }

@@ -2887,6 +2891,8 @@ void VMManager::CheckForEmulationSpeedConfigChanges(const Pcsx2Config& old_confi
 void VMManager::CheckForPatchConfigChanges(const Pcsx2Config& old_config)
 {
 	if (EmuConfig.EnableCheats == old_config.EnableCheats &&
+		EmuConfig.EnableWideScreenPatches == old_config.EnableWideScreenPatches &&
+		EmuConfig.EnableNoInterlacingPatches == old_config.EnableNoInterlacingPatches &&
 		EmuConfig.EnablePatches == old_config.EnablePatches)
 	{
 		return;
--- a/pcsx2/x86/iR3000A.cpp
+++ b/pcsx2/x86/iR3000A.cpp
@@ -1543,7 +1543,7 @@ static void iopRecRecompile(const u32 startpc)
 	// This detects when SYSMEM is called and clears the modules then
 	if(startpc == 0x890)
 	{
-		DevCon.WriteLn(Color_Gray, "[R3000 Debugger] Branch to 0x890 (SYSMEM). Clearing modules.");
+		DevCon.WriteLn(Color_Gray, "R3000 Debugger: Branch to 0x890 (SYSMEM). Clearing modules.");
 		R3000SymbolGuardian.ClearIrxModules();
 	}
Author	SHA1	Message	Date
Jordan	575ec07553	3rdparty: Update xxHash to v0.8.3 (#12137 )	2024-12-31 18:14:47 -05:00
lightningterror	18308b6525	GS/GL: Properly name logs with GL prefix.	2024-12-31 20:11:25 +01:00
lightningterror	d52f29dcd7	GS/D3D12: Properly name logs with D3D12 prefix.	2024-12-31 20:11:25 +01:00
lightningterror	288d8047ae	GS/VK: Properly name logs with VK prefix.	2024-12-31 20:11:25 +01:00
lightningterror	26b232292c	GS/D3D11: Properly name logs with D3D11 prefix.	2024-12-31 20:11:25 +01:00
Tyler Wilding	1fff69b0aa	translations: Syncing Crowdin translations (#12141 ) * New translations pcsx2-qt_en.ts (Romanian) [ci skip] * New translations pcsx2-qt_en.ts (French) [ci skip] * New translations pcsx2-qt_en.ts (Spanish) [ci skip] * New translations pcsx2-qt_en.ts (Afrikaans) [ci skip] * New translations pcsx2-qt_en.ts (Arabic) [ci skip] * New translations pcsx2-qt_en.ts (Bulgarian) [ci skip] * New translations pcsx2-qt_en.ts (Catalan) [ci skip] * New translations pcsx2-qt_en.ts (Czech) [ci skip] * New translations pcsx2-qt_en.ts (Danish) [ci skip] * New translations pcsx2-qt_en.ts (German) [ci skip] * New translations pcsx2-qt_en.ts (Greek) [ci skip] * New translations pcsx2-qt_en.ts (Finnish) [ci skip] * New translations pcsx2-qt_en.ts (Hebrew) [ci skip] * New translations pcsx2-qt_en.ts (Hungarian) [ci skip] * New translations pcsx2-qt_en.ts (Italian) [ci skip] * New translations pcsx2-qt_en.ts (Japanese) [ci skip] * New translations pcsx2-qt_en.ts (Georgian) [ci skip] * New translations pcsx2-qt_en.ts (Korean) [ci skip] * New translations pcsx2-qt_en.ts (Lithuanian) [ci skip] * New translations pcsx2-qt_en.ts (Dutch) [ci skip] * New translations pcsx2-qt_en.ts (Norwegian) [ci skip] * New translations pcsx2-qt_en.ts (Polish) [ci skip] * New translations pcsx2-qt_en.ts (Portuguese) [ci skip] * New translations pcsx2-qt_en.ts (Russian) [ci skip] * New translations pcsx2-qt_en.ts (Serbian (Cyrillic)) [ci skip] * New translations pcsx2-qt_en.ts (Swedish) [ci skip] * New translations pcsx2-qt_en.ts (Turkish) [ci skip] * New translations pcsx2-qt_en.ts (Ukrainian) [ci skip] * New translations pcsx2-qt_en.ts (Chinese Simplified) [ci skip] * New translations pcsx2-qt_en.ts (Chinese Traditional) [ci skip] * New translations pcsx2-qt_en.ts (Vietnamese) [ci skip] * New translations pcsx2-qt_en.ts (Portuguese, Brazilian) [ci skip] * New translations pcsx2-qt_en.ts (Indonesian) [ci skip] * New translations pcsx2-qt_en.ts (Persian) [ci skip] * New translations pcsx2-qt_en.ts (Croatian) [ci skip] * New translations pcsx2-qt_en.ts (Latvian) [ci skip] * New translations pcsx2-qt_en.ts (Hindi) [ci skip] * New translations pcsx2-qt_en.ts (Quechua) [ci skip] * New translations pcsx2-qt_en.ts (Guarani) [ci skip] * New translations pcsx2-qt_en.ts (Spanish, Latin America) [ci skip]	2024-12-30 19:19:40 -05:00
PCSX2 Bot	4d347305b5	[ci skip] PAD: Update to latest controller database.	2024-12-30 17:03:52 +01:00
PCSX2 Bot	2fd6f8e4ac	[ci skip] Qt: Update Base Translation.	2024-12-29 19:02:05 -05:00
Silent	97f316eca7	Qt/Patches: Gracefully migrate old per-game widescreen/no-interlace toggles to Patches This old upgrade path telling users that the setting has been deprecated can now be changed to perform the upgrade seamlessly for the user, because the behaviour of the old per-game setting is identical to the new behaviour of the Patches tab.	2024-12-29 14:03:56 -05:00
Silent	f7ba355697	Qt/Patches: Make WS/NI patches tri-state in the Patches screen, so disabling them per-game is possible This solves a long-standing issue where globally enabled widescreen/no-interlace patches visually appeared as disabled on the patches list, but they were in fact enabled and could NOT be disabled per-game.	2024-12-29 14:03:56 -05:00
Silent	c334040a96	Partially revert "Qt/Patches: Get rid of the global WS/NI toggle" This reverts commit `cc9f7e723a`.	2024-12-29 14:03:56 -05:00
TheTechnician27	b01359e06f	Tools: Port refraction's bulk compression script to Python	2024-12-28 12:09:19 -05:00
PCSX2 Bot	905f9431a5	[ci skip] Qt: Update Base Translation.	2024-12-28 11:30:16 -05:00
KamFretoZ	424951e1bb	Logging: Adjust the formatting to be more consistent	2024-12-28 11:25:26 -05:00
KamFretoZ	2167d9e4f5	Settings/Log: Print advanced settings warning on the log Warns the user through the log if they have advanced options enabled.	2024-12-28 11:25:26 -05:00
rtavarez98	82a38a7124	changed indentation from tab to space	2024-12-28 11:22:50 -05:00
Rain	eb6a52c55c	replaced recursive_directory_iterator w/ FindFiles()	2024-12-28 11:22:50 -05:00
Rain	234b8f6abf	Added rename input profile function	2024-12-28 11:22:50 -05:00