GameDB: fix some names

GameDB: Fix&Add few Japanese Game Titles
[ci skip] Qt: Update Base Translation.
2026-01-31 01:15:24 +01:00 · 2025-01-02 21:19:35 +01:00 · 2024-12-31 21:14:13 -06:00 · 2025-01-01 01:27:00 +01:00 · 2024-12-31 18:14:47 -05:00 · 2024-12-31 20:11:25 +01:00
103 changed files with 141945 additions and 91287 deletions
--- a/.github/workflows/scripts/linux/appimage-qt.sh
+++ b/.github/workflows/scripts/linux/appimage-qt.sh
@@ -206,7 +206,7 @@ GIT_VERSION=$(git tag --points-at HEAD)

 if [[ "${GIT_VERSION}" == "" ]]; then
 	# In the odd event that we run this script before the release gets tagged.
-	GIT_VERSION=$(git describe --tags)
+	GIT_VERSION=$(git describe --tags || true)
 	if [[ "${GIT_VERSION}" == "" ]]; then
 		GIT_VERSION=$(git rev-parse HEAD)
 	fi
--- a/3rdparty/include/xxhash.h
+++ b/3rdparty/include/xxhash.h
--- a/3rdparty/libchdr/include/libchdr/cdrom.h
+++ b/3rdparty/libchdr/include/libchdr/cdrom.h
@@ -10,12 +10,10 @@

 #pragma once

-#ifdef __cplusplus
-extern "C" {
-#endif
+#ifndef __CDROM_H__
+#define __CDROM_H__

 #include <stdint.h>
-#include <stdbool.h>
 #include <libchdr/chdconfig.h>

 /***************************************************************************
@@ -49,15 +47,11 @@ enum

 enum
 {
-	CD_SUB_NONE = 0,            /* no subcode data stored */
-	CD_SUB_RAW_INTERLEAVED,     /* raw interleaved 96 bytes per sector */
-	CD_SUB_RAW,                 /* raw non-interleaved 96 bytes per sector */
+	CD_SUB_NORMAL = 0,          /* "cooked" 96 bytes per sector */
+	CD_SUB_RAW,                 /* raw uninterleaved 96 bytes per sector */
+	CD_SUB_NONE                 /* no subcode data stored */
 };

-const char* cdrom_get_subtype_string(uint32_t subtype);
-bool cdrom_parse_subtype_string(const char* typestring, uint32_t* subtype, uint32_t* subsize);
-
-
 #define CD_FLAG_GDROM   0x00000001  /* disc is a GD-ROM, all tracks should be stored with GD-ROM metadata */
 #define CD_FLAG_GDROMLE 0x00000002  /* legacy GD-ROM, with little-endian CDDA data */

@@ -87,10 +81,10 @@ static inline uint32_t lba_to_msf(uint32_t lba)
 {
 	uint8_t m, s, f;

-	m = (uint8_t)(lba / (60 * 75));
+	m = lba / (60 * 75);
 	lba -= m * (60 * 75);
-	s = (uint8_t)(lba / 75);
-	f = (uint8_t)(lba % 75);
+	s = lba / 75;
+	f = lba % 75;

 	return ((m / 10) << 20) | ((m % 10) << 16) |
 			((s / 10) << 12) | ((s % 10) <<  8) |
@@ -113,6 +107,4 @@ static inline uint32_t lba_to_msf_alt(int lba)
 	return ret;
 }

-#ifdef __cplusplus
-} // extern "C"
-#endif
+#endif  /* __CDROM_H__ */
--- a/3rdparty/libchdr/include/libchdr/chd.h
+++ b/3rdparty/libchdr/include/libchdr/chd.h
@@ -48,7 +48,6 @@ extern "C" {

 #include <libchdr/coretypes.h>
 #include <libchdr/chdconfig.h>
-#include <stdbool.h>

 /***************************************************************************

@@ -59,67 +58,67 @@ extern "C" {
    V1 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] UINT32 length;        // length of header (including tag and length fields)
-    [ 12] UINT32 version;       // drive format version
-    [ 16] UINT32 flags;         // flags (see below)
-    [ 20] UINT32 compression;   // compression type
-    [ 24] UINT32 hunksize;      // 512-byte sectors per hunk
-    [ 28] UINT32 totalhunks;    // total # of hunks represented
-    [ 32] UINT32 cylinders;     // number of cylinders on hard disk
-    [ 36] UINT32 heads;         // number of heads on hard disk
-    [ 40] UINT32 sectors;       // number of sectors on hard disk
-    [ 44] UINT8  md5[16];       // MD5 checksum of raw data
-    [ 60] UINT8  parentmd5[16]; // MD5 checksum of parent file
+    [  8] uint32_t length;        // length of header (including tag and length fields)
+    [ 12] uint32_t version;       // drive format version
+    [ 16] uint32_t flags;         // flags (see below)
+    [ 20] uint32_t compression;   // compression type
+    [ 24] uint32_t hunksize;      // 512-byte sectors per hunk
+    [ 28] uint32_t totalhunks;    // total # of hunks represented
+    [ 32] uint32_t cylinders;     // number of cylinders on hard disk
+    [ 36] uint32_t heads;         // number of heads on hard disk
+    [ 40] uint32_t sectors;       // number of sectors on hard disk
+    [ 44] uint8_t  md5[16];       // MD5 checksum of raw data
+    [ 60] uint8_t  parentmd5[16]; // MD5 checksum of parent file
    [ 76] (V1 header length)

    V2 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] UINT32 length;        // length of header (including tag and length fields)
-    [ 12] UINT32 version;       // drive format version
-    [ 16] UINT32 flags;         // flags (see below)
-    [ 20] UINT32 compression;   // compression type
-    [ 24] UINT32 hunksize;      // seclen-byte sectors per hunk
-    [ 28] UINT32 totalhunks;    // total # of hunks represented
-    [ 32] UINT32 cylinders;     // number of cylinders on hard disk
-    [ 36] UINT32 heads;         // number of heads on hard disk
-    [ 40] UINT32 sectors;       // number of sectors on hard disk
-    [ 44] UINT8  md5[16];       // MD5 checksum of raw data
-    [ 60] UINT8  parentmd5[16]; // MD5 checksum of parent file
-    [ 76] UINT32 seclen;        // number of bytes per sector
+    [  8] uint32_t length;        // length of header (including tag and length fields)
+    [ 12] uint32_t version;       // drive format version
+    [ 16] uint32_t flags;         // flags (see below)
+    [ 20] uint32_t compression;   // compression type
+    [ 24] uint32_t hunksize;      // seclen-byte sectors per hunk
+    [ 28] uint32_t totalhunks;    // total # of hunks represented
+    [ 32] uint32_t cylinders;     // number of cylinders on hard disk
+    [ 36] uint32_t heads;         // number of heads on hard disk
+    [ 40] uint32_t sectors;       // number of sectors on hard disk
+    [ 44] uint8_t  md5[16];       // MD5 checksum of raw data
+    [ 60] uint8_t  parentmd5[16]; // MD5 checksum of parent file
+    [ 76] uint32_t seclen;        // number of bytes per sector
    [ 80] (V2 header length)

    V3 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] UINT32 length;        // length of header (including tag and length fields)
-    [ 12] UINT32 version;       // drive format version
-    [ 16] UINT32 flags;         // flags (see below)
-    [ 20] UINT32 compression;   // compression type
-    [ 24] UINT32 totalhunks;    // total # of hunks represented
-    [ 28] UINT64 logicalbytes;  // logical size of the data (in bytes)
-    [ 36] UINT64 metaoffset;    // offset to the first blob of metadata
-    [ 44] UINT8  md5[16];       // MD5 checksum of raw data
-    [ 60] UINT8  parentmd5[16]; // MD5 checksum of parent file
-    [ 76] UINT32 hunkbytes;     // number of bytes per hunk
-    [ 80] UINT8  sha1[20];      // SHA1 checksum of raw data
-    [100] UINT8  parentsha1[20];// SHA1 checksum of parent file
+    [  8] uint32_t length;        // length of header (including tag and length fields)
+    [ 12] uint32_t version;       // drive format version
+    [ 16] uint32_t flags;         // flags (see below)
+    [ 20] uint32_t compression;   // compression type
+    [ 24] uint32_t totalhunks;    // total # of hunks represented
+    [ 28] uint64_t logicalbytes;  // logical size of the data (in bytes)
+    [ 36] uint64_t metaoffset;    // offset to the first blob of metadata
+    [ 44] uint8_t  md5[16];       // MD5 checksum of raw data
+    [ 60] uint8_t  parentmd5[16]; // MD5 checksum of parent file
+    [ 76] uint32_t hunkbytes;     // number of bytes per hunk
+    [ 80] uint8_t  sha1[20];      // SHA1 checksum of raw data
+    [100] uint8_t  parentsha1[20];// SHA1 checksum of parent file
    [120] (V3 header length)

    V4 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] UINT32 length;        // length of header (including tag and length fields)
-    [ 12] UINT32 version;       // drive format version
-    [ 16] UINT32 flags;         // flags (see below)
-    [ 20] UINT32 compression;   // compression type
-    [ 24] UINT32 totalhunks;    // total # of hunks represented
-    [ 28] UINT64 logicalbytes;  // logical size of the data (in bytes)
-    [ 36] UINT64 metaoffset;    // offset to the first blob of metadata
-    [ 44] UINT32 hunkbytes;     // number of bytes per hunk
-    [ 48] UINT8  sha1[20];      // combined raw+meta SHA1
-    [ 68] UINT8  parentsha1[20];// combined raw+meta SHA1 of parent
-    [ 88] UINT8  rawsha1[20];   // raw data SHA1
+    [  8] uint32_t length;        // length of header (including tag and length fields)
+    [ 12] uint32_t version;       // drive format version
+    [ 16] uint32_t flags;         // flags (see below)
+    [ 20] uint32_t compression;   // compression type
+    [ 24] uint32_t totalhunks;    // total # of hunks represented
+    [ 28] uint64_t logicalbytes;  // logical size of the data (in bytes)
+    [ 36] uint64_t metaoffset;    // offset to the first blob of metadata
+    [ 44] uint32_t hunkbytes;     // number of bytes per hunk
+    [ 48] uint8_t  sha1[20];      // combined raw+meta SHA1
+    [ 68] uint8_t  parentsha1[20];// combined raw+meta SHA1 of parent
+    [ 88] uint8_t  rawsha1[20];   // raw data SHA1
    [108] (V4 header length)

    Flags:
@@ -131,17 +130,17 @@ extern "C" {
    V5 header:

    [  0] char   tag[8];        // 'MComprHD'
-    [  8] uint32_t length;        // length of header (including tag and length fields)
-    [ 12] uint32_t version;       // drive format version
-    [ 16] uint32_t compressors[4];// which custom compressors are used?
-    [ 32] uint64_t logicalbytes;  // logical size of the data (in bytes)
-    [ 40] uint64_t mapoffset;     // offset to the map
-    [ 48] uint64_t metaoffset;    // offset to the first blob of metadata
-    [ 56] uint32_t hunkbytes;     // number of bytes per hunk (512k maximum)
-    [ 60] uint32_t unitbytes;     // number of bytes per unit within each hunk
-    [ 64] uint8_t  rawsha1[20];   // raw data SHA1
-    [ 84] uint8_t  sha1[20];      // combined raw+meta SHA1
-    [104] uint8_t  parentsha1[20];// combined raw+meta SHA1 of parent
+    [  8] uint32_t_t length;        // length of header (including tag and length fields)
+    [ 12] uint32_t_t version;       // drive format version
+    [ 16] uint32_t_t compressors[4];// which custom compressors are used?
+    [ 32] uint64_t_t logicalbytes;  // logical size of the data (in bytes)
+    [ 40] uint64_t_t mapoffset;     // offset to the map
+    [ 48] uint64_t_t metaoffset;    // offset to the first blob of metadata
+    [ 56] uint32_t_t hunkbytes;     // number of bytes per hunk (512k maximum)
+    [ 60] uint32_t_t unitbytes;     // number of bytes per unit within each hunk
+    [ 64] uint8_t_t  rawsha1[20];   // raw data SHA1
+    [ 84] uint8_t_t  sha1[20];      // combined raw+meta SHA1
+    [104] uint8_t_t  parentsha1[20];// combined raw+meta SHA1 of parent
    [124] (V5 header length)

    If parentsha1 != 0, we have a parent (no need for flags)
@@ -149,22 +148,22 @@ extern "C" {

    V5 uncompressed map format:

-    [  0] uint32_t offset;        // starting offset / hunk size
+    [  0] uint32_t_t offset;        // starting offset / hunk size

    V5 compressed map format header:

-    [  0] uint32_t length;        // length of compressed map
+    [  0] uint32_t_t length;        // length of compressed map
    [  4] UINT48 datastart;     // offset of first block
    [ 10] uint16_t crc;           // crc-16 of the map
-    [ 12] uint8_t lengthbits;     // bits used to encode complength
-    [ 13] uint8_t hunkbits;       // bits used to encode self-refs
-    [ 14] uint8_t parentunitbits; // bits used to encode parent unit refs
-    [ 15] uint8_t reserved;       // future use
+    [ 12] uint8_t_t lengthbits;     // bits used to encode complength
+    [ 13] uint8_t_t hunkbits;       // bits used to encode self-refs
+    [ 14] uint8_t_t parentunitbits; // bits used to encode parent unit refs
+    [ 15] uint8_t_t reserved;       // future use
    [ 16] (compressed header length)

    Each compressed map entry, once expanded, looks like:

-    [  0] uint8_t compression;    // compression type
+    [  0] uint8_t_t compression;    // compression type
    [  1] UINT24 complength;    // compressed length
    [  4] UINT48 offset;        // offset
    [ 10] uint16_t crc;           // crc-16 of the data
@@ -221,7 +220,7 @@ extern "C" {

 /* metadata parameters */
 #define CHDMETATAG_WILDCARD			0
-#define CHD_METAINDEX_APPEND		((UINT32)-1)
+#define CHD_METAINDEX_APPEND		((uint32_t)-1)

 /* metadata flags */
 #define CHD_MDFLAGS_CHECKSUM		0x01		/* indicates data is checksummed */
@@ -290,8 +289,7 @@ enum _chd_error
 	CHDERR_INVALID_STATE,
 	CHDERR_OPERATION_PENDING,
 	CHDERR_NO_ASYNC_OPERATION,
-	CHDERR_UNSUPPORTED_FORMAT,
-	CHDERR_CANCELLED,
+	CHDERR_UNSUPPORTED_FORMAT
 };
 typedef enum _chd_error chd_error;

@@ -309,32 +307,32 @@ typedef struct _chd_file chd_file;
 typedef struct _chd_header chd_header;
 struct _chd_header
 {
-	UINT32		length;						/* length of header data */
-	UINT32		version;					/* drive format version */
-	UINT32		flags;						/* flags field */
-	UINT32		compression[4];				/* compression type */
-	UINT32		hunkbytes;					/* number of bytes per hunk */
-	UINT32		totalhunks;					/* total # of hunks represented */
-	UINT64		logicalbytes;				/* logical size of the data */
-	UINT64		metaoffset;					/* offset in file of first metadata */
-	UINT64		mapoffset;					/* TOOD V5 */
-	UINT8		md5[CHD_MD5_BYTES];			/* overall MD5 checksum */
-	UINT8		parentmd5[CHD_MD5_BYTES];	/* overall MD5 checksum of parent */
-	UINT8		sha1[CHD_SHA1_BYTES];		/* overall SHA1 checksum */
-	UINT8		rawsha1[CHD_SHA1_BYTES];	/* SHA1 checksum of raw data */
-	UINT8		parentsha1[CHD_SHA1_BYTES];	/* overall SHA1 checksum of parent */
-	UINT32		unitbytes;					/* TODO V5 */
-	UINT64		unitcount;					/* TODO V5 */
-    UINT32      hunkcount;                  /* TODO V5 */
+	uint32_t		length;						/* length of header data */
+	uint32_t		version;					/* drive format version */
+	uint32_t		flags;						/* flags field */
+	uint32_t		compression[4];				/* compression type */
+	uint32_t		hunkbytes;					/* number of bytes per hunk */
+	uint32_t		totalhunks;					/* total # of hunks represented */
+	uint64_t		logicalbytes;				/* logical size of the data */
+	uint64_t		metaoffset;					/* offset in file of first metadata */
+	uint64_t		mapoffset;					/* TOOD V5 */
+	uint8_t		md5[CHD_MD5_BYTES];			/* overall MD5 checksum */
+	uint8_t		parentmd5[CHD_MD5_BYTES];	/* overall MD5 checksum of parent */
+	uint8_t		sha1[CHD_SHA1_BYTES];		/* overall SHA1 checksum */
+	uint8_t		rawsha1[CHD_SHA1_BYTES];	/* SHA1 checksum of raw data */
+	uint8_t		parentsha1[CHD_SHA1_BYTES];	/* overall SHA1 checksum of parent */
+	uint32_t		unitbytes;					/* TODO V5 */
+	uint64_t		unitcount;					/* TODO V5 */
+    uint32_t      hunkcount;                  /* TODO V5 */

    /* map information */
-    UINT32      mapentrybytes;              /* length of each entry in a map (V5) */
-    UINT8*      rawmap;                     /* raw map data */
+    uint32_t      mapentrybytes;              /* length of each entry in a map (V5) */
+    uint8_t*      rawmap;                     /* raw map data */

-	UINT32		obsolete_cylinders;			/* obsolete field -- do not use! */
-	UINT32		obsolete_sectors;			/* obsolete field -- do not use! */
-	UINT32		obsolete_heads;				/* obsolete field -- do not use! */
-	UINT32		obsolete_hunksize;			/* obsolete field -- do not use! */
+	uint32_t		obsolete_cylinders;			/* obsolete field -- do not use! */
+	uint32_t		obsolete_sectors;			/* obsolete field -- do not use! */
+	uint32_t		obsolete_heads;				/* obsolete field -- do not use! */
+	uint32_t		obsolete_hunksize;			/* obsolete field -- do not use! */
 };


@@ -342,10 +340,10 @@ struct _chd_header
 typedef struct _chd_verify_result chd_verify_result;
 struct _chd_verify_result
 {
-	UINT8		md5[CHD_MD5_BYTES];			/* overall MD5 checksum */
-	UINT8		sha1[CHD_SHA1_BYTES];		/* overall SHA1 checksum */
-	UINT8		rawsha1[CHD_SHA1_BYTES];	/* SHA1 checksum of raw data */
-	UINT8		metasha1[CHD_SHA1_BYTES];	/* SHA1 checksum of metadata */
+	uint8_t		md5[CHD_MD5_BYTES];			/* overall MD5 checksum */
+	uint8_t		sha1[CHD_SHA1_BYTES];		/* overall SHA1 checksum */
+	uint8_t		rawsha1[CHD_SHA1_BYTES];	/* SHA1 checksum of raw data */
+	uint8_t		metasha1[CHD_SHA1_BYTES];	/* SHA1 checksum of metadata */
 };


@@ -371,10 +369,10 @@ struct _chd_verify_result
 /* ----- CHD file management ----- */

 /* create a new CHD file fitting the given description */
-/* chd_error chd_create(const char *filename, UINT64 logicalbytes, UINT32 hunkbytes, UINT32 compression, chd_file *parent); */
+/* chd_error chd_create(const char *filename, uint64_t logicalbytes, uint32_t hunkbytes, uint32_t compression, chd_file *parent); */

 /* same as chd_create(), but accepts an already-opened core_file object */
-/* chd_error chd_create_file(core_file *file, UINT64 logicalbytes, UINT32 hunkbytes, UINT32 compression, chd_file *parent); */
+/* chd_error chd_create_file(core_file *file, uint64_t logicalbytes, uint32_t hunkbytes, uint32_t compression, chd_file *parent); */

 /* open an existing CHD file */
 CHD_EXPORT chd_error chd_open_core_file(core_file *file, int mode, chd_file *parent, chd_file **chd);
@@ -383,7 +381,6 @@ CHD_EXPORT chd_error chd_open(const char *filename, int mode, chd_file *parent,

 /* precache underlying file */
 CHD_EXPORT chd_error chd_precache(chd_file *chd);
-CHD_EXPORT chd_error chd_precache_progress(chd_file* chd, bool(*progress)(size_t pos, size_t total, void* param), void* param);

 /* close a CHD file */
 CHD_EXPORT void chd_close(chd_file *chd);
@@ -391,13 +388,11 @@ CHD_EXPORT void chd_close(chd_file *chd);
 /* return the associated core_file */
 CHD_EXPORT core_file *chd_core_file(chd_file *chd);

-/* return the overall size of a CHD, and any of its parents */
-CHD_EXPORT UINT64 chd_get_compressed_size(chd_file* chd);
-
 /* return an error string for the given CHD error */
 CHD_EXPORT const char *chd_error_string(chd_error err);


+
 /* ----- CHD header management ----- */

 /* return a pointer to the extracted CHD header data */
@@ -413,14 +408,14 @@ CHD_EXPORT chd_error chd_read_header(const char *filename, chd_header *header);
 /* ----- core data read/write ----- */

 /* read one hunk from the CHD file */
-CHD_EXPORT chd_error chd_read(chd_file *chd, UINT32 hunknum, void *buffer);
+CHD_EXPORT chd_error chd_read(chd_file *chd, uint32_t hunknum, void *buffer);



 /* ----- metadata management ----- */

 /* get indexed metadata of a particular sort */
-CHD_EXPORT chd_error chd_get_metadata(chd_file *chd, UINT32 searchtag, UINT32 searchindex, void *output, UINT32 outputlen, UINT32 *resultlen, UINT32 *resulttag, UINT8 *resultflags);
+CHD_EXPORT chd_error chd_get_metadata(chd_file *chd, uint32_t searchtag, uint32_t searchindex, void *output, uint32_t outputlen, uint32_t *resultlen, uint32_t *resulttag, uint8_t *resultflags);



@@ -431,7 +426,7 @@ CHD_EXPORT chd_error chd_get_metadata(chd_file *chd, UINT32 searchtag, UINT32 se
 CHD_EXPORT chd_error chd_codec_config(chd_file *chd, int param, void *config);

 /* return a string description of a codec */
-CHD_EXPORT const char *chd_get_codec_name(UINT32 codec);
+CHD_EXPORT const char *chd_get_codec_name(uint32_t codec);

 #ifdef __cplusplus
 }
--- a/3rdparty/libchdr/include/libchdr/coretypes.h
+++ b/3rdparty/libchdr/include/libchdr/coretypes.h
@@ -8,26 +8,13 @@
 #include <streams/file_stream_transforms.h>
 #endif

+#ifndef ARRAY_LENGTH
 #define ARRAY_LENGTH(x) (sizeof(x)/sizeof(x[0]))
-
-#if defined(__PS3__) || defined(__PSL1GHT__)
-#undef UINT32
-#undef UINT16
-#undef UINT8
-#undef INT32
-#undef INT16
-#undef INT8
 #endif

-typedef uint64_t UINT64;
-typedef uint32_t UINT32;
-typedef uint16_t UINT16;
-typedef uint8_t UINT8;
-
-typedef int64_t INT64;
-typedef int32_t INT32;
-typedef int16_t INT16;
-typedef int8_t INT8;
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
+#endif

 typedef struct chd_core_file {
 	/*
@@ -41,9 +28,9 @@ typedef struct chd_core_file {
 	 * undefined because many implementations will seek to the end of the
 	 * file and call ftell.
 	 *
-	 * on error, (UINT64)-1 is returned.
+	 * on error, (uint64_t)-1 is returned.
 	 */
-	UINT64(*fsize)(struct chd_core_file*);
+	uint64_t(*fsize)(struct chd_core_file*);

 	/*
 	 * should match the behavior of fread, except the FILE* argument at the end
@@ -55,7 +42,7 @@ typedef struct chd_core_file {
 	int (*fclose)(struct chd_core_file*);

 	// fseek clone
-	int (*fseek)(struct chd_core_file*, INT64, int);
+	int (*fseek)(struct chd_core_file*, int64_t, int);
 } core_file;

 static inline int core_fclose(core_file *fp) {
@@ -66,11 +53,11 @@ static inline size_t core_fread(core_file *fp, void *ptr, size_t len) {
 	return fp->fread(ptr, 1, len, fp);
 }

-static inline int core_fseek(core_file* fp, INT64 offset, int whence) {
+static inline int core_fseek(core_file* fp, int64_t offset, int whence) {
 	return fp->fseek(fp, offset, whence);
 }

-static inline UINT64 core_fsize(core_file *fp)
+static inline uint64_t core_fsize(core_file *fp)
 {
 	return fp->fsize(fp);
 }
--- a/3rdparty/libchdr/include/libchdr/huffman.h
+++ b/3rdparty/libchdr/include/libchdr/huffman.h
@@ -85,6 +85,6 @@ int huffman_build_tree(struct huffman_decoder* decoder, uint32_t totaldata, uint
 enum huffman_error huffman_assign_canonical_codes(struct huffman_decoder* decoder);
 enum huffman_error huffman_compute_tree_from_histo(struct huffman_decoder* decoder);

-void huffman_build_lookup_table(struct huffman_decoder* decoder);
+enum huffman_error huffman_build_lookup_table(struct huffman_decoder* decoder);

 #endif
--- a/3rdparty/libchdr/src/libchdr_cdrom.c
+++ b/3rdparty/libchdr/src/libchdr_cdrom.c
@@ -20,35 +20,6 @@

 #include <libchdr/cdrom.h>

-const char* cdrom_get_subtype_string(uint32_t subtype)
-{
-	switch (subtype)
-	{
-	case CD_SUB_RAW:              return "RW";
-	case CD_SUB_RAW_INTERLEAVED:  return "RW_RAW";
-	default:                      return "NONE";
-	}
-}
-
-bool cdrom_parse_subtype_string(const char* typestring, uint32_t* subtype, uint32_t* subsize)
-{
-	// https://github.com/mamedev/mame/blob/d2d54fb8ed53a2e86d308067da8414f85b5929b0/src/lib/util/cdrom.cpp#L767
-  if (!strcmp(typestring, "RW"))
-  {
-    *subtype = CD_SUB_RAW;
-    *subsize = 96;
-		return true;
-  }
-  else if (!strcmp(typestring, "RW_RAW"))
-  {
-    *subtype = CD_SUB_RAW_INTERLEAVED;
-    *subsize = 96;
-		return true;
-  }
-
-	return false;
-}
-
 #ifdef WANT_RAW_DATA_SECTOR

 /***************************************************************************
--- a/3rdparty/libchdr/src/libchdr_chd.c
+++ b/3rdparty/libchdr/src/libchdr_chd.c
--- a/3rdparty/libchdr/src/libchdr_huffman.c
+++ b/3rdparty/libchdr/src/libchdr_huffman.c
@@ -230,7 +230,9 @@ enum huffman_error huffman_import_tree_rle(struct huffman_decoder* decoder, stru
 		return error;

 	/* build the lookup table */
-	huffman_build_lookup_table(decoder);
+	error = huffman_build_lookup_table(decoder);
+	if (error != HUFFERR_NONE)
+		return error;

 	/* determine final input length and report errors */
 	return bitstream_overflow(bitbuf) ? HUFFERR_INPUT_BUFFER_TOO_SMALL : HUFFERR_NONE;
@@ -271,8 +273,16 @@ enum huffman_error huffman_import_tree_huffman(struct huffman_decoder* decoder,
 	/* then regenerate the tree */
 	error = huffman_assign_canonical_codes(smallhuff);
 	if (error != HUFFERR_NONE)
+	{
+		delete_huffman_decoder(smallhuff);
 		return error;
-	huffman_build_lookup_table(smallhuff);
+	}
+	error = huffman_build_lookup_table(smallhuff);
+	if (error != HUFFERR_NONE)
+	{
+		delete_huffman_decoder(smallhuff);
+		return error;
+	}

 	/* determine the maximum length of an RLE count */
 	temp = decoder->numcodes - 9;
@@ -308,7 +318,9 @@ enum huffman_error huffman_import_tree_huffman(struct huffman_decoder* decoder,
 		return error;

 	/* build the lookup table */
-	huffman_build_lookup_table(decoder);
+	error = huffman_build_lookup_table(decoder);
+	if (error != HUFFERR_NONE)
+		return error;

 	/* determine final input length and report errors */
 	return bitstream_overflow(bitbuf) ? HUFFERR_INPUT_BUFFER_TOO_SMALL : HUFFERR_NONE;
@@ -523,8 +535,9 @@ enum huffman_error huffman_assign_canonical_codes(struct huffman_decoder* decode
 *-------------------------------------------------
 */

-void huffman_build_lookup_table(struct huffman_decoder* decoder)
+enum huffman_error huffman_build_lookup_table(struct huffman_decoder* decoder)
 {
+	const lookup_value* lookupend = &decoder->lookup[(1u << decoder->maxbits)];
 	uint32_t curcode;
 	/* iterate over all codes */
 	for (curcode = 0; curcode < decoder->numcodes; curcode++)
@@ -533,9 +546,10 @@ void huffman_build_lookup_table(struct huffman_decoder* decoder)
 		struct node_t* node = &decoder->huffnode[curcode];
 		if (node->numbits > 0)
 		{
-         int shift;
-         lookup_value *dest;
-         lookup_value *destend;
+			int shift;
+			lookup_value *dest;
+			lookup_value *destend;
+
 			/* set up the entry */
 			lookup_value value = MAKE_LOOKUP(curcode, node->numbits);

@@ -543,8 +557,12 @@ void huffman_build_lookup_table(struct huffman_decoder* decoder)
 			shift = decoder->maxbits - node->numbits;
 			dest = &decoder->lookup[node->bits << shift];
 			destend = &decoder->lookup[((node->bits + 1) << shift) - 1];
+			if (dest >= lookupend || destend >= lookupend || destend < dest)
+				return HUFFERR_INTERNAL_INCONSISTENCY;
 			while (dest <= destend)
 				*dest++ = value;
 		}
 	}
+
+	return HUFFERR_NONE;
 }
--- a/bin/resources/GameIndex.yaml
+++ b/bin/resources/GameIndex.yaml
--- a/bin/resources/RedumpDatabase.yaml
+++ b/bin/resources/RedumpDatabase.yaml
--- a/bin/resources/game_controller_db.txt
+++ b/bin/resources/game_controller_db.txt
@@ -593,6 +593,7 @@
 030000009b2800002c00000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,
 030000009b2800008000000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,
 03000000790000008f18000000000000,Rapoo Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b3,y:b0,platform:Windows,
+0300000032150000a602000000000000,Razer Huntsman V3 Pro,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b12,dpright:b13,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,
 03000000321500000003000000000000,Razer Hydra,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,
 03000000f8270000bf0b000000000000,Razer Kishi,a:b6,b:b7,back:b16,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b18,leftshoulder:b12,leftstick:b19,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b13,rightstick:b20,righttrigger:b15,rightx:a3,righty:a4,start:b17,x:b9,y:b10,platform:Windows,
 03000000321500000204000000000000,Razer Panthera PS3 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,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,
@@ -883,7 +884,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000c82d00003032000000010000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a31,start:b11,x:b4,y:b3,platform:Mac OS X,
 03000000491900001904000001010000,Amazon Luna Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Mac OS X,
 03000000710100001904000000010000,Amazon Luna Controller,a:b0,b:b1,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Mac OS X,
-0300000008100000e501000019040000,Anbernic Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a4,start:b11,x:b4,y:b3,platform:Mac OS X,
+0300000008100000e501000019040000,Anbernic Handheld,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a4,start:b11,x:b4,y:b3,platform:Mac OS X,
 03000000373500004610000001000000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 03000000a30c00002700000003030000,Astro City Mini,a:b2,b:b1,back:b8,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Mac OS X,
 03000000a30c00002800000003030000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a3,lefty:a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Mac OS X,
@@ -1116,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,
@@ -1208,10 +1210,9 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 05000000491900000204000021000000,Amazon Fire Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b17,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b12,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 03000000491900001904000011010000,Amazon Luna Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Linux,
 05000000710100001904000000010000,Amazon Luna Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,
-0300000008100000e501000001010000,Anbernic Gamepad,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a4,start:b11,x:b3,y:b4,platform:Linux,
+0300000008100000e501000001010000,Anbernic Handheld,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a4,start:b11,x:b3,y:b4,platform:Linux,
 03000000020500000913000010010000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 03000000373500000710000010010000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-030000005e0400008e02000072050000,Anbernic RG P01,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,
 05000000373500004610000001000000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 03000000790000003018000011010000,Arcade Fightstick F300,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,
 03000000a30c00002700000011010000,Astro City Mini,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,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,
@@ -1347,10 +1348,10 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000632500007505000011010000,Ipega PG 9099,a:b2,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:b3,y:b0,platform:Linux,
 0500000049190000030400001b010000,Ipega PG9099,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,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,
 05000000491900000204000000000000,Ipega PG9118,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
+03000000300f00001101000010010000,Jess Tech Colour Rumble Pad,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,
 03000000300f00001001000010010000,Jess Tech Dual Analog Rumble,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,
 03000000300f00000b01000010010000,Jess Tech GGE909 PC Recoil,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,
 03000000ba2200002010000001010000,Jess Technology Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,
-03000000300f00001101000010010000,Jess Tech Colour Rumble Pad,a:b2,b:b3,x:b0,y:b1,back:b8,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b6,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a2,lefttrigger:b5,righttrigger:b7,platform:Linux,
 030000007e0500000620000001000000,Joy-Con (L),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b13,leftshoulder:b4,leftstick:b10,rightshoulder:b5,start:b8,x:b2,y:b3,platform:Linux,
 050000007e0500000620000001000000,Joy-Con (L),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b13,leftshoulder:b4,leftstick:b10,rightshoulder:b5,start:b8,x:b2,y:b3,platform:Linux,
 030000007e0500000720000001000000,Joy-Con (R),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b12,leftshoulder:b4,leftstick:b11,rightshoulder:b5,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,
@@ -1719,10 +1721,11 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000006f0e00001503000000020000,Xbox 360 Controller,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,
 030000005e0400008e02000000010000,Xbox 360 EasySMX,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,
 030000005e040000a102000014010000,Xbox 360 Receiver,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,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,
+0000000058626f782047616d65706100,Xbox Controller,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:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,
 030000005e0400000202000000010000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,
+030000005e0400008e02000072050000,Xbox Controller,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,
 030000006f0e00001304000000010000,Xbox Controller,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,
 03000000ffff0000ffff000000010000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,
-0000000058626f782047616d65706100,Xbox Gamepad,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:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,
 030000005e0400000a0b000005040000,Xbox One Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Linux,
 030000005e040000d102000002010000,Xbox One Controller,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,
 030000005e040000ea02000000000000,Xbox One Controller,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,
--- 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/common/FileSystem.cpp
+++ b/common/FileSystem.cpp
@@ -1230,6 +1230,14 @@ size_t FileSystem::ReadFileWithProgress(std::FILE* fp, void* dst, size_t length,
 {
 	progress->SetProgressRange(100);

+	return FileSystem::ReadFileWithPartialProgress(fp, dst, length, progress, 0, 100, error, chunk_size);
+}
+
+size_t FileSystem::ReadFileWithPartialProgress(std::FILE* fp, void* dst, size_t length,
+	ProgressCallback* progress, int startPercent, int endPercent, Error* error, size_t chunk_size)
+{
+	const int deltaPercent = endPercent - startPercent;
+
 	size_t done = 0;
 	while (done < length)
 	{
@@ -1243,7 +1251,7 @@ size_t FileSystem::ReadFileWithProgress(std::FILE* fp, void* dst, size_t length,
 			break;
 		}

-		progress->SetProgressValue((done * 100) / length);
+		progress->SetProgressValue(startPercent + (done * deltaPercent) / length);
 		done += read_size;
 	}

--- a/common/FileSystem.h
+++ b/common/FileSystem.h
@@ -144,6 +144,8 @@ namespace FileSystem
 	bool WriteStringToFile(const char* filename, const std::string_view sv);
 	size_t ReadFileWithProgress(std::FILE* fp, void* dst, size_t length, ProgressCallback* progress,
 		Error* error = nullptr, size_t chunk_size = 16 * 1024 * 1024);
+	size_t ReadFileWithPartialProgress(std::FILE* fp, void* dst, size_t length, ProgressCallback* progress,
+		int startPercent, int endPercent, Error* error = nullptr, size_t chunk_size = 16 * 1024 * 1024);

 	/// creates a directory in the local filesystem
 	/// if the directory already exists, the return value will be true.
--- a/common/vsprops/common.props
+++ b/common/vsprops/common.props
@@ -52,10 +52,10 @@

      <!-- MSVC automatically adds __AVX__ and __AVX2__ appropriately -->
      <PreprocessorDefinitions Condition="'$(Platform)'=='x64'">_M_X86;__SSE4_1__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <EnableEnhancedInstructionSet Condition="!$(Configuration.Contains(AVX2)) Or $(Configuration.Contains(Clang))">NotSet</EnableEnhancedInstructionSet>
-      <EnableEnhancedInstructionSet Condition="$(Configuration.Contains(AVX2)) And !$(Configuration.Contains(Clang))">AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet Condition="'$(Platform)'=='ARM64' Or !$(Configuration.Contains(AVX2))">NotSet</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet Condition="'$(Platform)'=='x64' And $(Configuration.Contains(AVX2))">AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <!-- Allow SSE4 intrinsics on non-AVX Clang-cl builds -->
      <AdditionalOptions Condition="'$(Platform)'=='x64' And $(Configuration.Contains(Clang)) And !$(Configuration.Contains(AVX2))"> -march=nehalem %(AdditionalOptions)</AdditionalOptions>
-      <AdditionalOptions Condition="'$(Platform)'=='x64' And $(Configuration.Contains(Clang)) And $(Configuration.Contains(AVX2))"> -march=haswell %(AdditionalOptions)</AdditionalOptions>
      <AdditionalOptions Condition="'$(Platform)'=='ARM64' And $(Configuration.Contains(Clang))"> -march=armv8.4-a %(AdditionalOptions)</AdditionalOptions>
      <AdditionalOptions Condition="!$(Configuration.Contains(Clang))">%(AdditionalOptions) /Zc:externConstexpr /Zc:__cplusplus /Zo /utf-8</AdditionalOptions>

--- 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/DebugSettingsWidget.cpp
+++ b/pcsx2-qt/Settings/DebugSettingsWidget.cpp
@@ -151,6 +151,14 @@ void DebugSettingsWidget::onDrawDumpingChanged()
 	m_ui.saveFrame->setEnabled(enabled);
 	m_ui.saveTexture->setEnabled(enabled);
 	m_ui.saveDepth->setEnabled(enabled);
+	m_ui.startDraw->setEnabled(enabled);
+	m_ui.dumpCount->setEnabled(enabled);
+	m_ui.hwDumpDirectory->setEnabled(enabled);
+	m_ui.hwDumpBrowse->setEnabled(enabled);
+	m_ui.hwDumpOpen->setEnabled(enabled);
+	m_ui.swDumpDirectory->setEnabled(enabled);
+	m_ui.swDumpBrowse->setEnabled(enabled);
+	m_ui.swDumpOpen->setEnabled(enabled);
 }

 #ifdef PCSX2_DEVBUILD
--- a/pcsx2-qt/Settings/DebugSettingsWidget.ui
+++ b/pcsx2-qt/Settings/DebugSettingsWidget.ui
@@ -167,7 +167,7 @@
              </property>
             </widget>
            </item>
-            <item row="0" column="1">
+            <item row="1" column="1">
             <widget class="QCheckBox" name="saveRT">
              <property name="text">
               <string>Save RT</string>
@@ -181,7 +181,7 @@
              </property>
             </widget>
            </item>
-            <item row="1" column="1">
+            <item row="2" column="1">
             <widget class="QCheckBox" name="saveTexture">
              <property name="text">
               <string>Save Texture</string>
--- 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.cpp
+++ b/pcsx2-qt/Translations.cpp
--- 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/CDVD/ChdFileReader.cpp
+++ b/pcsx2/CDVD/ChdFileReader.cpp
@@ -21,6 +21,7 @@ static std::vector<std::pair<std::string, chd_header>> s_chd_hash_cache; // <fil
 static std::recursive_mutex s_chd_hash_cache_mutex;

 // Provides an implementation of core_file which allows us to control if the underlying FILE handle is freed.
+// Additionally, this class allows greater control and feedback while precaching CHD files.
 // The lifetime of ChdCoreFileWrapper will be equal to that of the relevant chd_file,
 // ChdCoreFileWrapper will also get destroyed if chd_open_core_file fails.
 class ChdCoreFileWrapper
@@ -31,10 +32,15 @@ private:
 	core_file m_core;
 	std::FILE* m_file;
 	bool m_free_file = false;
+	ChdCoreFileWrapper* m_parent = nullptr;
+	std::unique_ptr<u8[]> m_file_cache;
+	s64 m_file_cache_size;
+	s64 m_file_cache_pos;

 public:
-	ChdCoreFileWrapper(std::FILE* file)
+	ChdCoreFileWrapper(std::FILE* file, ChdCoreFileWrapper* parent)
 		: m_file{file}
+		, m_parent{parent}
 	{
 		m_core.argp = this;
 		m_core.fsize = FSize;
@@ -45,7 +51,7 @@ public:

 	~ChdCoreFileWrapper()
 	{
-		if (m_free_file)
+		if (m_free_file && m_file)
 			std::fclose(m_file);
 	}

@@ -64,15 +70,100 @@ public:
 		m_free_file = isOwner;
 	}

+	s64 GetPrecacheSize()
+	{
+		const s64 size = static_cast<size_t>(FileSystem::FSize64(m_file));
+		if (m_parent != nullptr)
+			return m_parent->GetPrecacheSize() + size;
+		else
+			return size;
+	}
+
+	bool Precache(ProgressCallback* progress, Error* error)
+	{
+		progress->SetProgressRange(100);
+
+		const s64 size = GetPrecacheSize();
+		return PrecacheInternal(progress, error, 0, size);
+	}
+
 private:
+	bool PrecacheInternal(ProgressCallback* progress, Error* error, s64 startSize, s64 finalSize)
+	{
+		m_file_cache_size = FileSystem::FSize64(m_file);
+		if (m_file_cache_size <= 0)
+		{
+			Error::SetStringView(error, "Failed to determine file size.");
+			return false;
+		}
+
+		// Copy the current file position.
+		m_file_cache_pos = FileSystem::FTell64(m_file);
+		if (m_file_cache_pos <= 0)
+		{
+			Error::SetStringView(error, "Failed to determine file position.");
+			return false;
+		}
+
+		m_file_cache = std::make_unique_for_overwrite<u8[]>(m_file_cache_size);
+		if (FileSystem::FSeek64(m_file, 0, SEEK_SET) != 0 ||
+			FileSystem::ReadFileWithPartialProgress(
+				m_file, m_file_cache.get(), m_file_cache_size, progress,
+				(startSize * 100) / finalSize,
+				((startSize + m_file_cache_size) * 100) / finalSize,
+				error) != static_cast<size_t>(m_file_cache_size))
+		{
+			m_file_cache.reset();
+			// Precache failed, continue using file
+			// Restore file position incase it's used for subsequent reads
+			FileSystem::FSeek64(m_file, m_file_cache_pos, SEEK_SET);
+			Error::SetStringView(error, "Failed to read part of the file.");
+			return false;
+		}
+
+		startSize += m_file_cache_size;
+
+		if (m_parent)
+		{
+			if (!m_parent->PrecacheInternal(progress, error, startSize, finalSize))
+			{
+				// Precache failed, continue using file
+				// Restore file position incase it's used for subsequent reads
+				FileSystem::FSeek64(m_file, m_file_cache_pos, SEEK_SET);
+				m_file_cache.reset();
+				return false;
+			}
+		}
+
+		if (m_free_file)
+			std::fclose(m_file);
+		m_file = nullptr;
+
+		return true;
+	}
+
 	static u64 FSize(core_file* file)
 	{
-		return static_cast<u64>(FileSystem::FSize64(FromCoreFile(file)->m_file));
+		ChdCoreFileWrapper* fileWrapper = FromCoreFile(file);
+		if (fileWrapper->m_file_cache)
+			return fileWrapper->m_file_cache_size;
+		else
+			return static_cast<u64>(FileSystem::FSize64(fileWrapper->m_file));
 	}

 	static size_t FRead(void* buffer, size_t elmSize, size_t elmCount, core_file* file)
 	{
-		return std::fread(buffer, elmSize, elmCount, FromCoreFile(file)->m_file);
+		ChdCoreFileWrapper* fileWrapper = FromCoreFile(file);
+		if (fileWrapper->m_file_cache)
+		{
+			// While currently libchdr only uses an elmCount of 1, we can't guarantee that will always be the case.
+			elmCount = std::min<size_t>(elmCount, std::max<s64>(fileWrapper->m_file_cache_size - fileWrapper->m_file_cache_pos, 0) / elmSize);
+			const size_t size = elmSize * elmCount;
+			std::memcpy(buffer, &fileWrapper->m_file_cache[fileWrapper->m_file_cache_pos], size);
+			return elmCount;
+		}
+		else
+			return std::fread(buffer, elmSize, elmCount, fileWrapper->m_file);
 	}

 	static int FClose(core_file* file)
@@ -84,7 +175,28 @@ private:

 	static int FSeek(core_file* file, int64_t offset, int whence)
 	{
-		return FileSystem::FSeek64(FromCoreFile(file)->m_file, offset, whence);
+		ChdCoreFileWrapper* fileWrapper = FromCoreFile(file);
+		if (fileWrapper->m_file_cache)
+		{
+			switch (whence)
+			{
+				case SEEK_SET:
+					fileWrapper->m_file_cache_pos = offset;
+					break;
+				case SEEK_CUR:
+					fileWrapper->m_file_cache_pos += offset;
+					break;
+				case SEEK_END:
+					fileWrapper->m_file_cache_pos = fileWrapper->m_file_cache_size + offset;
+					break;
+				default:
+					return -1;
+			}
+
+			return 0;
+		}
+		else
+			return FileSystem::FSeek64(fileWrapper->m_file, offset, whence);
 	}
 };

@@ -122,7 +234,7 @@ static bool IsHeaderParentCHD(const chd_header& header, const chd_header& parent
 static chd_file* OpenCHD(const std::string& filename, FileSystem::ManagedCFilePtr fp, Error* error, u32 recursion_level)
 {
 	chd_file* chd;
-	ChdCoreFileWrapper* core_wrapper = new ChdCoreFileWrapper(fp.get());
+	ChdCoreFileWrapper* core_wrapper = new ChdCoreFileWrapper(fp.get(), nullptr);
 	// libchdr will take ownership of core_wrapper, and will close/free it on failure.
 	chd_error err = chd_open_core_file(core_wrapper->GetCoreFile(), CHD_OPEN_READ, nullptr, &chd);
 	if (err == CHDERR_NONE)
@@ -236,7 +348,7 @@ static chd_file* OpenCHD(const std::string& filename, FileSystem::ManagedCFilePt
 	}

 	// Our last core file wrapper got freed, so make a new one.
-	core_wrapper = new ChdCoreFileWrapper(fp.get());
+	core_wrapper = new ChdCoreFileWrapper(fp.get(), ChdCoreFileWrapper::FromCoreFile(chd_core_file(parent_chd)));
 	// Now try re-opening with the parent.
 	err = chd_open_core_file(core_wrapper->GetCoreFile(), CHD_OPEN_READ, parent_chd, &chd);
 	if (err != CHDERR_NONE)
@@ -290,28 +402,11 @@ bool ChdFileReader::Open2(std::string filename, Error* error)

 bool ChdFileReader::Precache2(ProgressCallback* progress, Error* error)
 {
-	if (!CheckAvailableMemoryForPrecaching(chd_get_compressed_size(ChdFile), error))
+	ChdCoreFileWrapper* fileWrapper = ChdCoreFileWrapper::FromCoreFile(chd_core_file(ChdFile));
+	if (!CheckAvailableMemoryForPrecaching(fileWrapper->GetPrecacheSize(), error))
 		return false;

-	progress->SetProgressRange(100);
-
-	const auto callback = [](size_t pos, size_t total, void* param) -> bool {
-		ProgressCallback* progress = static_cast<ProgressCallback*>(param);
-		const u32 percent = static_cast<u32>((pos * 100) / total);
-		progress->SetProgressValue(std::min<u32>(percent, 100));
-		return !progress->IsCancelled();
-	};
-
-	const chd_error cerror = chd_precache_progress(ChdFile, callback, progress);
-	if (cerror != CHDERR_NONE)
-	{
-		if (cerror != CHDERR_CANCELLED)
-			Error::SetStringView(error, "Failed to read part of the file.");
-
-		return false;
-	}
-
-	return true;
+	return fileWrapper->Precache(progress, error);
 }

 ThreadedFileReader::Chunk ChdFileReader::ChunkForOffset(u64 offset)
--- a/pcsx2/COP0.cpp
+++ b/pcsx2/COP0.cpp
@@ -230,49 +230,49 @@ void MapTLB(const tlbs& t, int i)
 	u32 saddr, eaddr;

 	COP0_LOG("MAP TLB %d: 0x%08X-> [0x%08X 0x%08X] S=%d G=%d ASID=%d Mask=0x%03X EntryLo0 PFN=%x EntryLo0 Cache=%x EntryLo1 PFN=%x EntryLo1 Cache=%x VPN2=%x",
-		i, t.VPN2, t.PFN0, t.PFN1, t.S >> 31, t.G, t.ASID,
-		t.Mask, t.EntryLo0 >> 6, (t.EntryLo0 & 0x38) >> 3, t.EntryLo1 >> 6, (t.EntryLo1 & 0x38) >> 3, t.VPN2);
+		i, t.VPN2(), t.PFN0(), t.PFN1(), t.isSPR() >> 31, t.isGlobal(), t.EntryHi.ASID,
+		t.Mask(), t.EntryLo0.PFN, t.EntryLo0.C, t.EntryLo1.PFN, t.EntryLo1.C, t.VPN2());

 	// According to the manual
 	// 'It [SPR] must be mapped into a contiguous 16 KB of virtual address space that is
 	// aligned on a 16KB boundary.Results are not guaranteed if this restriction is not followed.'
 	// Assume that the game isn't doing anything less-than-ideal with the scratchpad mapping and map it directly to eeMem->Scratch.
-	if (t.S)
+	if (t.isSPR())
 	{
-		if (t.VPN2 != 0x70000000)
-			Console.Warning("COP0: Mapping Scratchpad to non-default address 0x%08X", t.VPN2);
+		if (t.VPN2() != 0x70000000)
+			Console.Warning("COP0: Mapping Scratchpad to non-default address 0x%08X", t.VPN2());

-		vtlb_VMapBuffer(t.VPN2, eeMem->Scratch, Ps2MemSize::Scratch);
+		vtlb_VMapBuffer(t.VPN2(), eeMem->Scratch, Ps2MemSize::Scratch);
 	}
 	else
 	{
-		if (t.EntryLo0 & 0x2)
+		if (t.EntryLo0.V)
 		{
-			mask = ((~t.Mask) << 1) & 0xfffff;
-			saddr = t.VPN2 >> 12;
-			eaddr = saddr + t.Mask + 1;
+			mask = ((~t.Mask()) << 1) & 0xfffff;
+			saddr = t.VPN2() >> 12;
+			eaddr = saddr + t.Mask() + 1;

 			for (addr = saddr; addr < eaddr; addr++)
 			{
-				if ((addr & mask) == ((t.VPN2 >> 12) & mask))
+				if ((addr & mask) == ((t.VPN2() >> 12) & mask))
 				{ //match
-					memSetPageAddr(addr << 12, t.PFN0 + ((addr - saddr) << 12));
+					memSetPageAddr(addr << 12, t.PFN0() + ((addr - saddr) << 12));
 					Cpu->Clear(addr << 12, 0x400);
 				}
 			}
 		}

-		if (t.EntryLo1 & 0x2)
+		if (t.EntryLo1.V)
 		{
-			mask = ((~t.Mask) << 1) & 0xfffff;
-			saddr = (t.VPN2 >> 12) + t.Mask + 1;
-			eaddr = saddr + t.Mask + 1;
+			mask = ((~t.Mask()) << 1) & 0xfffff;
+			saddr = (t.VPN2() >> 12) + t.Mask() + 1;
+			eaddr = saddr + t.Mask() + 1;

 			for (addr = saddr; addr < eaddr; addr++)
 			{
-				if ((addr & mask) == ((t.VPN2 >> 12) & mask))
+				if ((addr & mask) == ((t.VPN2() >> 12) & mask))
 				{ //match
-					memSetPageAddr(addr << 12, t.PFN1 + ((addr - saddr) << 12));
+					memSetPageAddr(addr << 12, t.PFN1() + ((addr - saddr) << 12));
 					Cpu->Clear(addr << 12, 0x400);
 				}
 			}
@@ -280,27 +280,36 @@ void MapTLB(const tlbs& t, int i)
 	}
 }

+__inline u32 ConvertPageMask(const u32 PageMask)
+{
+	const u32 mask = std::popcount(PageMask >> 13);
+
+	pxAssertMsg(!((mask & 1) || mask > 12), "Invalid page mask for this TLB entry. EE cache doesn't know what to do here.");
+
+	return (1 << (12 + mask)) - 1;
+}
+
 void UnmapTLB(const tlbs& t, int i)
 {
 	//Console.WriteLn("Clear TLB %d: %08x-> [%08x %08x] S=%d G=%d ASID=%d Mask= %03X", i,t.VPN2,t.PFN0,t.PFN1,t.S,t.G,t.ASID,t.Mask);
 	u32 mask, addr;
 	u32 saddr, eaddr;

-	if (t.S)
+	if (t.isSPR())
 	{
-		vtlb_VMapUnmap(t.VPN2, 0x4000);
+		vtlb_VMapUnmap(t.VPN2(), 0x4000);
 		return;
 	}

-	if (t.EntryLo0 & 0x2)
+	if (t.EntryLo0.V)
 	{
-		mask = ((~t.Mask) << 1) & 0xfffff;
-		saddr = t.VPN2 >> 12;
-		eaddr = saddr + t.Mask + 1;
+		mask = ((~t.Mask()) << 1) & 0xfffff;
+		saddr = t.VPN2() >> 12;
+		eaddr = saddr + t.Mask() + 1;
 		//	Console.WriteLn("Clear TLB: %08x ~ %08x",saddr,eaddr-1);
 		for (addr = saddr; addr < eaddr; addr++)
 		{
-			if ((addr & mask) == ((t.VPN2 >> 12) & mask))
+			if ((addr & mask) == ((t.VPN2() >> 12) & mask))
 			{ //match
 				memClearPageAddr(addr << 12);
 				Cpu->Clear(addr << 12, 0x400);
@@ -308,38 +317,74 @@ void UnmapTLB(const tlbs& t, int i)
 		}
 	}

-	if (t.EntryLo1 & 0x2)
+	if (t.EntryLo1.V)
 	{
-		mask = ((~t.Mask) << 1) & 0xfffff;
-		saddr = (t.VPN2 >> 12) + t.Mask + 1;
-		eaddr = saddr + t.Mask + 1;
+		mask = ((~t.Mask()) << 1) & 0xfffff;
+		saddr = (t.VPN2() >> 12) + t.Mask() + 1;
+		eaddr = saddr + t.Mask() + 1;
 		//	Console.WriteLn("Clear TLB: %08x ~ %08x",saddr,eaddr-1);
 		for (addr = saddr; addr < eaddr; addr++)
 		{
-			if ((addr & mask) == ((t.VPN2 >> 12) & mask))
+			if ((addr & mask) == ((t.VPN2() >> 12) & mask))
 			{ //match
 				memClearPageAddr(addr << 12);
 				Cpu->Clear(addr << 12, 0x400);
 			}
 		}
 	}
+
+	for (size_t i = 0; i < cachedTlbs.count; i++)
+	{
+		if (cachedTlbs.PFN0s[i] == t.PFN0() && cachedTlbs.PFN1s[i] == t.PFN1() && cachedTlbs.PageMasks[i] == ConvertPageMask(t.PageMask.UL))
+		{
+			for (size_t j = i; j < cachedTlbs.count - 1; j++)
+			{
+				cachedTlbs.CacheEnabled0[j] = cachedTlbs.CacheEnabled0[j + 1];
+				cachedTlbs.CacheEnabled1[j] = cachedTlbs.CacheEnabled1[j + 1];
+				cachedTlbs.PFN0s[j] = cachedTlbs.PFN0s[j + 1];
+				cachedTlbs.PFN1s[j] = cachedTlbs.PFN1s[j + 1];
+				cachedTlbs.PageMasks[j] = cachedTlbs.PageMasks[j + 1];
+			}
+			cachedTlbs.count--;
+			break;
+		}
+	}
 }

 void WriteTLB(int i)
 {
-	tlb[i].PageMask = cpuRegs.CP0.n.PageMask;
-	tlb[i].EntryHi = cpuRegs.CP0.n.EntryHi;
-	tlb[i].EntryLo0 = cpuRegs.CP0.n.EntryLo0;
-	tlb[i].EntryLo1 = cpuRegs.CP0.n.EntryLo1;
+	tlb[i].PageMask.UL = cpuRegs.CP0.n.PageMask;
+	tlb[i].EntryHi.UL = cpuRegs.CP0.n.EntryHi;
+	tlb[i].EntryLo0.UL = cpuRegs.CP0.n.EntryLo0;
+	tlb[i].EntryLo1.UL = cpuRegs.CP0.n.EntryLo1;

-	tlb[i].Mask = (cpuRegs.CP0.n.PageMask >> 13) & 0xfff;
-	tlb[i].nMask = (~tlb[i].Mask) & 0xfff;
-	tlb[i].VPN2 = ((cpuRegs.CP0.n.EntryHi >> 13) & (~tlb[i].Mask)) << 13;
-	tlb[i].ASID = cpuRegs.CP0.n.EntryHi & 0xfff;
-	tlb[i].G = cpuRegs.CP0.n.EntryLo0 & cpuRegs.CP0.n.EntryLo1 & 0x1;
-	tlb[i].PFN0 = (((cpuRegs.CP0.n.EntryLo0 >> 6) & 0xFFFFF) & (~tlb[i].Mask)) << 12;
-	tlb[i].PFN1 = (((cpuRegs.CP0.n.EntryLo1 >> 6) & 0xFFFFF) & (~tlb[i].Mask)) << 12;
-	tlb[i].S = cpuRegs.CP0.n.EntryLo0 & 0x80000000;
+	// Setting the cache mode to reserved values is vaguely defined in the manual.
+	// I found that SPR is set to cached regardless.
+	// Non-SPR entries default to uncached on reserved cache modes.
+	if (tlb[i].isSPR())
+	{
+		tlb[i].EntryLo0.C = 3;
+		tlb[i].EntryLo1.C = 3;
+	}
+	else
+	{
+		if (!tlb[i].EntryLo0.isValidCacheMode())
+			tlb[i].EntryLo0.C = 2;
+		if (!tlb[i].EntryLo1.isValidCacheMode())
+			tlb[i].EntryLo1.C = 2;
+	}
+
+	if (!tlb[i].isSPR() && ((tlb[i].EntryLo0.V && tlb[i].EntryLo0.isCached()) || (tlb[i].EntryLo1.V && tlb[i].EntryLo1.isCached())))
+	{
+		const size_t idx = cachedTlbs.count;
+		cachedTlbs.CacheEnabled0[idx] = tlb[i].EntryLo0.isCached() ? ~0 : 0;
+		cachedTlbs.CacheEnabled1[idx] = tlb[i].EntryLo1.isCached() ? ~0 : 0;
+		cachedTlbs.PFN1s[idx] = tlb[i].PFN1();
+		cachedTlbs.PFN0s[idx] = tlb[i].PFN0();
+		cachedTlbs.PageMasks[idx] = ConvertPageMask(tlb[i].PageMask.UL);
+
+		cachedTlbs.count++;
+	}

 	MapTLB(tlb[i], i);
 }
@@ -355,49 +400,57 @@ namespace COP0 {
 			cpuRegs.CP0.n.Index, cpuRegs.CP0.n.PageMask, cpuRegs.CP0.n.EntryHi,
 			cpuRegs.CP0.n.EntryLo0, cpuRegs.CP0.n.EntryLo1);

-		int i = cpuRegs.CP0.n.Index & 0x3f;
+		const u8 i = cpuRegs.CP0.n.Index & 0x3f;

-		cpuRegs.CP0.n.PageMask = tlb[i].PageMask;
-		cpuRegs.CP0.n.EntryHi = tlb[i].EntryHi & ~(tlb[i].PageMask | 0x1f00);
-		cpuRegs.CP0.n.EntryLo0 = (tlb[i].EntryLo0 & ~1) | ((tlb[i].EntryHi >> 12) & 1);
-		cpuRegs.CP0.n.EntryLo1 = (tlb[i].EntryLo1 & ~1) | ((tlb[i].EntryHi >> 12) & 1);
+		if (i > 47)
+		{
+			Console.Warning("TLBR with index > 47! (%d)", i);
+			return;
+		}
+
+		cpuRegs.CP0.n.PageMask = tlb[i].PageMask.Mask << 13;
+		cpuRegs.CP0.n.EntryHi = tlb[i].EntryHi.UL & ~((tlb[i].PageMask.Mask << 13) | 0x1f00);
+		cpuRegs.CP0.n.EntryLo0 = tlb[i].EntryLo0.UL & ~(0xFC000000) & ~1;
+		cpuRegs.CP0.n.EntryLo1 = tlb[i].EntryLo1.UL & ~(0x7C000000) & ~1;
+		// "If both the Global bit of EntryLo0 and EntryLo1 are set to 1, the processor ignores the ASID during TLB lookup."
+		// This is reflected during TLBR, where G is only set if both EntryLo0 and EntryLo1 are global.
+		cpuRegs.CP0.n.EntryLo0 |= (tlb[i].EntryLo0.UL & 1) & (tlb[i].EntryLo1.UL & 1);
+		cpuRegs.CP0.n.EntryLo1 |= (tlb[i].EntryLo0.UL & 1) & (tlb[i].EntryLo1.UL & 1);
 	}

 	void TLBWI()
 	{
-		int j = cpuRegs.CP0.n.Index & 0x3f;
+		const u8 j = cpuRegs.CP0.n.Index & 0x3f;

-		//if (j > 48) return;
+		if (j > 47)
+		{
+			Console.Warning("TLBWI with index > 47! (%d)", j);
+			return;
+		}

 		COP0_LOG("COP0_TLBWI %d:%x,%x,%x,%x",
 			cpuRegs.CP0.n.Index, cpuRegs.CP0.n.PageMask, cpuRegs.CP0.n.EntryHi,
 			cpuRegs.CP0.n.EntryLo0, cpuRegs.CP0.n.EntryLo1);

 		UnmapTLB(tlb[j], j);
-		tlb[j].PageMask = cpuRegs.CP0.n.PageMask;
-		tlb[j].EntryHi = cpuRegs.CP0.n.EntryHi;
-		tlb[j].EntryLo0 = cpuRegs.CP0.n.EntryLo0;
-		tlb[j].EntryLo1 = cpuRegs.CP0.n.EntryLo1;
 		WriteTLB(j);
 	}

 	void TLBWR()
 	{
-		int j = cpuRegs.CP0.n.Random & 0x3f;
+		const u8 j = cpuRegs.CP0.n.Random & 0x3f;

-		//if (j > 48) return;
+		if (j > 47)
+		{
+			Console.Warning("TLBWR with random > 47! (%d)", j);
+			return;
+		}

 		DevCon.Warning("COP0_TLBWR %d:%x,%x,%x,%x\n",
 			cpuRegs.CP0.n.Random, cpuRegs.CP0.n.PageMask, cpuRegs.CP0.n.EntryHi,
 			cpuRegs.CP0.n.EntryLo0, cpuRegs.CP0.n.EntryLo1);

-		//if (j > 48) return;
-
 		UnmapTLB(tlb[j], j);
-		tlb[j].PageMask = cpuRegs.CP0.n.PageMask;
-		tlb[j].EntryHi = cpuRegs.CP0.n.EntryHi;
-		tlb[j].EntryLo0 = cpuRegs.CP0.n.EntryLo0;
-		tlb[j].EntryLo1 = cpuRegs.CP0.n.EntryLo1;
 		WriteTLB(j);
 	}

@@ -422,7 +475,7 @@ namespace COP0 {
 		cpuRegs.CP0.n.Index = 0xFFFFFFFF;
 		for (i = 0; i < 48; i++)
 		{
-			if (tlb[i].VPN2 == ((~tlb[i].Mask) & (EntryHi32.s.VPN2)) && ((tlb[i].G & 1) || ((tlb[i].ASID & 0xff) == EntryHi32.s.ASID)))
+			if (tlb[i].VPN2() == ((~tlb[i].Mask()) & (EntryHi32.s.VPN2)) && ((tlb[i].isGlobal()) || ((tlb[i].EntryHi.ASID & 0xff) == EntryHi32.s.ASID)))
 			{
 				cpuRegs.CP0.n.Index = i;
 				break;
--- 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/DebugTools/SymbolGuardian.h
+++ b/pcsx2/DebugTools/SymbolGuardian.h
@@ -6,6 +6,7 @@
 #include <atomic>
 #include <thread>
 #include <functional>
+#include <mutex>
 #include <shared_mutex>

 #include <ccc/ast.h>
--- 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/R5900.cpp
+++ b/pcsx2/R5900.cpp
@@ -36,6 +36,8 @@ u32 EEoCycle;

 alignas(16) cpuRegistersPack _cpuRegistersPack;
 alignas(16) tlbs tlb[48];
+cachedTlbs_t cachedTlbs;
+
 R5900cpu *Cpu = NULL;

 static constexpr uint eeWaitCycles = 3072;
@@ -59,6 +61,7 @@ void cpuReset()
 	std::memset(&cpuRegs, 0, sizeof(cpuRegs));
 	std::memset(&fpuRegs, 0, sizeof(fpuRegs));
 	std::memset(&tlb, 0, sizeof(tlb));
+	cachedTlbs.count = 0;

 	cpuRegs.pc				= 0xbfc00000; //set pc reg to stack
 	cpuRegs.CP0.n.Config	= 0x440;
--- a/pcsx2/R5900.h
+++ b/pcsx2/R5900.h
@@ -5,6 +5,8 @@

 #include "common/Pcsx2Defs.h"

+#include <array>
+
 // --------------------------------------------------------------------------------------
 //  EE Bios function name tables.
 // --------------------------------------------------------------------------------------
@@ -160,17 +162,68 @@ struct fpuRegisters {
 	u32 ACCflag;        // an internal accumulator overflow flag
 };

+union PageMask_t
+{
+	struct
+	{
+		u32 : 13;
+		u32 Mask : 12;
+		u32 : 7;
+	};
+	u32 UL;
+};
+
+union EntryHi_t
+{
+	struct
+	{
+		u32 ASID:8;
+		u32 : 5;
+		u32 VPN2:19;
+	};
+	u32 UL;
+};
+
+union EntryLo_t
+{
+	struct
+	{
+		u32 G:1;
+		u32 V:1;
+		u32 D:1;
+		u32 C:3;
+		u32 PFN:20;
+		u32 : 5;
+		u32 S : 1; // Only used in EntryLo0
+	};
+	u32 UL;
+
+	constexpr bool isCached() const { return C == 0x3; }
+	constexpr bool isValidCacheMode() const { return C == 0x2 || C == 0x3 || C == 0x7; }
+};
+
 struct tlbs
 {
-	u32 PageMask,EntryHi;
-	u32 EntryLo0,EntryLo1;
-	u32 Mask, nMask;
-	u32 G;
-	u32 ASID;
-	u32 VPN2;
-	u32 PFN0;
-	u32 PFN1;
-	u32 S;
+	PageMask_t PageMask;
+	EntryHi_t EntryHi;
+	EntryLo_t EntryLo0;
+	EntryLo_t EntryLo1;
+
+	// (((cpuRegs.CP0.n.EntryLo0 >> 6) & 0xFFFFF) & (~tlb[i].Mask())) << 12;
+	constexpr u32 PFN0() const { return (EntryLo0.PFN & ~Mask()) << 12; }
+	constexpr u32 PFN1() const { return (EntryLo1.PFN & ~Mask()) << 12; }
+	constexpr u32 VPN2() const {return ((EntryHi.VPN2) & (~Mask())) << 13; }
+	constexpr u32 Mask() const { return PageMask.Mask; }
+	constexpr bool isGlobal() const { return EntryLo0.G && EntryLo1.G; }
+	constexpr bool isSPR() const { return EntryLo0.S; }
+
+	constexpr bool operator==(const tlbs& other) const
+	{
+		return PageMask.UL == other.PageMask.UL &&
+			   EntryHi.UL == other.EntryHi.UL &&
+			   EntryLo0.UL == other.EntryLo0.UL &&
+			   EntryLo1.UL == other.EntryLo1.UL;
+	}
 };

 #ifndef _PC_
@@ -211,6 +264,19 @@ struct cpuRegistersPack
 alignas(16) extern cpuRegistersPack _cpuRegistersPack;
 alignas(16) extern tlbs tlb[48];

+struct cachedTlbs_t
+{
+	u32 count;
+
+	alignas(16) std::array<u32, 48> PageMasks;
+	alignas(16) std::array<u32, 48> PFN1s;
+	alignas(16) std::array<u32, 48> CacheEnabled1;
+	alignas(16) std::array<u32, 48> PFN0s;
+	alignas(16) std::array<u32, 48> CacheEnabled0;
+};
+
+extern cachedTlbs_t cachedTlbs;
+
 static cpuRegisters& cpuRegs = _cpuRegistersPack.cpuRegs;
 static fpuRegisters& fpuRegs = _cpuRegistersPack.fpuRegs;

--- 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/SIO/Sio.cpp
+++ b/pcsx2/SIO/Sio.cpp
@@ -5,6 +5,7 @@

 #include "SIO/SioTypes.h"
 #include "SIO/Memcard/MemoryCardProtocol.h"
+#include "Counters.h"

 #include "Host.h"
 #include "IconsPromptFont.h"
@@ -128,6 +129,8 @@ void AutoEject::ClearAll()
 // unsafe to shutdown the VM due to memcard access.
 static std::atomic_uint32_t currentBusyTicks = 0;

+uint32_t sioLastFrameMcdBusy = 0;
+
 void MemcardBusy::Decrement()
 {
 	if (currentBusyTicks.load(std::memory_order_relaxed) == 0)
@@ -139,6 +142,7 @@ void MemcardBusy::Decrement()
 void MemcardBusy::SetBusy()
 {
 	currentBusyTicks.store(300, std::memory_order_release);
+	sioLastFrameMcdBusy = g_FrameCount;
 }

 bool MemcardBusy::IsBusy()
@@ -149,4 +153,15 @@ bool MemcardBusy::IsBusy()
 void MemcardBusy::ClearBusy()
 {
 	currentBusyTicks.store(0, std::memory_order_release);
+	sioLastFrameMcdBusy = 0;
+}
+
+#include "common/Console.h"
+void MemcardBusy::CheckSaveStateDependency()
+{
+	if (g_FrameCount - sioLastFrameMcdBusy > NUM_FRAMES_BEFORE_SAVESTATE_DEPENDENCY_WARNING)
+	{
+		Host::AddIconOSDMessage("MemcardBusy", ICON_PF_MEMORY_CARD,
+			TRANSLATE_SV("MemoryCard", "The virtual console hasn't saved to your memory card for quite some time. Savestates should not be used in place of in-game saves."), Host::OSD_INFO_DURATION);
+	}
 }
--- a/pcsx2/SIO/Sio.h
+++ b/pcsx2/SIO/Sio.h
@@ -118,10 +118,19 @@ namespace AutoEject
 	extern void ClearAll();
 } // namespace AutoEject

+// ~1 hour of memory card inactivity.
+constexpr u32 NUM_FRAMES_BEFORE_SAVESTATE_DEPENDENCY_WARNING = 60 * 60 * 60;
+
+// Set to the current frame count when there is memory card activity.
+// Used to detect the last frame when memory card activity was detected,
+// and if it exceeds a certain threshold, warns on savestate save/load.
+extern uint32_t sioLastFrameMcdBusy;
+
 namespace MemcardBusy
 {
 	extern void Decrement();
 	extern void SetBusy();
 	extern bool IsBusy();
 	extern void ClearBusy();
+	extern void CheckSaveStateDependency();
 }
--- a/pcsx2/SIO/Sio2.cpp
+++ b/pcsx2/SIO/Sio2.cpp
@@ -541,5 +541,6 @@ bool Sio2::DoState(StateWrapper& sw)
 		}
 	}

+	sw.Do(&sioLastFrameMcdBusy);
 	return sw.IsGood();
 }
--- a/pcsx2/SaveState.cpp
+++ b/pcsx2/SaveState.cpp
@@ -15,12 +15,13 @@
 #include "Host.h"
 #include "MTGS.h"
 #include "MTVU.h"
-#include "SIO/Pad/Pad.h"
 #include "Patch.h"
 #include "R3000A.h"
+#include "SIO/Multitap/MultitapProtocol.h"
+#include "SIO/Pad/Pad.h"
+#include "SIO/Sio.h"
 #include "SIO/Sio0.h"
 #include "SIO/Sio2.h"
-#include "SIO/Multitap/MultitapProtocol.h"
 #include "SPU2/spu2.h"
 #include "SaveState.h"
 #include "StateWrapper.h"
@@ -182,6 +183,7 @@ bool SaveStateBase::FreezeInternals(Error* error)
 	Freeze(psxRegs);		// iop regs
 	Freeze(fpuRegs);
 	Freeze(tlb);			// tlbs
+	Freeze(cachedTlbs);		// cached tlbs
 	Freeze(AllowParams1);	//OSDConfig written (Fast Boot)
 	Freeze(AllowParams2);

--- a/pcsx2/SaveState.h
+++ b/pcsx2/SaveState.h
@@ -25,7 +25,7 @@ enum class FreezeAction
 // [SAVEVERSION+]
 // This informs the auto updater that the users savestates will be invalidated.

-static const u32 g_SaveVersion = (0x9A51 << 16) | 0x0000;
+static const u32 g_SaveVersion = (0x9A53 << 16) | 0x0000;


 // the freezing data between submodules and core
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mrlinkwii	1feb31498d	GameDB: fix some names	2025-01-02 21:19:35 +01:00
nassau-tk	f3632c44c8	GameDB: Fix&Add few Japanese Game Titles	2024-12-31 21:14:13 -06:00
PCSX2 Bot	32a6e62212	[ci skip] Qt: Update Base Translation.	2025-01-01 01:27:00 +01:00
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
lightningterror	843566eb49	Qt: Properly disable all dumping options if draw dumping is disabled. Also move around sone options.	2024-12-28 17:04:33 +01:00
nassau-tk	d63733830f	GameDB: Disable MTVU for some games	2024-12-27 23:43:51 -06:00
nassau-tk	3ebd496c37	GameDB: Fix titles for Japanese games	2024-12-27 23:43:51 -06:00
Mrlinkwii	f0f2b013fc	Redump: update database	2024-12-27 14:30:23 -05:00
Ty Lamontagne	9a75509614	EE Cache: Fix up TLB related register fetching	2024-12-27 14:18:32 -05:00
Ty Lamontagne	c513a29bcf	EE Cache: Freeze cached entries in sstates [SAVEVERSION+]	2024-12-27 14:18:32 -05:00
Ty Lamontagne	5d39c884b5	R5900: Improve the EE cache performance with SIMD	2024-12-27 14:18:32 -05:00
TheLastRar	6a0f811812	Build: Always set EnhancedInstructionSet for AVX2 configs Replaces the march arguments for clang-cl	2024-12-24 22:05:50 -05:00
TheLastRar	f509fb6950	CI/Appimage: Suppress error when no tags are present	2024-12-24 12:00:56 -05:00
Ziemas	33a475a456	DebugTools: Fix GCC build, missing include	2024-12-24 13:47:49 +01:00
JordanTheToaster	d2fb90a700	GameDB: Various fixes	2024-12-23 19:40:29 -05:00
PCSX2 Bot	a34467dccd	[ci skip] PAD: Update to latest controller database.	2024-12-23 17:58:45 +01:00
Hallkezz	c6d0f5e3cd	GameDB: Change recommended blending level 2 to 4 for Twisted Metal: Head-On [Extra Twisted Edition]. (#12107 ) Fixes menu text brightness in Twisted Metal: Head-On [Extra Twisted Edition].	2024-12-22 13:03:40 +01:00
PCSX2 Bot	34c9590cf1	[ci skip] Qt: Update Base Translation.	2024-12-18 19:06:27 -05:00
Ty Lamontagne	a2c7542e48	Savestates: Warn on savestate load and saves without mcd activity [SAVEVERSION+]	2024-12-18 18:01:30 -05:00
TheLastRar	72a9f18456	3rdparty: Sync libchdr to commit cb077337d53392454e7100a0fd07139ca678e527	2024-12-18 17:58:44 -05:00
TheLastRar	7f59757eea	3rdparty/libchdr: Purge almost all remaining patches Leaving only the chd_read_header_* functions, of which exists an equivalent in later libchdr versions	2024-12-18 17:58:44 -05:00
TheLastRar	3b89020082	3rdparty/libchdr: Purge now unused patches	2024-12-18 16:23:49 -05:00
TheLastRar	a7b07eb53f	ChdReader: Use core_file to implement precaching	2024-12-18 16:23:49 -05:00
TheLastRar	58d13dac34	FileSystem: Add ReadFileWithPartialProgress for multiple files	2024-12-18 16:23:49 -05:00