FullscreenUI: Align setting descriptions with Qt

Signed-off-by: SternXD <stern@sidestore.io>

pcsx2-qt/Settings/AchievementSettingsWidget.cpp

@@ -54,9 +54,17 @@ AchievementSettingsWidget::AchievementSettingsWidget(SettingsWindow* settings_di
 	dialog()->registerWidgetHelp(m_ui.enable, tr("Enable Achievements"), tr("Unchecked"), tr("When enabled and logged in, PCSX2 will scan for achievements on startup."));
 	dialog()->registerWidgetHelp(m_ui.hardcoreMode, tr("Enable Hardcore Mode"), tr("Unchecked"), tr("\"Challenge\" mode for achievements, including leaderboard tracking. Disables save state, cheats, and slowdown functions."));
 	dialog()->registerWidgetHelp(m_ui.achievementNotifications, tr("Show Achievement Notifications"), tr("Checked"), tr("Displays popup messages on events such as achievement unlocks and game completion."));
+	dialog()->registerWidgetHelp(m_ui.achievementNotificationsDuration, tr("Unlock Notification Duration"), tr("3 Seconds"), tr("Determines the display duration for achievement unlock popups."));
 	dialog()->registerWidgetHelp(m_ui.leaderboardNotifications, tr("Show Leaderboard Notifications"), tr("Checked"), tr("Displays popup messages when starting, submitting, or failing a leaderboard challenge."));
+	dialog()->registerWidgetHelp(m_ui.leaderboardNotificationsDuration, tr("Leaderboard Notification Duration"), tr("3 Seconds"), tr("Determines the display duration for leaderboard notification popups."));
 	dialog()->registerWidgetHelp(m_ui.soundEffects, tr("Enable Sound Effects"), tr("Checked"), tr("Plays sound effects for events such as achievement unlocks and leaderboard submissions."));
 	dialog()->registerWidgetHelp(m_ui.soundEffectsBox, tr("Custom Sound Effect"), tr("Any"), tr("Customize the sound effect that are played whenever you received a notification, earned an achievement or submitted an entry to the leaderboard."));
+	dialog()->registerWidgetHelp(m_ui.notificationSound, tr("Notification Sound"), tr("Checked"), tr("Plays a sound effect when achievement notifications appear."));
+	dialog()->registerWidgetHelp(m_ui.notificationSoundPath, tr("Notification Sound Path"), tr("Default"), tr("Custom audio file to play for achievement notification alerts."));
+	dialog()->registerWidgetHelp(m_ui.unlockSound, tr("Unlock Sound"), tr("Checked"), tr("Plays a sound effect when an achievement is unlocked."));
+	dialog()->registerWidgetHelp(m_ui.unlockSoundPath, tr("Unlock Sound Path"), tr("Default"), tr("Custom audio file to play when an achievement is unlocked."));
+	dialog()->registerWidgetHelp(m_ui.lbSound, tr("Leaderboard Sound"), tr("Checked"), tr("Plays a sound effect when submitting a leaderboard entry."));
+	dialog()->registerWidgetHelp(m_ui.lbSoundPath, tr("Leaderboard Sound Path"), tr("Default"), tr("Custom audio file to play when submitting a leaderboard score."));
 	dialog()->registerWidgetHelp(m_ui.overlays, tr("Enable In-Game Overlays"), tr("Checked"), tr("Shows icons in the screen when a challenge/primed achievement is active."));
 	dialog()->registerWidgetHelp(m_ui.leaderboardOverlays, tr("Enable In-Game Leaderboard Overlays"), tr("Checked"), tr("Shows icons in the screen when leaderboard tracking is active."));
 	dialog()->registerWidgetHelp(m_ui.overlayPosition, tr("Overlay Position"), tr("Bottom Right"), tr("Determines where achievement/leaderboard overlays are positioned on the screen."));

pcsx2-qt/Settings/AdvancedSettingsWidget.cpp

@@ -75,13 +75,14 @@ AdvancedSettingsWidget::AdvancedSettingsWidget(SettingsWindow* settings_dialog,
 		   "The default value handles the vast majority of games; <b>modifying this setting when a game is not having a visible problem can cause instability.</b>"));
 
 	dialog()->registerWidgetHelp(m_ui.eeRecompiler, tr("Enable Recompiler"), tr("Checked"),
-		tr("Performs just-in-time binary translation of 64-bit MIPS-IV machine code to x86."));
+		tr("Performs just-in-time binary translation of 64-bit MIPS-IV machine code to native code."));
 
 	//: Wait loop: When the game makes the CPU do nothing (loop/spin) while it waits for something to happen (usually an interrupt).
 	dialog()->registerWidgetHelp(m_ui.eeWaitLoopDetection, tr("Wait Loop Detection"), tr("Checked"),
 		tr("Moderate speedup for some games, with no known side effects."));
 
-	dialog()->registerWidgetHelp(m_ui.eeCache, tr("Enable Cache (Slow)"), tr("Unchecked"), tr("Interpreter only, provided for diagnostic."));
+	dialog()->registerWidgetHelp(m_ui.eeCache, tr("Enable Cache (Slow)"), tr("Unchecked"),
+		tr("Enables emulation of the EE's hardware cache. Interpreter only, provided for diagnostics."));
 
 	//: INTC = Name of a PS2 register, leave as-is. "spin" = to make a cpu (or gpu) actively do nothing while you wait for something.  Like spinning in a circle, you're moving but not actually going anywhere.
 	dialog()->registerWidgetHelp(m_ui.eeINTCSpinDetection, tr("INTC Spin Detection"), tr("Checked"),
@@ -117,17 +118,19 @@ AdvancedSettingsWidget::AdvancedSettingsWidget(SettingsWindow* settings_dialog,
 		   "Safe for most games, but a few games may exhibit graphical errors."));
 
 	//: VU0 = Vector Unit 0. One of the PS2's processors.
-	dialog()->registerWidgetHelp(m_ui.vu0Recompiler, tr("Enable VU0 Recompiler (Micro Mode)"), tr("Checked"), tr("Enables VU0 Recompiler."));
+	dialog()->registerWidgetHelp(m_ui.vu0Recompiler, tr("Enable VU0 Recompiler (Micro Mode)"), tr("Checked"),
+		tr("Performs just-in-time binary translation of Vector Unit 0 (VU0) microprograms to native code."));
 
 	//: VU1 = Vector Unit 1. One of the PS2's processors.
-	dialog()->registerWidgetHelp(m_ui.vu1Recompiler, tr("Enable VU1 Recompiler"), tr("Checked"), tr("Enables VU1 Recompiler."));
+	dialog()->registerWidgetHelp(m_ui.vu1Recompiler, tr("Enable VU1 Recompiler"), tr("Checked"),
+		tr("Performs just-in-time binary translation of Vector Unit 1 (VU1) microprograms to native code."));
 
 	dialog()->registerWidgetHelp(
 		//: mVU = PCSX2's recompiler for VU (Vector Unit) code (full name: microVU)
 		m_ui.vuFlagHack, tr("mVU Flag Hack"), tr("Checked"), tr("Good speedup and high compatibility, may cause graphical errors."));
 
 	dialog()->registerWidgetHelp(m_ui.iopRecompiler, tr("Enable Recompiler"), tr("Checked"),
-		tr("Performs just-in-time binary translation of 32-bit MIPS-I machine code to x86."));
+		tr("Performs just-in-time binary translation of 32-bit MIPS-I machine code to native code."));
 
 	dialog()->registerWidgetHelp(m_ui.gameFixes, tr("Enable Game Fixes"), tr("Checked"),
 		tr("Automatically loads and applies fixes to known problematic games on game start."));
@@ -148,6 +151,11 @@ AdvancedSettingsWidget::AdvancedSettingsWidget(SettingsWindow* settings_dialog,
 	dialog()->registerWidgetHelp(m_ui.backupSaveStates, tr("Create Save State Backups"), tr("Checked"),
 		//: Do not translate the ".backup" extension.
 		tr("Creates a backup copy of a save state if it already exists when the save is created. The backup copy has a .backup suffix."));
+
+	dialog()->registerWidgetHelp(m_ui.pineEnable, tr("Enable PINE"), tr("Unchecked"),
+		tr("Enables the PINE Inter-Process Communication system, allowing external programs to interact with the emulator."));
+	dialog()->registerWidgetHelp(m_ui.pineSlot, tr("PINE Slot"), tr("28011"),
+		tr("The network port slot used for PINE IPC connections."));
 }
 
 AdvancedSettingsWidget::~AdvancedSettingsWidget() = default;

pcsx2-qt/Settings/AudioSettingsWidget.cpp

@@ -103,6 +103,15 @@ AudioSettingsWidget::AudioSettingsWidget(SettingsWindow* settings_dialog, QWidge
 		m_ui.outputLatencyMS, tr("Output Latency"), tr("%1 ms").arg(AudioStreamParameters::DEFAULT_OUTPUT_LATENCY_MS),
 		tr("Determines the latency from the buffer to the host audio output. This can be set lower than the target latency "
 		   "to reduce audio delay."));
+	dialog()->registerWidgetHelp(
+		m_ui.outputLatencyMinimal, tr("Minimal Output Latency"), tr("Unchecked"),
+		tr("When enabled, the minimum supported output latency will be used for the host API."));
+	dialog()->registerWidgetHelp(
+		m_ui.driver, tr("Driver"), tr("Default"),
+		tr("Selects the host audio driver used by the audio backend."));
+	dialog()->registerWidgetHelp(
+		m_ui.outputDevice, tr("Output Device"), tr("Default"),
+		tr("Selects the physical audio output device on the host machine."));
 	dialog()->registerWidgetHelp(m_ui.standardVolume, tr("Standard Volume"), "100%",
 		tr("Controls the volume of the audio played on the host at normal speed."));
 	dialog()->registerWidgetHelp(m_ui.fastForwardVolume, tr("Fast Forward Volume"), "100%",

pcsx2-qt/Settings/BIOSSettingsWidget.cpp

@@ -33,6 +33,9 @@ BIOSSettingsWidget::BIOSSettingsWidget(SettingsWindow* settings_dialog, QWidget*
 	dialog()->registerWidgetHelp(m_ui.fastBootFastForward, tr("Fast Forward Boot"), tr("Unchecked"),
 		tr("Removes emulation speed throttle until the game starts to reduce startup time."));
 
+	dialog()->registerWidgetHelp(m_ui.searchDirectory, tr("BIOS Directory"), tr("Default"),
+		tr("The directory searched by PCSX2 to detect valid PlayStation 2 BIOS ROM images."));
+
 	refreshList();
 
 	connect(m_ui.searchDirectory, &QLineEdit::textChanged, this, &BIOSSettingsWidget::refreshList);

pcsx2-qt/Settings/DEV9SettingsWidget.cpp

@@ -190,6 +190,43 @@ DEV9SettingsWidget::DEV9SettingsWidget(SettingsWindow* settings_dialog, QWidget*
 	SettingWidgetBinder::SettingAccessor<QSpinBox>::connectValueChanged(m_ui.hddSizeSpinBox, [&]() { onHddSizeAccessorSpin(); });
 
 	connect(m_ui.hddCreate, &QPushButton::clicked, this, &DEV9SettingsWidget::onHddCreateClicked);
+
+	dialog()->registerWidgetHelp(m_ui.ethEnabled, tr("Enable Network Adapter"), tr("Unchecked"),
+		tr("Enables the network adapter for online functionality and LAN play."));
+	dialog()->registerWidgetHelp(m_ui.ethDevType, tr("Device Type"), tr("Sockets"),
+		tr("Selects the network emulation backend API (e.g. Sockets, TAP, PCAP Bridged, or PCAP Switched)."));
+	dialog()->registerWidgetHelp(m_ui.ethDev, tr("Adapter / Interface"), tr("Default"),
+		tr("Selects the host network adapter interface to bind emulated network traffic to."));
+	dialog()->registerWidgetHelp(m_ui.ethInterceptDHCP, tr("Intercept DHCP"), tr("Unchecked"),
+		tr("When enabled, DHCP packets will be intercepted and replaced with internal responses."));
+	dialog()->registerWidgetHelp(m_ui.ethPS2Addr, tr("PS2 IP Address"), tr("N/A"),
+		tr("IP address for the PS2 virtual network adapter."));
+	dialog()->registerWidgetHelp(m_ui.ethNetMask, tr("Subnet Mask"), tr("N/A"),
+		tr("Subnet mask for the PS2 virtual network adapter."));
+	dialog()->registerWidgetHelp(m_ui.ethNetMaskAuto, tr("Auto Subnet Mask"), tr("Checked"),
+		tr("Automatically determine the subnet mask based on the IP address class."));
+	dialog()->registerWidgetHelp(m_ui.ethGatewayAddr, tr("Gateway Address"), tr("N/A"),
+		tr("Gateway address for the PS2 virtual network adapter."));
+	dialog()->registerWidgetHelp(m_ui.ethGatewayAuto, tr("Auto Gateway"), tr("Checked"),
+		tr("Automatically determine the gateway address based on the IP address."));
+	dialog()->registerWidgetHelp(m_ui.ethDNS1Mode, tr("DNS1 Mode"), tr("Auto"),
+		tr("Determines how primary DNS requests are handled."));
+	dialog()->registerWidgetHelp(m_ui.ethDNS1Addr, tr("DNS1 Address"), tr("N/A"),
+		tr("Primary DNS server address for the PS2 virtual network adapter."));
+	dialog()->registerWidgetHelp(m_ui.ethDNS2Mode, tr("DNS2 Mode"), tr("Auto"),
+		tr("Determines how secondary DNS requests are handled."));
+	dialog()->registerWidgetHelp(m_ui.ethDNS2Addr, tr("DNS2 Address"), tr("N/A"),
+		tr("Secondary DNS server address for the PS2 virtual network adapter."));
+	dialog()->registerWidgetHelp(m_ui.hddEnabled, tr("Enable HDD"), tr("Unchecked"),
+		tr("Enables the internal Hard Disk Drive for expanded storage."));
+	dialog()->registerWidgetHelp(m_ui.hddFile, tr("HDD Image File"), tr("DEV9hdd.raw"),
+		tr("Path to the raw virtual hard disk image file on disk."));
+	dialog()->registerWidgetHelp(m_ui.hddLBA48, tr("Enable 48-Bit LBA"), tr("Unchecked"),
+		tr("Enables 48-bit Logical Block Addressing support for virtual hard drives larger than 128 GB."));
+	dialog()->registerWidgetHelp(m_ui.hddSizeSlider, tr("HDD Size"), tr("40 GB"),
+		tr("Specifies the capacity in gigabytes when creating a new virtual PS2 hard disk image."));
+	dialog()->registerWidgetHelp(m_ui.hddSizeSpinBox, tr("HDD Size"), tr("40 GB"),
+		tr("Specifies the capacity in gigabytes when creating a new virtual PS2 hard disk image."));
 }
 
 void DEV9SettingsWidget::onEthEnabledChanged(Qt::CheckState state)

pcsx2-qt/Settings/DebugAnalysisSettingsWidget.cpp

@@ -147,6 +147,10 @@ DebugAnalysisSettingsWidget::DebugAnalysisSettingsWidget(SettingsWindow* dialog,
 		m_dialog->registerWidgetHelp(m_ui.customAddressRange, tr("Custom Address Range"), tr("Unchecked"),
 			tr("Whether to look for functions from the address range specified (Checked), or from the ELF segment "
 			   "containing the entry point (Unchecked)."));
+		m_dialog->registerWidgetHelp(m_ui.addressRangeStart, tr("Scan Range Start Address"), tr("N/A"),
+			tr("Starting memory address (in hexadecimal) to begin scanning for functions."));
+		m_dialog->registerWidgetHelp(m_ui.addressRangeEnd, tr("Scan Range End Address"), tr("N/A"),
+			tr("Ending memory address (in hexadecimal) to stop scanning for functions."));
 	}
 	else
 	{

pcsx2-qt/Settings/DebugSettingsWidget.cpp

@@ -125,6 +125,41 @@ DebugSettingsWidget::DebugSettingsWidget(SettingsWindow* settings_dialog, QWidge
 	connect(m_gs.dumpGSData, &QCheckBox::checkStateChanged, this, &DebugSettingsWidget::onDrawDumpingChanged);
 	onDrawDumpingChanged();
 
+	dialog()->registerWidgetHelp(m_gs.dumpGSData, tr("Dump GS Draws"), tr("Unchecked"),
+		tr("Enables dumping of GS draws, textures, and render targets to disk for debugging."));
+	dialog()->registerWidgetHelp(m_gs.saveRT, tr("Save Render Targets"), tr("Unchecked"),
+		tr("Saves render target surfaces on each draw call when GS dumping is active."));
+	dialog()->registerWidgetHelp(m_gs.saveFrame, tr("Save Frames"), tr("Unchecked"),
+		tr("Saves completed frame buffer images when GS dumping is active."));
+	dialog()->registerWidgetHelp(m_gs.saveTexture, tr("Save Textures"), tr("Unchecked"),
+		tr("Saves source texture surfaces on each draw call when GS dumping is active."));
+	dialog()->registerWidgetHelp(m_gs.saveDepth, tr("Save Depth Buffer"), tr("Unchecked"),
+		tr("Saves depth buffer surfaces on each draw call when GS dumping is active."));
+	dialog()->registerWidgetHelp(m_gs.saveAlpha, tr("Save Alpha Channel"), tr("Unchecked"),
+		tr("Saves alpha channel data on each draw call when GS dumping is active."));
+	dialog()->registerWidgetHelp(m_gs.saveInfo, tr("Save GS State Info"), tr("Unchecked"),
+		tr("Saves text metadata describing the GS hardware register state on each draw call."));
+	dialog()->registerWidgetHelp(m_gs.saveTransferImages, tr("Save Transfer Images"), tr("Unchecked"),
+		tr("Saves host-to-local and local-to-host image transfer data when GS dumping is active."));
+	dialog()->registerWidgetHelp(m_gs.saveDrawStats, tr("Save Draw Statistics"), tr("Unchecked"),
+		tr("Saves performance metrics and statistics per draw call when GS dumping is active."));
+	dialog()->registerWidgetHelp(m_gs.saveFrameStats, tr("Save Frame Statistics"), tr("Unchecked"),
+		tr("Saves performance metrics and statistics per frame when GS dumping is active."));
+	dialog()->registerWidgetHelp(m_gs.saveHWConfig, tr("Save Hardware Config"), tr("Unchecked"),
+		tr("Records the host graphics hardware configuration and renderer settings in the GS dump."));
+	dialog()->registerWidgetHelp(m_gs.saveDrawStart, tr("Save Draw Range Start"), tr("N/A"),
+		tr("Starting draw call index within each frame to dump."));
+	dialog()->registerWidgetHelp(m_gs.saveDrawCount, tr("Save Draw Range Count"), tr("N/A"),
+		tr("Total number of draw calls to dump per frame after the starting draw index."));
+	dialog()->registerWidgetHelp(m_gs.saveFrameStart, tr("Save Frame Range Start"), tr("N/A"),
+		tr("Starting frame number to begin dumping GS data."));
+	dialog()->registerWidgetHelp(m_gs.saveFrameCount, tr("Save Frame Range Count"), tr("N/A"),
+		tr("Total number of consecutive frames to dump before stopping."));
+	dialog()->registerWidgetHelp(m_gs.hwDumpDirectory, tr("Hardware Dump Directory"), tr("Default"),
+		tr("Destination directory for dumps generated by the hardware renderer."));
+	dialog()->registerWidgetHelp(m_gs.swDumpDirectory, tr("Software Dump Directory"), tr("Default"),
+		tr("Destination directory for dumps generated by the software renderer."));
+
 #ifdef PCSX2_DEVBUILD
 	//////////////////////////////////////////////////////////////////////////
 	// Logging Settings

pcsx2-qt/Settings/FolderSettingsWidget.cpp

@@ -22,8 +22,20 @@ FolderSettingsWidget::FolderSettingsWidget(SettingsWindow* settings_dialog, QWid
 		"Folders", "Savestates", Path::Combine(EmuFolders::DataRoot, "sstates"));
 	SettingWidgetBinder::BindWidgetToFolderSetting(sif, m_ui.videoDumpingDirectory, m_ui.videoDumpingDirectoryBrowse, m_ui.videoDumpingDirectoryOpen, m_ui.videoDumpingDirectoryReset,
 		"Folders", "Videos", Path::Combine(EmuFolders::DataRoot, "videos"));
+	dialog()->registerWidgetHelp(m_ui.cache, tr("Cache Directory"), tr("Default"),
+		tr("Location used for caching compiled shaders, game covers, and temporary files."));
+	dialog()->registerWidgetHelp(m_ui.cheats, tr("Cheats Directory"), tr("Default"),
+		tr("Location where user pnach cheat files are stored."));
+	dialog()->registerWidgetHelp(m_ui.covers, tr("Covers Directory"), tr("Default"),
+		tr("Location where game box art and cover images are saved."));
+	dialog()->registerWidgetHelp(m_ui.snapshots, tr("Snapshots Directory"), tr("Default"),
+		tr("Location where screenshots taken during gameplay are saved."));
 	dialog()->registerWidgetHelp(m_ui.organizeSnapshotsByGame, tr("Save Snapshots in Game-Specific Folders"), tr("Unchecked"),
 		tr("Saves snapshots to per-game subfolders instead of a shared folder."));
+	dialog()->registerWidgetHelp(m_ui.saveStates, tr("Save States Directory"), tr("Default"),
+		tr("Location where save state files are saved and loaded from."));
+	dialog()->registerWidgetHelp(m_ui.videoDumpingDirectory, tr("Video Captures Directory"), tr("Default"),
+		tr("Location where video recordings captured from the emulator are saved."));
 	dialog()->registerWidgetHelp(m_ui.organizeVideoDumpByGame, tr("Save Video Recordings in Game-Specific Folders"), tr("Unchecked"),
 		tr("Saves video recordings to per-game subfolders instead of a shared folder."));
 }

pcsx2-qt/Settings/GameCheatSettingsWidget.cpp

@@ -61,6 +61,8 @@ GameCheatSettingsWidget::GameCheatSettingsWidget(SettingsWindow* settings_dialog
 	});
 	connect(dialog(), &SettingsWindow::discSerialChanged, this, &GameCheatSettingsWidget::reloadList);
 
+	dialog()->registerWidgetHelp(m_ui.enableCheats, tr("Enable Cheats"), tr("Unchecked"),
+		tr("Enables loading cheats from pnach files."));
 	dialog()->registerWidgetHelp(m_ui.allCRCsCheckbox, tr("Show Cheats For All CRCs"), tr("Checked"),
 		tr("Toggles scanning patch files for all CRCs of the game. With this enabled available patches for the game serial with different CRCs will also be loaded."));
 }

pcsx2-qt/Settings/GameSummaryWidget.cpp

@@ -53,6 +53,9 @@ GameSummaryWidget::GameSummaryWidget(const GameList::Entry* entry, SettingsWindo
 	m_ui.restoreTitle->setEnabled(has_custom_title);
 	m_ui.restoreRegion->setEnabled(has_custom_region);
 	m_ui.checkWiki->setEnabled(!entry->serial.empty());
+
+	dialog()->registerWidgetHelp(m_ui.inputProfile, tr("Input Profile"), tr("Shared (Default)"),
+		tr("Selects the controller input profile to use for this game. Choosing a specific profile allows custom controller bindings without changing global settings."));
 }
 
 GameSummaryWidget::~GameSummaryWidget() = default;

pcsx2-qt/Settings/GraphicsSettingsWidget.cpp

@@ -410,8 +410,14 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* settings_dialog,
 		onEnableAudioCaptureArgumentsChanged();
 	}
 
-	// Display tab
+	// Header & Display tab
 	{
+		dialog()->registerWidgetHelp(m_header.rendererDropdown, tr("Renderer"), tr("Automatic (Default)"),
+			tr("Selects the graphics renderer. Automatic will select the best available renderer for your hardware."));
+
+		dialog()->registerWidgetHelp(m_header.adapterDropdown, tr("Graphics Adapter"), tr("Default"),
+			tr("Selects which GPU or adapter to use for graphics rendering on systems with multiple graphics devices."));
+
 		dialog()->registerWidgetHelp(m_display.widescreenPatches, tr("Apply Widescreen Patches"), tr("Unchecked"),
 			tr("Automatically loads and applies widescreen patches on game start. Can cause issues."));
 
@@ -552,6 +558,9 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* settings_dialog,
 			   "May improve performance during readbacks but with a significant increase in power usage."));
 
 		// Software
+		dialog()->registerWidgetHelp(m_sw.swTextureFiltering, tr("Software Texture Filtering"), tr("Bilinear (PS2)"),
+			tr("Selects the texture filtering mode used by the software renderer."));
+
 		dialog()->registerWidgetHelp(m_sw.extraSWThreads, tr("Software Rendering Threads"), tr("2 threads"),
 			tr("Number of rendering threads: 0 for single thread, 2 or more for multithread (1 is for debugging). "
 			   "2 to 4 threads is recommended, any more than that is likely to be slower instead of faster."));
@@ -569,6 +578,9 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* settings_dialog,
 		dialog()->registerWidgetHelp(m_fixes.cpuSpriteRenderBW, tr("CPU Sprite Render Size"), tr("0 (Disabled)"),
 			tr("The maximum target memory width that will allow the CPU Sprite Renderer to activate on."));
 
+		dialog()->registerWidgetHelp(m_fixes.cpuSpriteRenderLevel, tr("CPU Sprite Render Level"), tr("Disabled"),
+			tr("Determines filter level for CPU sprite render."));
+
 		dialog()->registerWidgetHelp(m_fixes.cpuCLUTRender, tr("Software CLUT Render"), tr("0 (Disabled)"),
 			tr("Tries to detect when a game is drawing its own color palette and then renders it in software, instead of on the GPU."));
 
@@ -662,6 +674,9 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* settings_dialog,
 
 		dialog()->registerWidgetHelp(m_upscaling.nativePaletteDraw, tr("Unscaled Palette Texture Draws"), tr("Unchecked"),
 			tr("Forces palette texture draws to render at native resolution."));
+
+		dialog()->registerWidgetHelp(m_upscaling.nativeScaling, tr("Native Scaling"), tr("Off (Default)"),
+			tr("Emulates native PS2 coordinate scaling behavior when upscaling to reduce misalignment artifacts and seams in games that draw custom 2D elements."));
 	}
 
 	// Texture Replacement tab
@@ -677,6 +692,12 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* settings_dialog,
 		dialog()->registerWidgetHelp(m_texture.loadTextureReplacements, tr("Load Textures"), tr("Unchecked"), tr("Loads replacement textures where available and user-provided."));
 
 		dialog()->registerWidgetHelp(m_texture.precacheTextureReplacements, tr("Precache Textures"), tr("Unchecked"), tr("Preloads all replacement textures to memory. Not necessary with asynchronous loading."));
+
+		if (!dialog()->isPerGameSettings())
+		{
+			dialog()->registerWidgetHelp(m_texture.texturesDirectory, tr("Textures Directory"), tr("Default"),
+				tr("Directory where replacement texture packs are loaded from and where dumped textures are saved."));
+		}
 	}
 
 	// Post Processing tab
@@ -707,6 +728,12 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* settings_dialog,
 
 	// Recording tab
 	{
+		dialog()->registerWidgetHelp(m_capture.enableVideoCapture, tr("Capture Video"), tr("Checked"),
+			tr("Enables video recording during gameplay capture."));
+
+		dialog()->registerWidgetHelp(m_capture.captureContainer, tr("Container Format"), tr("MKV"),
+			tr("Selects the media container file format for video recordings."));
+
 		dialog()->registerWidgetHelp(m_capture.videoCaptureCodec, tr("Video Codec"), tr("Default"),
 			tr("Selects the Video Codec to be used for Video Capture. "
 			   "<b>If unsure, leave it on default.<b>"));
@@ -724,6 +751,11 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* settings_dialog,
 
 			   "<b>Be careful when using this setting especially when you are upscaling, as higher internal resolutions (above 4x) can result in very large video capture and can cause system overload.</b>"));
 
+		dialog()->registerWidgetHelp(m_capture.videoCaptureWidth, tr("Video Capture Width"), tr("1280"),
+			tr("Custom horizontal resolution width for video recordings when automatic resolution is unchecked."));
+
+		dialog()->registerWidgetHelp(m_capture.videoCaptureHeight, tr("Video Capture Height"), tr("720"),
+			tr("Custom vertical resolution height for video recordings when automatic resolution is unchecked."));
 
 		dialog()->registerWidgetHelp(m_capture.enableVideoCaptureArguments, tr("Enable Extra Video Arguments"), tr("Unchecked"), tr("Allows you to pass arguments to the selected video codec."));
 
@@ -732,6 +764,9 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* settings_dialog,
 			   "<b>You must use '=' to separate key from value and ':' to separate two pairs from each other.</b><br>"
 			   "For example: \"crf = 21 : preset = veryfast\""));
 
+		dialog()->registerWidgetHelp(m_capture.enableAudioCapture, tr("Capture Audio"), tr("Checked"),
+			tr("Enables audio stream recording into video captures."));
+
 		dialog()->registerWidgetHelp(m_capture.audioCaptureCodec, tr("Audio Codec"), tr("Default"),
 			tr("Selects the Audio Codec to be used for Video Capture. "
 			   "<b>If unsure, leave it on default.<b>"));
@@ -762,9 +797,21 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* settings_dialog,
 			tr("Overrides the driver's heuristics for enabling exclusive fullscreen, or direct flip/scanout.<br>"
 			   "Disallowing exclusive fullscreen may enable smoother task switching and overlays, but increase input latency."));
 
+		dialog()->registerWidgetHelp(m_advanced.overrideTextureBarriers, tr("Override Texture Barriers"), tr("Automatic (Default)"),
+			tr("Forces texture barrier functionality to the specified value."));
+
 		dialog()->registerWidgetHelp(m_advanced.rovBarriersVK, tr("ROV Barriers Vulkan"), tr("Unchecked"),
 			tr("Forces extra barriers when using ROV with Vulkan to fix graphical issues present in some games and hardware configurations."));
 
+		dialog()->registerWidgetHelp(m_advanced.disableFramebufferFetch, tr("Disable Framebuffer Fetch"), tr("Unchecked"),
+			tr("Prevents the usage of framebuffer fetch when supported by host GPU."));
+
+		dialog()->registerWidgetHelp(m_advanced.disableShaderCache, tr("Disable Shader Cache"), tr("Unchecked"),
+			tr("Prevents the loading and saving of shaders/pipelines to disk."));
+
+		dialog()->registerWidgetHelp(m_advanced.disableVertexShaderExpand, tr("Disable Vertex Shader Expand"), tr("Unchecked"),
+			tr("Falls back to the CPU for expanding sprites/lines."));
+
 		dialog()->registerWidgetHelp(m_advanced.disableMailboxPresentation, tr("Disable Mailbox Presentation"), tr("Unchecked"),
 			tr("Forces the use of FIFO over Mailbox presentation, i.e. double buffering instead of triple buffering. "
 			   "Usually results in worse frame pacing."));

pcsx2-qt/Settings/InterfaceSettingsWidget.cpp

@@ -164,6 +164,8 @@ InterfaceSettingsWidget::InterfaceSettingsWidget(SettingsWindow* settings_dialog
 		m_ui.autoUpdateTag->addItems(AutoUpdaterDialog::getTagList());
 		SettingWidgetBinder::BindWidgetToStringSetting(sif, m_ui.autoUpdateTag, "AutoUpdater", "UpdateTag",
 			AutoUpdaterDialog::getDefaultTag());
+		dialog()->registerWidgetHelp(m_ui.autoUpdateTag, tr("Update Channel"), tr("stable"),
+			tr("Selects whether the automatic updater checks for stable or nightly builds."));
 
 		//: Variable %1 shows the version number and variable %2 shows a timestamp.
 		m_ui.autoUpdateCurrentVersion->setText(tr("%1 (%2)").arg(AutoUpdaterDialog::getCurrentVersion()).arg(AutoUpdaterDialog::getCurrentVersionDate()));
@@ -245,6 +247,14 @@ InterfaceSettingsWidget::InterfaceSettingsWidget(SettingsWindow* settings_dialog
 		tr("Select how to display the background image: <br><br>Fit (Preserve aspect ratio, fit to screen)"
 		   "<br>Fill (Preserve aspect ratio, fill the screen) <br>Stretch (Ignore aspect ratio) <br>Center (Centers the image without any scaling) <br>Tile (Repeat the image to fill the screen)"));
 
+	if (!dialog()->isPerGameSettings())
+	{
+		dialog()->registerWidgetHelp(m_ui.theme, tr("Theme"), tr("N/A"),
+			tr("Selects the color theme and styling for the PCSX2 user interface."));
+		dialog()->registerWidgetHelp(m_ui.language, tr("Language"), tr("System Default"),
+			tr("Selects the display language for the PCSX2 interface, menus, and setting descriptions."));
+	}
+
 	onRenderToSeparateWindowChanged();
 }
 

pcsx2-qt/Settings/OSDSettingsWidget.cpp

@@ -128,7 +128,7 @@ OSDSettingsWidget::OSDSettingsWidget(SettingsWindow* settings_dialog, QWidget* p
 	dialog()->registerWidgetHelp(m_ui.showDebugGPU, tr("Show GPU Debug Info"),
 		tr("Unchecked"), tr("Shows debug information about the renderer."));
 #endif
-	dialog()->registerWidgetHelp(m_ui.showDebugGPU, tr("Show GPU Pipeline Statistics"),
+	dialog()->registerWidgetHelp(m_ui.showStatsGPU, tr("Show GPU Pipeline Statistics"),
 		tr("Unchecked"), tr("Shows GPU vertex shader and pixels shader invocations."));
 	dialog()->registerWidgetHelp(m_ui.showFrameTimes, tr("Show Frame Times"), tr("Unchecked"),
 		tr("Displays a graph showing the average frametimes."));

pcsx2/ImGui/FullscreenUI_Settings.cpp

@@ -2279,7 +2279,7 @@ void FullscreenUI::DrawInterfaceSettingsPage()
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_RECTANGLE_LIST, "Pause On Menu"),
 		FSUI_CSTR("Pauses the emulator when you open the quick menu, and unpauses when you close it."), "UI", "PauseOnMenu", true);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_FLOPPY_DISK, "Prompt On State Load/Save Failure"),
-		FSUI_CSTR("Display a modal dialog when a save state load/save operation fails."), "UI", "PromptOnStateLoadSaveFailure", true);
+		FSUI_CSTR("Displays a modal dialog when a save state load/save operation fails."), "UI", "PromptOnStateLoadSaveFailure", true);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_POWER_OFF, "Confirm Shutdown"),
 		FSUI_CSTR("Determines whether a prompt will be displayed to confirm shutting down the emulator/game when the hotkey is pressed."),
 		"UI", "ConfirmShutdown", true);
@@ -2421,13 +2421,13 @@ void FullscreenUI::DrawInterfaceSettingsPage()
 
 	MenuHeading(FSUI_CSTR("Integration"));
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_CIRCLE_USER, "Enable Discord Presence"),
-		FSUI_CSTR("Shows the game you are currently playing as part of your profile on Discord."), "EmuCore", "EnableDiscordPresence", false);
+		FSUI_CSTR("Shows the game you are currently playing as part of your profile in Discord."), "EmuCore", "EnableDiscordPresence", false);
 
 	MenuHeading(FSUI_CSTR("Game Display"));
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_TV, "Start Fullscreen"),
 		FSUI_CSTR("Automatically switches to fullscreen mode when a game is started."), "UI", "StartFullscreen", false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_COMPUTER_MOUSE, "Double-Click Toggles Fullscreen"),
-		FSUI_CSTR("Switches between full screen and windowed when the window is double-clicked."), "UI", "DoubleClickTogglesFullscreen",
+		FSUI_CSTR("Allows switching in and out of fullscreen mode by double-clicking the game window."), "UI", "DoubleClickTogglesFullscreen",
 		true);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_ARROW_POINTER, "Hide Cursor In Fullscreen"),
 		FSUI_CSTR("Hides the mouse pointer/cursor when the emulator is in fullscreen mode."), "UI", "HideMouseCursor", false);
@@ -2494,7 +2494,7 @@ void FullscreenUI::DrawBIOSSettingsPage()
 	}
 
 	MenuHeading(FSUI_CSTR("Fast Boot Options"));
-	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_FORWARD_FAST, "Fast Boot"), FSUI_CSTR("Skips the intro screen, and bypasses region checks."),
+	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_FORWARD_FAST, "Fast Boot"), FSUI_CSTR("Patches the BIOS to skip the console's boot animation."),
 		"EmuCore", "EnableFastBoot", true);
 	const bool fast_boot_enabled = GetEffectiveBoolSetting(bsi, "EmuCore", "EnableFastBoot", true);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_FORWARD, "Fast Forward Boot"),
@@ -2608,11 +2608,11 @@ void FullscreenUI::DrawEmulationSettingsPage()
 	DrawToggleSetting(
 		bsi, FSUI_ICONSTR(ICON_FA_FACE_ROLLING_EYES, "Enable Cheats"), FSUI_CSTR("Enables loading cheats from pnach files."), "EmuCore", "EnableCheats", false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_HARD_DRIVE, "Enable Host Filesystem"),
-		FSUI_CSTR("Enables access to files from the host: namespace in the virtual machine."), "EmuCore", "HostFs", false);
+		FSUI_CSTR("Allows games and homebrew to access files / folders directly on the host computer."), "EmuCore", "HostFs", false);
 
 	if (IsEditingGameSettings(bsi))
 	{
-		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_COMPACT_DISC, "Enable Fast CDVD"), FSUI_CSTR("Fast disc access, less loading times. Not recommended."),
+		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_COMPACT_DISC, "Enable Fast CDVD"), FSUI_CSTR("Fast disc access, shorter loading times. Check HDLoader compatibility lists for games that are known to have issues with this."),
 			"EmuCore/Speedhacks", "fastCDVD", false);
 	}
 
@@ -2624,7 +2624,7 @@ void FullscreenUI::DrawEmulationSettingsPage()
 		MenuHeading(FSUI_CSTR("Real-Time Clock"));
 
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_CLOCK, "Manually Set Real-Time Clock"),
-			FSUI_CSTR("Uses a fixed date/time for the virtual PS2 instead of the host clock. Applied on boot only."),
+			FSUI_CSTR("Manually set a real-time clock to use for the virtual PlayStation 2 instead of using your OS' system clock."),
 			"EmuCore", "ManuallySetRealTimeClock", false);
 
 		const bool rtc_enabled = GetEffectiveBoolSetting(bsi, "EmuCore", "ManuallySetRealTimeClock", false);
@@ -3021,7 +3021,7 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 		FSUI_CSTR("Selects the aspect ratio for display when a FMV is detected as playing."), "EmuCore/GS", "FMVAspectRatioSwitch",
 		"Auto 4:3/3:2", Pcsx2Config::GSOptions::FMVAspectRatioSwitchNames, Pcsx2Config::GSOptions::FMVAspectRatioSwitchNames, 0, false);
 	DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_TV, "Deinterlacing"),
-		FSUI_CSTR("Selects the algorithm used to convert the PS2's interlaced output to progressive for display."), "EmuCore/GS",
+		FSUI_CSTR("Determines the deinterlacing method to be used on the interlaced screen of the emulated console.\nAutomatic should be able to correctly deinterlace most games, but if you see visibly shaky graphics, try one of the other options."), "EmuCore/GS",
 		"deinterlace_mode", static_cast<int>(GSInterlaceMode::Automatic), s_deinterlacing_options, std::size(s_deinterlacing_options),
 		true);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_TV, "Disable Interlace Offset"),
@@ -3042,10 +3042,10 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 
 	if (!IsEditingGameSettings(bsi))
 	{
-		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_TV, "Apply Widescreen Patches"), FSUI_CSTR("Enables loading widescreen patches from pnach files."),
+		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_TV, "Apply Widescreen Patches"), FSUI_CSTR("Automatically loads and applies widescreen patches on game start. Can cause issues."),
 			"EmuCore", "EnableWideScreenPatches", false);
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_TV, "Apply No-Interlacing Patches"),
-			FSUI_CSTR("Enables loading no-interlacing patches from pnach files."), "EmuCore", "EnableNoInterlacingPatches", false);
+			FSUI_CSTR("Automatically loads and applies no-interlacing patches on game start. Can cause issues."), "EmuCore", "EnableNoInterlacingPatches", false);
 	}
 
 	DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_TABLE_CELLS, "Bilinear Filtering"), FSUI_CSTR("Smooths out the image when upscaling the console to the screen."),
@@ -3061,7 +3061,7 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 		FSUI_CSTR("Enables the option to show the overscan area on games which draw more than the safe area of the screen."), "EmuCore/GS",
 		"pcrtc_overscan", false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_GLASSES, "Anti-Blur"),
-		FSUI_CSTR("Enables internal Anti-Blur hacks. Less accurate to PS2 rendering but will make a lot of games look less blurry."),
+		FSUI_CSTR("Enables internal Anti-Blur hacks. Less accurate than PS2 rendering but will make a lot of games look less blurry."),
 		"EmuCore/GS", "pcrtc_antiblur", true);
 
 	MenuHeading(FSUI_CSTR("Rendering"));
@@ -3077,20 +3077,20 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 			FSUI_CSTR("Selects where trilinear filtering is utilized when rendering textures."), "EmuCore/GS", "TriFilter",
 			static_cast<int>(TriFiltering::Automatic), s_trilinear_options, std::size(s_trilinear_options), true, -1);
 		DrawStringListSetting(bsi, FSUI_ICONSTR(ICON_FA_EYE_LOW_VISION, "Anisotropic Filtering"),
-			FSUI_CSTR("Selects where anisotropic filtering is utilized when rendering textures."), "EmuCore/GS", "MaxAnisotropy", "0",
+			FSUI_CSTR("Reduces texture aliasing at extreme viewing angles."), "EmuCore/GS", "MaxAnisotropy", "0",
 			s_anisotropic_filtering_entries, s_anisotropic_filtering_values, std::size(s_anisotropic_filtering_entries), true);
 		DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_DROPLET_SLASH, "Dithering"), FSUI_CSTR("Selects the type of dithering applies when the game requests it."),
 			"EmuCore/GS", "dithering_ps2", 2, s_dithering_options, std::size(s_dithering_options), true);
 		DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_SPLOTCH, "Blending Accuracy"),
 			FSUI_CSTR("Determines the level of accuracy when emulating blend modes not supported by the host graphics API."), "EmuCore/GS",
 			"accurate_blending_unit", static_cast<int>(AccBlendLevel::Basic), s_blending_options, std::size(s_blending_options), true);
-		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_EYE_DROPPER, "AA1"), FSUI_CSTR("Enables emulation of the GS's edge anti-aliasing (AA1)."),
+		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_EYE_DROPPER, "AA1"), FSUI_CSTR("Enables AA1 (PS2 antialiasing), which some games require to render correctly. This may result in a heavy performance penalty."),
 			"EmuCore/GS", "HWAA1", false);
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_DROPLET, "Accurate Alpha Test"),
 			FSUI_CSTR("Enables accurate alpha testing, which some games require to render correctly. This may require more draw calls and result in a speed penalty."),
 			"EmuCore/GS", "HWAccurateAlphaTest", false);
 		DrawToggleSetting(
-			bsi, FSUI_ICONSTR(ICON_FA_BULLSEYE, "Mipmapping"), FSUI_CSTR("Enables emulation of the GS's texture mipmapping."), "EmuCore/GS", "hw_mipmap", true);
+			bsi, FSUI_ICONSTR(ICON_FA_BULLSEYE, "Mipmapping"), FSUI_CSTR("Enables mipmapping, which some games require to render correctly. Mipmapping uses progressively lower resolution variants of textures at progressively further distances to reduce processing load and avoid visual artifacts."), "EmuCore/GS", "hw_mipmap", true);
 		if (is_hardware && effective_renderer != GSRendererType::OGL)
 		{
 			DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_LAYER_GROUP, "Rasterizer Ordered View"),
@@ -3107,7 +3107,7 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_TOILET, "Auto Flush"),
 			FSUI_CSTR("Force a primitive flush when a framebuffer is also an input texture."), "EmuCore/GS", "autoflush_sw", true);
 		DrawToggleSetting(
-			bsi, FSUI_ICONSTR(ICON_FA_BULLSEYE, "Mipmapping"), FSUI_CSTR("Enables emulation of the GS's texture mipmapping."), "EmuCore/GS", "mipmap", true);
+			bsi, FSUI_ICONSTR(ICON_FA_BULLSEYE, "Mipmapping"), FSUI_CSTR("Enables mipmapping, which some games require to render correctly. Mipmapping uses progressively lower resolution variants of textures at progressively further distances to reduce processing load and avoid visual artifacts."), "EmuCore/GS", "mipmap", true);
 	}
 
 	if (hw_fixes_visible)
@@ -3190,23 +3190,25 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 			};
 
 			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_SHAPES, "CPU Sprite Render Size"),
-				FSUI_CSTR("Uses software renderer to draw texture decompression-like sprites."), "EmuCore/GS",
+				FSUI_CSTR("The maximum target memory width that will allow the CPU Sprite Renderer to activate on."), "EmuCore/GS",
 				"UserHacks_CPUSpriteRenderBW", 0, s_cpu_sprite_render_bw_options, std::size(s_cpu_sprite_render_bw_options), true);
 			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_SHAPES, "CPU Sprite Render Level"), FSUI_CSTR("Determines filter level for CPU sprite render."),
 				"EmuCore/GS", "UserHacks_CPUSpriteRenderLevel", 0, s_cpu_sprite_render_level_options,
 				std::size(s_cpu_sprite_render_level_options), true);
 			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_PALETTE, "Software CLUT Render"),
-				FSUI_CSTR("Uses software renderer to draw texture CLUT points/sprites."), "EmuCore/GS", "UserHacks_CPUCLUTRender", 0,
+				FSUI_CSTR("Tries to detect when a game is drawing its own color palette and then renders it in software, instead of on the GPU."), "EmuCore/GS", "UserHacks_CPUCLUTRender", 0,
 				s_cpu_clut_render_options, std::size(s_cpu_clut_render_options), true);
 			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_PALETTE, "GPU Target CLUT"),
-				FSUI_CSTR("Try to detect when a game is drawing its own color palette and then renders it on the GPU with special handling."), "EmuCore/GS", "UserHacks_GPUTargetCLUTMode",
+				FSUI_CSTR("Tries to detect when a game is drawing its own color palette and then renders it on the GPU with special handling."), "EmuCore/GS", "UserHacks_GPUTargetCLUTMode",
 				0, s_gpu_clut_options, std::size(s_gpu_clut_options), true, 0, manual_hw_fixes);
-			DrawIntSpinBoxSetting(bsi, FSUI_ICONSTR(ICON_FA_FORWARD, "Skip Draw Range Start"), FSUI_CSTR("Object range to skip drawing."), "EmuCore/GS",
+			DrawIntSpinBoxSetting(bsi, FSUI_ICONSTR(ICON_FA_FORWARD, "Skip Draw Range Start"),
+				FSUI_CSTR("Completely skips drawing surfaces from the starting index up to the ending index."), "EmuCore/GS",
 				"UserHacks_SkipDraw_Start", 0, 0, 5000, 1);
-			DrawIntSpinBoxSetting(bsi, FSUI_ICONSTR(ICON_FA_FORWARD_STEP, "Skip Draw Range End"), FSUI_CSTR("Object range to skip drawing."), "EmuCore/GS",
+			DrawIntSpinBoxSetting(bsi, FSUI_ICONSTR(ICON_FA_FORWARD_STEP, "Skip Draw Range End"),
+				FSUI_CSTR("Completely skips drawing surfaces from the starting index up to the ending index."), "EmuCore/GS",
 				"UserHacks_SkipDraw_End", 0, 0, 5000, 1);
 			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_BROOM, "Auto Flush"),
-				FSUI_CSTR("Force a primitive flush when a framebuffer is also an input texture."), "EmuCore/GS", "UserHacks_AutoFlushLevel",
+				FSUI_CSTR("Forces a primitive flush when a framebuffer is also an input texture. Fixes some processing effects such as the shadows in the Jak series and radiosity in GTA:SA."), "EmuCore/GS", "UserHacks_AutoFlushLevel",
 				0, s_auto_flush_options, std::size(s_auto_flush_options), true, 0, manual_hw_fixes);
 			DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_MICROCHIP, "Framebuffer Conversion"),
 				FSUI_CSTR("Convert 4-bit and 8-bit framebuffer on the CPU instead of the GPU."), "EmuCore/GS",
@@ -3246,9 +3248,9 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 				std::size(s_limit_24bit_depth_options), true, 0, manual_hw_fixes);
 
 			MenuHeading(FSUI_CSTR("Upscaling Fixes"));
-			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_ARROWS_UP_DOWN_LEFT_RIGHT, "Half Pixel Offset"), FSUI_CSTR("Adjusts vertices relative to upscaling."), "EmuCore/GS",
+			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_ARROWS_UP_DOWN_LEFT_RIGHT, "Half Pixel Offset"), FSUI_CSTR("Might fix some misaligned fog, bloom, or blend effect."), "EmuCore/GS",
 				"UserHacks_HalfPixelOffset", 0, s_half_pixel_offset_options, std::size(s_half_pixel_offset_options), true);
-			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_COMPRESS, "Native Scaling"), FSUI_CSTR("Attempt to do rescaling at native resolution."), "EmuCore/GS",
+			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_COMPRESS, "Native Scaling"), FSUI_CSTR("Emulates native PS2 coordinate scaling behavior when upscaling to reduce misalignment artifacts and seams in games that draw custom 2D elements."), "EmuCore/GS",
 				"UserHacks_native_scaling", 0, s_native_scaling_options, std::size(s_native_scaling_options), true);
 			DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_CIRCLE, "Round Sprite"), FSUI_CSTR("Adjusts sprite coordinates."), "EmuCore/GS",
 				"UserHacks_round_sprite_offset", 0, s_round_sprite_options, std::size(s_round_sprite_options), true);
@@ -3263,13 +3265,13 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 			DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_ALIGN_CENTER, "Align Sprite"), FSUI_CSTR("Fixes issues with upscaling (vertical lines) in some games."),
 				"EmuCore/GS", "UserHacks_align_sprite_X", false, manual_hw_fixes);
 			DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_COMPRESS, "Merge Sprite"),
-				FSUI_CSTR("Replaces multiple post-processing sprites with a larger single sprite."), "EmuCore/GS",
+				FSUI_CSTR("Replaces post-processing multiple paving sprites by a single fat sprite. It reduces various upscaling lines."), "EmuCore/GS",
 				"UserHacks_merge_pp_sprite", false, manual_hw_fixes);
 			DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_ALIGN_CENTER, "Force Even Sprite Position"),
 				FSUI_CSTR("Lowers the GS precision to avoid gaps between pixels when upscaling. Fixes the text on Wild Arms games."),
 				"EmuCore/GS", "UserHacks_ForceEvenSpritePosition", false, manual_hw_fixes);
 			DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_PALETTE, "Unscaled Palette Texture Draws"),
-				FSUI_CSTR("Can fix some broken effects which rely on pixel perfect precision."), "EmuCore/GS",
+				FSUI_CSTR("Forces palette texture draws to render at native resolution."), "EmuCore/GS",
 				"UserHacks_NativePaletteDraw", false, manual_hw_fixes);
 		}
 	}
@@ -3313,7 +3315,7 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 		};
 		const bool cas_active = (GetEffectiveIntSetting(bsi, "EmuCore/GS", "CASMode", 0) != static_cast<int>(GSCASMode::Disabled));
 
-		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_EYE, "FXAA"), FSUI_CSTR("Enables FXAA post-processing shader."), "EmuCore/GS", "fxaa", false);
+		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_EYE, "FXAA"), FSUI_CSTR("Applies the FXAA anti-aliasing algorithm to improve the visual quality of games."), "EmuCore/GS", "fxaa", false);
 		DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_SUN, "Contrast Adaptive Sharpening"), FSUI_CSTR("Enables FidelityFX Contrast Adaptive Sharpening."),
 			"EmuCore/GS", "CASMode", static_cast<int>(GSCASMode::Disabled), s_cas_options, std::size(s_cas_options), true);
 		DrawIntSpinBoxSetting(bsi, FSUI_ICONSTR(ICON_FA_PENCIL, "Sharpness"),
@@ -3346,7 +3348,7 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 			FSUI_NSTR("4xRGSS"),
 			FSUI_NSTR("NxAGSS"),
 		};
-		DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_TV, "TV Shader"), FSUI_CSTR("Applies a shader which replicates the visual effects of different styles of television set."), "EmuCore/GS", "TVShader", 0,
+		DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_TV, "TV Shader"), FSUI_CSTR("Applies a shader which replicates the visual effects of different styles of television sets."), "EmuCore/GS", "TVShader", 0,
 			s_tv_shaders, std::size(s_tv_shaders), true);
 	}
 
@@ -3388,7 +3390,7 @@ void FullscreenUI::DrawGraphicsSettingsPage(SettingsInterface* bsi, bool show_ad
 		DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_SHIELD_HALVED, "Override Texture Barriers"),
 			FSUI_CSTR("Forces texture barrier functionality to the specified value."), "EmuCore/GS", "OverrideTextureBarriers", -1,
 			s_generic_options, std::size(s_generic_options), true, -1);
-		DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_FILE_ZIPPER, "GS Dump Compression"), FSUI_CSTR("Sets the compression algorithm for GS dumps."), "EmuCore/GS",
+		DrawIntListSetting(bsi, FSUI_ICONSTR(ICON_FA_FILE_ZIPPER, "GS Dump Compression"), FSUI_CSTR("Change the compression algorithm used when creating a GS dump."), "EmuCore/GS",
 			"GSDumpCompression", static_cast<int>(GSDumpCompressionMethod::LZMA), s_gsdump_compression, std::size(s_gsdump_compression), true);
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_BAN, "Disable Framebuffer Fetch"),
 			FSUI_CSTR("Prevents the usage of framebuffer fetch when supported by host GPU."), "EmuCore/GS", "DisableFramebufferFetch", false);
@@ -3429,9 +3431,9 @@ void FullscreenUI::DrawOSDSettingsPage()
 
 	MenuHeading(FSUI_CSTR("On-Screen Display"));
 	DrawIntSpinBoxSetting(bsi, FSUI_ICONSTR(ICON_FA_MAGNIFYING_GLASS, "OSD Scale"),
-		FSUI_CSTR("Determines how large the on-screen messages and monitors are."), "EmuCore/GS", "OsdScale", 100, 25, 500, 1, FSUI_CSTR("%d%%"));
+		FSUI_CSTR("Scales the size of the onscreen OSD from 50% to 500%."), "EmuCore/GS", "OsdScale", 100, 25, 500, 1, FSUI_CSTR("%d%%"));
 	DrawIntSpinBoxSetting(bsi, FSUI_ICONSTR(ICON_FA_BORDER_ALL, "OSD Margin"),
-		FSUI_CSTR("Determines the distance in pixels from the edges of the screen for OSD elements."), "EmuCore/GS", "OsdMargin", 10, 0, 100, 1, FSUI_CSTR("%dpx"));
+		FSUI_CSTR("Sets the distance in pixels from the edges of the screen for OSD elements."), "EmuCore/GS", "OsdMargin", 10, 0, 100, 1, FSUI_CSTR("%dpx"));
 
 	// OSD Positioning Options
 	static constexpr const char* s_osd_position_options[] = {
@@ -3453,7 +3455,7 @@ void FullscreenUI::DrawOSDSettingsPage()
 		FSUI_CSTR("Determines where on-screen display messages are positioned."), "EmuCore/GS", "OsdMessagesPos", "1",
 		s_osd_position_options, s_osd_position_values, std::size(s_osd_position_options), true);
 	DrawStringListSetting(bsi, FSUI_ICONSTR(ICON_FA_CHART_BAR, "OSD Performance Position"),
-		FSUI_CSTR("Determines where performance statistics are positioned."), "EmuCore/GS", "OsdPerformancePos", "3",
+		FSUI_CSTR("Position of a variety of on-screen performance data points as selected by the user."), "EmuCore/GS", "OsdPerformancePos", "3",
 		s_osd_position_options, s_osd_position_values, std::size(s_osd_position_options), true);
 
 	{
@@ -3525,34 +3527,34 @@ void FullscreenUI::DrawOSDSettingsPage()
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_IMAGE, "Show GPU Usage"),
 		FSUI_CSTR("Shows the host's GPU utilization."), "EmuCore/GS", "OsdShowGPU", false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_PLAY, "Show Status Indicators"),
-		FSUI_CSTR("Shows indicators when fast forwarding, pausing, and other abnormal states are active."), "EmuCore/GS",
+		FSUI_CSTR("Shows icon indicators for emulation states such as Pausing, Turbo, Fast-Forward, and Slow-Motion."), "EmuCore/GS",
 		"OsdShowIndicators", true);
 #ifdef _WIN32
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_BUG, "Show GPU Debug Info"),
 		FSUI_CSTR("Shows debug information about the renderer."), "EmuCore/GS", "OsdShowGPUDebug", false);
 #endif
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_IMAGE, "Show GPU Pipeline Statistics"),
-		FSUI_CSTR("Shows the host's GPU pipeline statistics."), "EmuCore/GS", "OsdShowGPUStats", false);
+		FSUI_CSTR("Shows GPU vertex shader and pixels shader invocations."), "EmuCore/GS", "OsdShowGPUStats", false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_PF_HEARTBEAT_ALT, "Show Frame Times"),
-		FSUI_CSTR("Shows a visual history of frame times."), "EmuCore/GS", "OsdShowFrameTimes", false);
+		FSUI_CSTR("Displays a graph showing the average frametimes."), "EmuCore/GS", "OsdShowFrameTimes", false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_SLIDERS, "Show Settings"),
-		FSUI_CSTR("Shows the current configuration in the bottom-right corner of the display."),
+		FSUI_CSTR("Displays various settings and the current values of those settings in the bottom-right corner of the display."),
 		"EmuCore/GS", "OsdShowSettings", false);
 	bool show_settings = (bsi->GetBoolValue("EmuCore/GS", "OsdShowSettings", false) == false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_HAMMER, "Show Patches"),
-		FSUI_CSTR("Shows the amount of currently active patches/cheats on the bottom-right corner of the display."), "EmuCore/GS",
+		FSUI_CSTR("Shows the amount of currently active patches/cheats in the bottom-right corner of the display."), "EmuCore/GS",
 		"OsdshowPatches", false, !show_settings);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_PF_GAMEPAD_ALT, "Show Inputs"),
 		FSUI_CSTR("Shows the current controller state of the system in the bottom-left corner of the display."), "EmuCore/GS",
 		"OsdShowInputs", false);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_VIDEO, "Show Video Capture Status"),
-		FSUI_CSTR("Shows the status of the currently active video capture."), "EmuCore/GS",
+		FSUI_CSTR("Shows the status of the currently active video capture in the top-right corner of the display."), "EmuCore/GS",
 		"OsdShowVideoCapture", true);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_KEYBOARD, "Show Input Recording Status"),
-		FSUI_CSTR("Shows the status of the currently active input recording."), "EmuCore/GS",
+		FSUI_CSTR("Shows the status of the currently active input recording in the top-right corner of the display."), "EmuCore/GS",
 		"OsdShowInputRec", true);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_IMAGES, "Show Texture Replacement Status"),
-		FSUI_CSTR("Shows the number of dumped and loaded texture replacements on the OSD."), "EmuCore/GS",
+		FSUI_CSTR("Shows the status of the number of dumped and loaded texture replacements in the top-right corner of the display."), "EmuCore/GS",
 		"OsdShowTextureReplacements", true);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_TRIANGLE_EXCLAMATION, "Warn About Unsafe Settings"),
 		FSUI_CSTR("Displays warnings when settings are enabled which may break games."), "EmuCore", "WarnAboutUnsafeSettings", true);
@@ -3591,7 +3593,7 @@ void FullscreenUI::DrawAudioSettingsPage()
 		&AudioStream::GetExpansionModeName, &AudioStream::GetExpansionModeDisplayName,
 		AudioExpansionMode::Count);
 	DrawEnumSetting(bsi, FSUI_ICONSTR(ICON_FA_ARROWS_SPIN, "Synchronization"),
-		FSUI_CSTR("Changes when SPU samples are generated relative to system emulation."),
+		FSUI_CSTR("When the emulation isn't running at 100% speed, adjusts the tempo of the audio\nwhich produces much nicer sound during fast-forward/slowdown."),
 		"SPU2/Output", "SyncMode", Pcsx2Config::SPU2Options::DEFAULT_SYNC_MODE,
 		&Pcsx2Config::SPU2Options::ParseSyncMode, &Pcsx2Config::SPU2Options::GetSyncModeName,
 		&Pcsx2Config::SPU2Options::GetSyncModeDisplayName, Pcsx2Config::SPU2Options::SPU2SyncMode::Count);
@@ -4806,7 +4808,7 @@ void FullscreenUI::DrawAchievementsSettingsPage(std::unique_lock<std::mutex>& se
 		FSUI_CSTR("When enabled, each session will behave as if no achievements have been unlocked."), "Achievements", "EncoreMode", false,
 		enabled);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_MEDAL, "Test Unofficial Achievements"),
-		FSUI_CSTR("When enabled, PCSX2 will list achievements from unofficial sets. These achievements are not tracked by RetroAchievements."),
+		FSUI_CSTR("When enabled, PCSX2 will list achievements from unofficial sets. Please note that these achievements are not tracked by RetroAchievements, so they unlock every time."),
 		"Achievements", "UnofficialTestMode", false, enabled);
 
 	// Check for challenge mode just being enabled.
@@ -4840,7 +4842,7 @@ void FullscreenUI::DrawAchievementsSettingsPage(std::unique_lock<std::mutex>& se
 
 	MenuHeading(FSUI_CSTR("Notifications"));
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_BELL, "Show Achievement Notifications"),
-		FSUI_CSTR("Displays popup messages on events such as achievement unlocks and leaderboard submissions."), "Achievements",
+		FSUI_CSTR("Displays popup messages on events such as achievement unlocks and game completion."), "Achievements",
 		"Notifications", true, enabled);
 	DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_LIST_OL, "Show Leaderboard Notifications"),
 		FSUI_CSTR("Displays popup messages when starting, submitting, or failing a leaderboard challenge."), "Achievements",
@@ -4861,7 +4863,7 @@ void FullscreenUI::DrawAchievementsSettingsPage(std::unique_lock<std::mutex>& se
 			FSUI_CSTR("Determines the display duration for achievement unlock popups."), "Achievements", "NotificationsDuration", 5, 3, 30,
 			"%d seconds", achievement_notifications_enabled);
 		DrawIntRangeSetting(bsi, FSUI_ICONSTR(ICON_FA_CLOCK, "Leaderboard Notification Duration"),
-			FSUI_CSTR("Determines the display duration for leaderboard popups."), "Achievements", "LeaderboardsDuration", 10, 3, 30,
+			FSUI_CSTR("Determines the display duration for leaderboard notification popups."), "Achievements", "LeaderboardsDuration", 10, 3, 30,
 			"%d seconds", leaderboard_notifications_enabled);
 	}
 
@@ -5598,7 +5600,8 @@ void FullscreenUI::DrawAdvancedSettingsPage()
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_MICROCHIP, "Enable Recompiler"),
 			FSUI_CSTR("Performs just-in-time binary translation of 64-bit MIPS-IV machine code to native code."), "EmuCore/CPU/Recompiler",
 			"EnableEE", true);
-		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_BUCKET, "Enable Cache (Slow)"), FSUI_CSTR("Enables simulation of the EE's cache. Slow."),
+		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_BUCKET, "Enable Cache (Slow)"),
+			FSUI_CSTR("Enables emulation of the EE's hardware cache. Interpreter only, provided for diagnostics."),
 			"EmuCore/CPU/Recompiler", "EnableEECache", false);
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_ARROWS_SPIN, "INTC Spin Detection"),
 			FSUI_CSTR("Huge speedup for some games, with almost no compatibility side effects."), "EmuCore/Speedhacks", "IntcStat", true);
@@ -5628,10 +5631,10 @@ void FullscreenUI::DrawAdvancedSettingsPage()
 		DrawClampingModeSetting(bsi, FSUI_ICONSTR(ICON_FA_ARROW_TURN_DOWN, "VU1 Clamping Mode"),
 			FSUI_CSTR("Determines how out-of-range floating point numbers are handled. Some games need specific settings."), 1);
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_MICROCHIP, "Enable VU0 Recompiler (Micro Mode)"),
-			FSUI_CSTR("New Vector Unit recompiler with much improved compatibility. Recommended."), "EmuCore/CPU/Recompiler", "EnableVU0",
+			FSUI_CSTR("Performs just-in-time binary translation of Vector Unit 0 (VU0) microprograms to native code."), "EmuCore/CPU/Recompiler", "EnableVU0",
 			true);
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_MICROCHIP, "Enable VU1 Recompiler"),
-			FSUI_CSTR("New Vector Unit recompiler with much improved compatibility. Recommended."), "EmuCore/CPU/Recompiler", "EnableVU1",
+			FSUI_CSTR("Performs just-in-time binary translation of Vector Unit 1 (VU1) microprograms to native code."), "EmuCore/CPU/Recompiler", "EnableVU1",
 			true);
 		DrawToggleSetting(bsi, FSUI_ICONSTR(ICON_FA_FLAG, "mVU Flag Hack"),
 			FSUI_CSTR("Good speedup and high compatibility, may cause graphical errors."), "EmuCore/Speedhacks", "vuFlagHack", true);