To start with a teaser - we have some serious performance gains to talk about with this release; as seen here with Need for Speed: Carbon!

Now let's jump into this release's major talking points!

The System Requirements Update​

We have updated our system requirements to reflect several improvements to the core and graphics pipelines that require more powerful hardware than our previous requirements recommended.

Installer Visual Overhaul​

The installer has received quite a facelift. It now looks more sleek and comes with dark mode support. It also has received some Quality of Life Improvements such as:

• In Portable mode, the install location will now default to the root of the drive that the installer is being run from.
• In Portable mode, it will no longer create an uninstaller entry in the start menu.

Before

After

New Features​

Deps: Bundle FFmpeg on Windows​

14065

FFmpeg is now bundled together with the Windows build of PCSX2. It's no longer necessary for you to download FFmpeg separately before you use the built-in Video Capture!

We've also hand-picked the most popular codecs. Previously, we included everything that FFmpeg offered, but this was too much wasted space on codecs that were rarely, if ever, used. The reduced set of codecs should still provide you with all the modern, efficient options you need without taking up much extra space.

Video Encoders:

• Hardware Encoders:

  • AMD AMF/VCE
  • Intel QSV
  • Nvidia NVENC
  • Media Foundations
  • Vulkan Video

• Software Encoders:

  • libx264 (H264)
  • libx265 (H265)
  • libsvtav1 (AV1)
  • ffv1 (FFmpeg's own codec)
  • qtrle (Apple QT RLE)

Audio Encoders:

• AAC (Advanced Audio Coding)
• Opus
• FLAC (Free Lossless Audio Codec)
• pcm_s16le & pcm_s16be (WAV)

USB: Implement EyeToy camera support on macOS​

13974

SternXD worked on adding EyeToy camera support for macOS. With this, all 3 OSes now have full EyeToy camera support!

USB: Train Mascon, Master Controller and Olympus Storage Devices support​

1365214328

Florin9doi has worked on adding additional Train Mascon and Master Controller support to the existing Train controller feature.

Alongside that, they have also added support for Olympus Camera and Olympus Turbo MO miniEX IV (MO644U2S, MO133U2S) Storage Devices.

Qt/FullscreenUI/ImGui: On-Screen Display Customizations​

14127

This grants the ability to customize the look of the On-Screen Display, such as changing its fonts, location, scale, margin and more. We also gave the On-Screen Display its own dedicated settings within PCSX2.

The frame time graph now has more detailed measurements as well!

Achievements: Various visual improvements to Achievements menu​

13926

The Achievements section has received some enhancements!

• The collapsing headers have been replaced with a sidebar in the achievements menu for games with multiple subsets.
• Added subset mastery notifications.
• When a subset is open, the header shows that subset’s title, stats, and progress bar.
• Missable, Win Condition, and Progression indicators are now shown as small badges next to the achievement title.

FullscreenUI: Implement cover download support​

13620

Just like its Qt counterpart, the Big Picture Mode interface now also gets its own cover downloader functionality! Now you no longer need to go to the Qt interface just to use the cover downloader. Convenience 💯

Qt: Add Icon Selection and Preview to the Shortcut Creator​

14176

The game shortcut creator now allows you to attach a custom icon to a shortcut as well when you're creating one. No more having to manually add them afterwards!

Qt: Revamp the status bar​

14308

The status bar has received quite a number of quality of life improvements. You can now control the volume of the virtual console directly from the main interface without going to the audio settings manually. You can now toggle the speed limit directly without using the hotkeys. Additionally, it shows you the host GPU usage, the current renderer, and the currently active internal resolution multiplier.

Qt: Add a bunch of Open XXX Folder actions to Game List entries​

1419014191

A few new options have been added to the Game List's context menu. These allow you to open the folders of various PCSX2-related game data or resources. You can access this by right-clicking a game entry in the Game List.

Qt: Add -datapath launch argument​

14316

You can now override the default data folder location that PCSX2 uses with your own custom path, instead of being stuck with the default locations.

Qt/FSUI: Miscellaneous UI Changes​

+2

• #14228 FullscreenUI: Add analog control to Big Picture Mode
• #13589 FullscreenUI: Load all language fonts at all times
• #13933 Qt: Prevent empty Gamelist header + reset option
• #13933 Qt: show full game titles in grid view
• #14007 Qt: Toggle mouse lock hotkey
• #14117 Hotkey: Add Reload Patch Hotkey
• #14112 GS: Add hotkey for cycling Blending Accuracy
• #14197 VMManager: Make Prefer English also applies to other things
• #14191 Qt: Add Option for storing video captures per-games
• #14448 GS: Add shader compile indicator
• #14618 Qt: Add sorting to memory card list
• #14579 Qt/GameListBackground: Auto adjust gamelist text color
• #14666 Qt: Add Create PCSX2 launcher option to setup wizard
• #14721 FSUI: Add gamelist hotkey to scan for new games
• #14284 Qt: Add RetroAchievements to Setup Wizard

Performance and Graphics Improvements​

GS/HW: Depth feedback loops and accurate AFAIL.​

13631

The PS2's GS is known for being difficult to emulate due to how different it is from the PC hardware we use today. PCSX2 has long had options to choose between accuracy and speed for things like blending. The fast options pick a close but not identical setting for the PC hardware to approximate each setting of the GS. The accurate options move the operation from dedicated hardware to shaders, requiring large numbers of slow barriers to ensure the correct result.

Until now, these options have all been only for the main color texture, but the GS also has mismatches with PC hardware in its handling of the depth texture. In particular, the alpha test, which allows discarding pixels when the texture alpha value is below a set cutoff, gives games the choice of whether to discard color, depth, or both. On the other hand, the only option for PC GPUs is to discard both¹.

For games that choose the option to discard only color, PCSX2 can use the shader blend system to load the existing color from the render target and re-output that, but for depth, PCSX2 didn't support a fully accurate system. Instead, PCSX2 rendered every draw call twice. First, it would draw color only, without discarding based on the alpha test, then a second pass would draw depth only, discarding where needed. This means that if two overlapping triangles occurred in the same draw, it was possible for the wrong result to happen, since the pass that was drawing color didn't update depth and therefore wouldn't reject a further triangle drawn after a closer triangle.

To fix this, TJ added a system similar to the color handling for depth, where we disable the dedicated hardware and instead do all processing in the shader. This means disabling the hardware depth test and emulating that as well, so that it doesn't interfere with our attempts to cancel depth update by re-emitting the existing depth value. Unfortunately, due to this being a niche usage of an already niche feature, many of the APIs that did support this kind of shader feedback loop for color failed when we attempted to do the same with depth textures, handing our shaders outdated pixel values. In the end, only Vulkan, which has an extension made explicitly for this purpose, consistently worked, while the D3D12 and OpenGL renderers default to copying the depth texture to a temporary color texture for the handling, then copying the result back to the original depth texture when done.^{2 3 4}

Minna No Tennis:

Before

After

Ratchet & Clank: Up Your Arsenal:

Before

After

Before

After

GS/HW: Support for HW AA1 lines/triangles​

1368114439

AA1 is the PS2's name for antialiasing. Unlike MSAA, which rasterizes triangles at a higher resolution and then downsamples, the PS2's AA1 works by adding a semi-transparent border around each triangle as it's drawn. In order for the semi-transparent border to not block the triangles below, it doesn't write depth, even though the fully-opaque parts of the triangle do. Even so, that only prevents things from looking broken under AA1. For fully working antialiasing, PS2 games have to sort their triangles and draw back to front, like in the old depth-buffer-less days of the PS1.

Because PC GPUs don't support writing depth for only some triangles in a draw, this was a software-renderer-only feature in PCSX2 for a long time, but TJ used PCSX2's newly-added software depth support to add support for these triangle borders. Due to the high cost of the software depth emulation, this is currently disabled by default, but can be enabled in the graphics settings which will allow it to activate on supported games.

Comparison:

God Of War:

Before

After

Before

After

Final Fantasy X:

Before

After

The Incredibles:

Before

After

Sly 2:

Before

After

Jonny Moseley Mad Trix:

Before

After

GS/HW: Support for Rasterizer Order View (ROV)​

14503145551464314646

ROV (Rasterizer Ordered Views) provides a way to do programmable color blending when games draw overlapping geometry. They help guarantee that pixels are blended in the same order that the game intended, which is necessary for accurate graphics emulation. PS2 games often use effects where pixels must be blended in exactly the order the game draws them in (e.g. layering textures, transparency, etc.). GPUs already provide this ordering guarantee for fixed function blending. However, many blending effects in PS2 games cannot be accurately done with fixed function, so we emulate them in the pixel shader. To enforce correct ordering in pixel shaders there are several approaches that we use: barrier loops (Direct3D 12, VK, GL, Metal), framebuffer fetch (aka FB Fetch; GL, VK, Metal), copy loops (Direct3D 11, GL), and most recently rasterizer ordered views (aka ROV; Direct3D 12, Direct3D 11, VK). Out of these the fastest is FB fetch, though it has the most limited support out of the list.

In the middle are ROV and barrier loops, which both have widespread support. In some cases ROV can be faster, while in others barriers can be. The tradeoff is generally system and game dependent, though ROV tends to work well in cases where the number of barriers would be excessively high (e.g. with AA1 enabled). The slowest is copy loops, but it's basic and has universal support. It took a few months to implement and test because our current GS code was based around the other methods. It's also not an all-or-nothing approach since ROVs can be turned on/off within a single frame. We had to determine a heuristic for when to activate ROVs, since using them unnecessarily or switching too often can degrade performance. During the process we encountered some bugs with VK ROVs that took some time to sort out. The PR went through several revisions to find an approach that was both performant and maintainable from a coding perspective. Many people were involved in debugging, testing, and reviewing it to get it to its current state. Likely there will continue to be some adjustments as users encounter issues.

Simply put, this allows higher blending accuracy levels to incur less of a performance hit!

Here are some benchmarks:

Misc: Default to Direct3D 12 on Nvidia/AMD and mark Direct3D 11 as Legacy​

1387713827

Over the past several release cycles, the Direct3D 12 renderer has received substantial performance and compatibility improvements and is now at parity with Vulkan, and as such, we now default to it on Windows for most graphics cards.

As some of you have noticed, Direct3D 11 is marked as legacy, so what does this mean? This means that Direct3D 11 is the least preferred renderer to use and should only be used if the other renderers can't be used or have issues. Direct3D 11 will continue receiving updates and is in feature parity with the other renderers, but it's usually not the best option. Compatibility wise, it can work with a variety of hardware, both legacy and new, hence why it also matches the Legacy naming.

GS/DX12: Use Enhanced Barriers API​

13792

When Direct3D 12 launched, texture layout transitions (switching from a render layout to a read layout), texture access (does the GPU need to flush caches?), and GPU synchronization (waiting until we've done rendering) were done by simply specifying the resource state with resource barriers. This simplification, however, complicated feedback reads, requiring us to use aliased resources (two resources sharing the same memory) and relatively expensive aliasing barriers.

Direct3D 12 has since released "Enhanced Barriers" which replace the old resource state/barriers and allow greater control over texture layouts, texture access, and GPU synchronization. This greater control allows us to do away with aliased resources, and instead directly specify the layout, access, and synchronization we need for feedback reads.

In addition to simplifying feedback reads, the extra information we provide allows GPUs to more efficiently handle barriers, allowing better utilisation of the hardware.

Not every GPU benefits from Enhanced Barriers; RDNA2 and older AMD GPUs see minimal benefit, but newer GPUs see substantial improvements.

GS/HW: Add SW (Shader Based) Anisotropic Filtering​

14188

Anisotropic Filtering is a technique that improves the visuals of textures drawn at an oblique angle⁵. The effect is most noticeable on cobblestone or tile floor textures at native resolution. While the PS2 never supported this feature, PC GPUs have had hardware support for this for eons and PCSX2 offered it to improve visual quality of games.

Unfortunately, we encountered a few issues with hardware level Anisotropic Filtering on certain GPU models:

• AMD drivers would ignore our attempts to enable Anisotropic Filtering.

  • LightningTerror determined that providing a dummy mipmap layer had success on older GPUs; however, the workaround had only limited success on newer generations of AMD GPUs.

• Direct3D 12 did not allow Anisotropic Filtering and point filtering on the same texture.

• Point filtering is often used by games wanting a more pixel art style, instead of the smoothed sampling of other filtering methods.

• Due to limitations with the Direct3D 12 API, we had opted to ignore point filtering in favour of enabling Anisotropic Filtering.

• Unfortunately, this caused artifacts in Dragon Quest V where, without point filtering, some textures would have black pixels appear in them that were bleeding over from outside the texture's clamped area (see this issue).

Anisotropic Filtering in high level shaders is noticeably more demanding than using the GPU's native anisotropic filtering. Older GPUs may notice a mild to moderate performance degradation, and users are encouraged to re-check their anisotropic filtering setting to ensure it is not too high for their system to tolerate.

GS/HW: Merge together adjacent tristrips in drawlist.​

13943

This fixes a bug in tristrip detection that prevented triangle strips with 2 triangles from being detected. This brings a massive performance gain on some games.

GS: Fixes to CRTC merging​

14140

One of the features of the PS2 is the "CRTC" merge circuits, which allow for some limited post-processing and compositing of images before they are output to the screen. Some of the functionalities of these circuits, such as alpha blending two images together, are usually done with the standard rendering capabilities of the PS2. However, certain games make use of the CRTC merge circuits for things such as overlaying a loading screen on top of the render space.

Since this feature is not used frequently, there have been a couple of unresolved bugs. One such bug was fixed in #13300, where the game apparently left the CRTC merging functionality enabled with invalid settings. On the PS2 the settings would not have caused problems, as the alpha blending ended up erasing any possible side effects, so this had to be properly handled on the PCSX2 side. Another bug was fixed in #14140, where the game used CRTC merging to overlay a loading bar. PCSX2 wasn't updating the GS registers in the correct order, which caused the wrong image to be used for the loading bar.

This is Football 2003:

Before

After

GS/Texture Cache: Improve depth target lookup behaviour​

13875

In games such as Pachi Para, we were picking the wrong target from the available list, which resulted in a whole bunch of issues. This aims to correct the behaviour when the target expects to pick up a depth target.

PachiPara 13:

Before

After

GS/HW: Fix some target detection and format issues.​

14843

Fixes problems with target overlap of a single pixel and looking into the future to get the correct frame format on shuffles.

Single pixel overlap was happening on Steambot as it was drawing right on the edge of the target, then blending in the Z buffer, which is of course not good.

Also fixed an issue where when there is a texture shuffle it checks if the target is used in the next draw as a texture, but didn't consider if it was also a shuffle of a different type, so that is now corrected.

SteamBot Chronicles:

Before

After

Before

After

GS/HW: Adjust depth copies when doing Texture Cache moves​

13841

Previously, depth textures being moved in the texture cache would be done via GPU copy operations. Now they are done with shader copy/blit operations. Extra care was given to Direct3D 11, which does not support partial copies, and Direct3D 12 with its inconsistent driver-level support.

Kenran Butousai:

Before

After

Kunoichi:

Before

After

GS/Direct3D12: Don't end render passes on enhanced barriers​

13869

Following the addition of Enhanced Barriers, it was discovered that we can cut down the number of render passes (attachment state changes). In some scenarios this provided a nice further boost when using enhanced barriers on D3D12.

GS/HW: Improve destination alpha testing handling​

140591407314597

Previously it was believed that resolving these issues would require ROV; however, LightningTerror discovered that handling can be improved without needing ROV.

This further improves the destination alpha testing behavior to be more accurate in combination with incoming source alpha testing.

Energy Airforce:

Before

After

Before

After

The Sims - Bustin Out:

Before

After

The Sims 2:

Before

After

FIFA 2009:

Before

After

Persona 4:

Before

After

GS/HW: Framebuffer switching optimizations​

14301145671459514550

Avoiding framebuffer switching has been further optimized. This allows us to reuse the old framebuffer attachments, which provides an FPS boost.

To make it a bit simpler, the less re-binding/re-attaching is done, the better. However, great care is needed because if done improperly it can cause issues.

This change did not change performance noticeably beyond single digit changes.

What did decrease more was the reduction of bindings when using ROV on Direct3D 11; however, since there's a bottleneck elsewhere (ROV barriers themselves) we didn't see much of an FPS gain there either.

GS/HW: Further improve framebuffer copies.​

139481391714243

Further optimizations have been done to improve framebuffer copies which will be useful for all renderers when texture barriers are disabled or not supported. This is especially helpful for Direct3D 11 since we have no texture barrier support, other than ROV which can be faster for a lot of draw splits using full barriers but not single barriers/copies.

• Align drawlist bounding box to 4-pixel boundaries.

  • Will be faster using Direct Memory Access, otherwise it may stall as more commands need to be issued.
  • This will make the bounding box slightly larger but more friendly with GPU cache/VRAM.

• Expand 4-pixel boundaries correction to non-overlapping draws.

• If the copy area covers 95% or more of the render target size switch to full copies using CopyResource instead of CopySubresourceRegion.

• At this size using full copies should be faster.

Currently it is only used when texture barriers are disabled but can be used when Depth testing/Afail copies are implemented.

Next, multidraw framebuffer copies have been backported from Direct3D 11 to OpenGL in cases where texture barriers aren't supported, which may help some older drivers which lack support.

GS/HW: Enable non recursive sw blending on minimum level.​

14034

Since non-recursive blending is basically free and doesn't require a barrier/copy, we can just enable it on minimum level without any cost for better accuracy.

Sniper Elite:

Before

After

Star Wars Battlefront 2:

Before

After

GS/Direct3D11: Backport ds as rt from GL for depth feedback.​

14603

With the addition of depth feedback for Accurate Alpha Test/AA1, Direct3D 11 became painfully slow when using said features. This is because GPU depth copies are much, much slower on Direct3D 11 compared to color copies. A solution was to treat the depth as color, which would require additional shader copies, and later on, where we'd need a copy as a barrier, we'd do a color copy where we'd usually do a depth copy. This results in doubling the speed or more, even though technically we do even more copies with the addition of shader copies. This brings the speed closer to OpenGL without using ROV when using AAT/AA1.

GS/HW: Improve channel shuffle detection and use on 24bit sources​

13794

Improves lookup of sources when 24-bit targets are involved. Also merges single page targets into larger targets if they overlap.

Our channel shuffle emulation used to only look in our texture cache for textures with the full 32 bits valid. Since games like MotoGP shuffle use a 24 bit texture, we would never find a match (the top 8 bits were not valid). We now pre-check what bits the shuffle needs, and made our texture cache lookup a little smarter.

L.A. Rush:

Before

After

MotoGP:

Before

After

GS/HW: Improve texture hazard handling, shuffles + fix CSBW typo​

14455

Reduce hazard copies where they are not required and fix a typo in the SW renderer drop back.

A "hazard" occurs when a game is both writing to and reading from the same texture in the same draw. Our checks were only checking if the texture and target were pointing to the same place. It didn't actually check if it was reading and writing the same texels. If not, then there's no need to create a separate (hazard) copy as the data won't change. This will cut down a bunch of copies (as seen below). Also fixed a typo in the rect calculation for readbacks in the Software renderer fallback (CSBW), whoops.

Highlight number of copies reduced on the following GS dumps:

- 777  Bakusou Dekotora Densetsu - Otoko Hanamichi Yume Roman_SLPM-65234
- 448  Zettai Zetsumei Toshi 2 - Itetsuita Kioku-tachi_SLPS-25606_20251105164821
- 176  Haunting Ground_SLUS-21075_20220807194320
- 160  Syphon Filter - Dark Mirror_SCUS-97362_20240610050046
- 139  Blokus Club with Bumpy Trot_SLPS-20443_20251105235531
- 139  PachiPara 12 - Ooumi to Natsu no Omoide_SLPS-25574_20251105155128
- 139  PachiPara 13 - Super Umi to PachiPro Fu-unroku_SLPS-25682_20251105154553
- 139  PachiPara 14 - Kaze to Kumo to Super Umi in Okinawa_SLPS-25787_20251105160122
- 139  Steambot_Chronicles_SLUS-21344_20230511114115
- 138  hitmancontracts_l3_bjarkov
- 138  LEGO Racers 2_SLUS-20042
- 137  hitman (this is Blood Money)
- 130  Jak X - Combat Racing_SCUS-97429_20250526073932
- 127  LEGO Dome Racers_SLES-51303_20230717193026
- 114  Juiced_SLUS-20872_20230505163642
- 69   007 russia half screen
- 67   Minority_Report_-_Everybody_Runs_SLUS-20331_20221022205359
- 66   007 - From Russia with Love_SLUS-21282_20231202212313
- 66   Syphon_Filter_-_Logans_Shadow_SCUS-97584_20240104192224
- 45   FordRacing2CarShadow
- 40   Charlie and the Chocolate Factory_SLES-53386_20250214214241
- 38   Power_Drome_SLUS-20978_20240617182239
- 32   Knight Rider - The Game_SLES-51011_20230301100135
- 28   The_Godfather_SLUS-21385_20240206091914
- 26   The Bigs 2_SLUS-21860_20250303214104
- 25   Need for Speed - Undercover_SLUS-21801_20240712020737
- 24   Indiana_Jones_and_the_Emperors_Tomb_SLUS-20508_20230206223913
- 24   Killzone_SCES-52004_20240617170050
- 24   Prince of Persia - Sands of Time_SLUS-20743_20250528185119

GS/HW: Improve fog accuracy in HW Renderers​

13844

Improves the fog modulation in the hardware renderers to match the PlayStation 2. This doesn't account for interpolation where the colour changes across the primitive, that will still be slightly out.

The original formula was based on doing 255 - fog_coeff, which is incorrect, it's actually 256 - fog_coeff. Most of the time this doesn't matter, but in Steambot it makes a huge difference to the fog colour.

Steambot Chronicles:

Before

After

Okami:

Before

After

Hitman - Blood Money:

Before

After

GS/HW: Floor depth writes to improve Z testing​

13795

Floors the depth write values in the hardware renderers to improve Z-fighting and bring depth testing closer to software accuracy.

On the PlayStation 2, only integer depth is available. On PC GPUs, interpolating primitives produces a sliding scale of decimal values, which can cause depth tests to fail when they shouldn't. Flooring the depth write values gets rid of these false failures and fixes Z-fighting across a ton of games.

Harry Potter:

Before

After

Need for Speed - Underground 2:

Before

After

Okami:

Before

After

Tony Hawk's Pro Skater 3:

Before

After

GS: Add draw buffering option​

13950

Adds a new optional draw buffering setting under Manual Hardware Fixes to reduce draw calls in games with excessively high draw counts.

Several games, notably Primal Image and Need for Speed titles, perform alternating draws every triangle (e.g., texturing a triangle, applying a reflection map, then blending), which creates heavy context switching. Buffering these draws provides huge performance improvements by significantly cutting draw calls and barriers.

Highlight number of draw calls reduced on the following GS dumps:

- Brothers in Arms - Road to Hill 30 (Menu): Draw Calls: -9,272 [10,105 => 833]
- Primal Image: Draw Calls: -6,972 [8,083 => 1,111], Barriers: -3,056 [3,484 => 428]
- Need for Speed: Underground 2: Draw Calls: -2,796 [5,624 => 2,828], Barriers: -1,394 [2,975 => 1,581]
- Stuntman: Draw Calls: -2,668 [4,572 => 1,904], Barriers: -1,182 [2,024 => 842], Uploads: -9 [111 => 102]
- Need for Speed: Most Wanted (Black Edition): Draw Calls: -2,425 [4,189 => 1,764], Barriers: -1,151 [2,100 => 949]
- Armored Core: Nine Breaker: Draw Calls: -2,400 [3,921 => 1,521]
- Need for Speed: Carbon: Draw Calls: -1,980 [4,956 => 2,976], Barriers: -971 [1,692 => 721]
- The Sims: Bustin' Out: Draw Calls: -1,782 [4,693 => 2,911], Barriers: -48 [56 => 8]
- Need for Speed: Undercover: Draw Calls: -1,627 [4,107 => 2,480], Barriers: -518 [1,020 => 502]
- X-Men 2: Wolverine's Revenge: Draw Calls: -1,455 [1,809 => 354], Uploads: -2 [26 => 24]

GS: Optimize draw buffering and pointer logic​

14729

Following the addition of draw buffering, this follow-up cuts down on unnecessary environment copies when draw buffering is disabled or when subsequent draws can't be buffered. Previously, the context was being backed up and restored during flushes even when not needed, wasting CPU cycles.

Pointers added by draw buffering were also replaced with local references, helping reduce GS CPU load on weaker machines.

GS/HW: Support offsetting for channel shuffle instead of copying​

13762

Adds support for offsetting reads during channel shuffles, removing the need to copy memory pages for every single draw. This eliminates huge numbers of redundant texture copies and render pass transitions, significantly boosting performance in titles that make heavy use of render-target-in-render-target operations.

Highlight number of render passes and copies reduced on the following GS dumps:

- Zettai Zetsumei Toshi 2: Itetsuita Kioku-tachi (Raw Danger): Render Passes: -1,120 [3,094 => 1,974], Draw Calls: -672 [3,726 => 3,054], Copies: -672 [1,355 => 683], Barriers: +448 [484 => 932]
- Hitman: Contracts: Render Passes: -847 [1,426 => 579], Draw Calls: -427 [1,907 => 1,480], Copies: -427 [564 => 137], Barriers: +305 [85 => 390]
- Manhunt 2: Render Passes: -696 [1,006 => 310], Draw Calls: -417 [1,409 => 992], Copies: -417 [425 => 8], Barriers: -140 [140 => 0]
- Stolen: Render Passes: -515 [2,653 => 2,138], Draw Calls: -258 [2,849 => 2,591], Copies: -258 [277 => 19], Barriers: +56 [133 => 189]
- Ghost in the Shell: Stand Alone Complex: Render Passes: -333 [1,543 => 1,210], Draw Calls: -334 [4,413 => 4,079], Copies: -333 [701 => 368]
- Project: Snowblind: Render Passes: -288 [457 => 169], Draw Calls: -157 [596 => 439], Copies: -157 [194 => 37], Barriers: +153 [4 => 157]
- Blokus Club with Bumpy Trot: Render Passes: -280 [2,555 => 2,275], Barriers: -140 [489 => 349]
- PachiPara 12: Ooumi to Natsu no Omoide: Render Passes: -280 [2,191 => 1,911], Barriers: -140 [289 => 149]
- Wild ARMs 5: Render Passes: -266 [818 => 552], Draw Calls: -267 [901 => 634], Copies: -266 [269 => 3]
- Hitman: Blood Money: Render Passes: -265 [481 => 216], Draw Calls: -135 [929 => 794], Copies: -134 [182 => 48], Barriers: +124 [221 => 345]

GS/HW/COLCLIP: Check tex mapping is enabled when checking for recursion​

14418

Checks that texture mapping is enabled before checking if a recursive draw is about to happen.

Some games (Cowboy Bebop and Detective Conan) set the texture address to the same address as the frame buffer even when texture mapping isn't being used. This was confusing PCSX2 into repeatedly resolving COLCLIP HDR targets, causing massive slowdowns. Explicitly checking if texture mapping is enabled cuts out hundreds of unnecessary render passes and barriers.

Highlight number of draw calls and render passes reduced on the following GS dumps:

- Cowboy Bebop: Tsuioku no Serenade: Render Passes: -1,589 [1,604 => 15], Draw Calls: -1,262 [4,434 => 3,172], Copies: -1,261 [1,265 => 4], Barriers: -502 [502 => 0]
- Detective Conan (Menu Graphics Bug): Render Passes: -460 [471 => 11], Draw Calls: -376 [1,599 => 1,223], Copies: -376 [380 => 4], Barriers: -168 [176 => 8]
- Rayman 3: Hoodlum Havoc: Draw Calls: -6 [210 => 204], Copies: -6 [34 => 28], Render Passes: -5 [64 => 59]
- Disney's PK: Out of the Shadows: Draw Calls: -2 [85 => 83], Render Passes: -2 [23 => 21], Copies: -2 [9 => 7]

GS/TC: Allow creation of target during GS->GS transfer with offset​

13872

Allows the texture cache to create render targets during GS-to-GS transfers when an offset is used, provided the offset and widths match.

Previously, these transfers failed to match a target and triggered slow GPU-to-CPU readbacks. Handling them directly in the texture cache allows menus in Dynasty Warriors 2 to upscale properly, while giving Time Crisis 3 roughly a 30% speedup by avoiding readbacks.

GS/HW: Improve inside target wrapping and clear draw behaviour​

13701

Improves GS memory clear behavior when a clear isn't immediately followed by a draw, making sure unwritten areas in GS memory are properly cleared instead of being left full of garbage data. This fixes flashing shadows in Beyond Good & Evil, shadow bugs in Ford Racing 2, the menu in Black, and FMV playback in 60Hz Silent Hill 3.

Black:

Before

After

Ford Racing 2:

Before

After

GS/HW: Properly scale depth up if required when native scaling is in use​

13849

Correctly scales up depth stencils when the render target is at a higher scale.

When Native Scaling was enabled, depth stencils were getting scaled down and then back up, but instead of resizing to the upscaled resolution, they were being copied directly, causing the depth stencil to slowly get smaller and smaller! Properly upscaling depth stencils fixes depth bugs in Xenosaga Episode III and The Nightmare Before Christmas, and stops Steambot Chronicles from erroneously turning blurry.

GS/TC: Only bilinear resize depth if downscaled​

14685

Makes sure depth target resizes use nearest-neighbor filtering unless the depth target is downscaled, in which case bilinear filtering is used.

Using bilinear filtering on a depth target that isn't scaling actually corrupts depth values, resulting in ugly rendering artifacts. Restricting bilinear filtering only to downscaled depth targets fixes broken foot shadows in Kingdom Hearts and geometry glitches in The Nightmare Before Christmas.

Kingdom Hearts:

Before

After

Nightmare Before Christmas:

Before

After

GS/HW: Improve iRem CRC hack​

13839

Improves the Irem CRC fix to better handle depth-channel shuffle effects.

Our game-specific hack for Irem titles was missing some of the ways these games use depth-buffer channels for post-processing. Handling these additional cases restores proper lighting, sky colours, and water effects in Raw Danger! (Zettai Zetsumei Toshi 2) and PachiPara 12.

Zettai Zetsumei Toshi 2 (Raw Danger):

Before

After

Pachi Para 12:

Before

After

GS/TC: Delete empty target after height adjust​

13837

When a new texture is loaded into the texture cache (TC), some bookkeeping is required to ensure that older entries don’t overlap with it. Otherwise, the game could read stale data from an old entry. We call this process preloading.

For example, if a new texture overwrites the top half of an older texture, the TC shrinks the older entry and adjusts its starting address to cover only the remaining data.

Previously, preloading could shrink an older entry to a height of zero without deleting it. A subsequent draw could then mistakenly select that empty entry as its texture source, preventing the texture from being updated with the correct data from memory.

Deleting these zero-height entries fixes missing textures in PachiPara 13.

PachiPara 13:

Before

After

GS/CLUT: Handle special case for CSM2 32bit mode switch​

14546

Adjusts CLUT (Color Look-Up Table) Storage Mode 2 behavior to always load palette data directly from local GS memory rather than reusing a cached buffer.

In Breath of Fire: Dragon Quarter, the game loads a palette in Storage Mode 1 (which swizzles the palette entries) and then immediately switches to Storage Mode 2 (which expects linear, sequential data). Reusing the swizzled buffer caused palette indexing errors, creating speckled black holes across dialogue and menu fonts. Reading directly from local GS memory for Storage Mode 2 restores clean, legible text.

Breath of Fire - Dragon Quarter:

Before

After

GS/TC: Add new HW Readback option to force full download​

14541

Adds a new Hardware Download Mode option, Accurate (Force Full), under Advanced Graphics settings.

Some games issue multiple small, partial GPU-to-CPU readbacks per frame, which is much more cumbersome than doing a single consolidated readback. In games like SSX and Armored Core 3, forcing one full readback can provide a noticeable performance boost.

GS: Disallow flipped GS->GS transfer when destination overwrites source​

13791

GS local-to-local transfers are essentially memory copies within VRAM. Games can reverse the horizontal or vertical copy direction, but when the source and destination overlap, this can cause PCSX2 to overwrite source data before it has been read.

Original hardware avoids this problem with its GS page cache. Because PCSX2 performs these transfers without a cache, it now overrides unsafe reversed copies with a forward copy. This fixes heavily corrupted lighting and textures in Armored Core 2.

Armored Core 2:

Before

After

GS/TC: Check format matches on invalidation rect translation​

13828

Adjusts page invalidation calculations when texture formats don't match between source and destination targets.

Previously, invalidation rects were calculated using destination block alignment. Because block layouts can be wildly different across formats, partial rects were misaligning and leaving stale texture data behind. When formats don't match, we now invalidate the entire page instead, fixing corrupted text in the Final Fantasy X-2 load menu and broken terrain in Battle Engine Aquila.

Final Fantasy X-2:

Before

After

Battle Engine Aquila:

Before

After

GS/HW: On EE->GS transfer only invalidate area actually transferred​

13902

Restricts texture cache invalidation rectangles during EE-to-GS transfers to the actual data dimensions transferred rather than the declared packet size.

In Star Wars: The Clone Wars, the game declares an oversized upload rectangle (16×4096) while only transferring a small fraction (16×96). Previously, passing this declared rectangle to the texture cache erroneously invalidated active framebuffers in adjacent memory, causing the renderer to reload corrupted data. Restricting invalidation to the actual transferred area fixes character model corruption in Star Wars: The Clone Wars.

Star Wars - Clone Wars:

Before

After

GS/HW: Correct buffered rect size of corrected EE->GS transfers​

14382

Fixes an issue when merging sequential EE-to-GS transfers targeting the same memory address, ensuring transfer bounding rectangles are properly combined rather than overwritten.

Previously, subsequent transfers to identical addresses were overwriting the stored bounding box instead of expanding it. When this rectangle was later used to determine texture target dimensions, incorrect sizes were calculated. Properly uniting these transfer regions fixes missing graphics on the loading screen in Mercenaries: Playground of Destruction.

Mercenaries:

Before

After

GS/TC: Update dirty target linked to source when dirty overlaps the read​

14419

Properly update render targets when linked to an existing source that is in-use (dirty) and overlaps the requested read address in the cache.

If a source texture was updated via EE-to-GS upload (and still in use by a target), there were cases where the texture cache was not updated properly, causing old data to be used. Updating the dirty linked target fixes corrupted arrow sprites in Pump It Up: Exceed.

Pump It Up - Exceed:

Before

After

GS/TC: Check valid area overlap on exact match Tex is RT​

14604

Check for overlap in the draw/read area in a scenario where an exact target match is found.

If a target was drawn with an offset and a texture upload was done earlier in the target, matching purely by memory pointer caused the renderer to pick the target and sample uninitialized black pixels instead of triggering an upload. Checking that the rect overlaps the target's valid area fixes black geometry glitches in Devil May Cry.

Devil May Cry:

Before

After

GS/HW: Remove zero clear from GSUploadQueue, use transfer_type instead​

14409

Refactors the GS texture upload handling to use the transfer type for clears instead of a separate variable.

The transfer type field was previously left uninitialized during zero-clears, causing undefined behavior depending on the build and memory state. Explicitly requiring the transfer type eliminates this redundant variable and fixes missing publisher logos during intro and loading screens in Worms 3D.

IPU: Reset dc dct precision on soft reset​

13961

Resets DC DCT (Discrete Cosine Transform) decoding precision in the IPU during soft resets.

When the game would send a reset command to the IPU, we were mistakenly not resetting some of the internal IPU state. In particular, the DCT (Discrete Cosine Transform) decoding precision.

Clearing this precision state on reset fixes severe screen flashing during FMV video playback in Critical Velocity.

Footnotes​

New Year - New Build​

Now that the dust has settled down from our biggest single release to date, we decided to step back a bit and give more love and attention to the interface, quality of life features and accessibility. There are also more performance improvements to be seen, which we are very excited to show you! Our contributors have been hard at work further refining the foundation that has been laid out since 2.0.0 to make PCSX2 more accessible to everyone!

Major New Features​

Better Feature Parity Between Big Picture Mode and Qt Interface​

127401294413294

SternXD has been on a mission to achieve feature parity between Big Picture Mode and the Qt interface. Thanks to his work, you can now adjust Network & HDD Settings, create a Memory Card, as well as login to RetroAchievements directly from Big Picture Mode!

New icon for RetroAchievements Qt login dialog (#13718)​

Alongside Big Picture Mode getting a new RetroAchievements login dialog, Qt's login dialog also gets a small facelift! It now shows the actual RetroAchievements icon instead of a generic login icon.

Korean Game Titles​

13199

Despite having nearly 700 known NTSC-K serials, the GameDB has for a long time only had Latin versions of the titles. These titles were pulled from the NTSC-U/PAL name or from a Romaji version of the Japanese name. PCSX2 now has 100% complete Korean translation on our Crowdin (at the time of writing), a milestone which has been a long time coming. TheTechnician27 has been working on adding Korean game titles to most NTSC-K serials which did not previously have them.

Game Shortcut Creation Feature​

12746

KamFretoZ set his sights on adding the ability to create desktop (or start menu) shortcuts for your games from inside PCSX2. Motivated by this GitHub issue and lots of feedback on Discord, this was a very popular ask from users!

Custom Background Support​

1272213410

What started as a silly idea between KamFretoZ and JordanTheToast to see what's possible with Qt, ended up becoming a full blown feature. With this, you can now set a custom background (even animated ones too!) on your game list to your heart's content.

Emoji Support for Big Picture Mode​

1300912678129701297012837

Allows emojis to be shown in Big Picture Mode and the fullscreen pause menu. RetroAchievements popups would often use emojis; these are now able to render as well.

Not all emojis are supported; this is a limitation of ImGui, the library we use for this.

For the longest time, our Big Picture Mode UI was unable to display emoji due to limitations with ImGui. This was especially apparent when displaying emojis from certain RetroAchievements sets. Thanks to ImGui fixes and AirGamer's efforts, we have finally implemented emoji support in PCSX2's Big Picture Mode.

On a more technical level, previous version of ImGui required us to provide ranges of characters we needed. ImGui would then generate a font atlas from this. This required that we either hardcode, or generate these ranges for any languages we support in PCSX2. With ImGui 1.9.21, we can now rely on ImGui to dynamically adjust its font atlas on its own, removing the maintenance burden of fixed character ranges.

Before:

After:

Big Picture Mode Icon Refresh​

Big Picture Mode just got a small facelift! You might have noticed inconsistencies where some options had an icon while others did not. Now, every settings entry has an icon to go along with it.

Additionally, we can add emoji as icon too! 🔥

Various Blending and Hardware Renderer Improvements​

GS/Direct3D12: Added Feedback Reads Support​

13653

Upon looking through the Direct3D12 documentation, it was found that aliased resources (two resources sharing the same memory) could be used to bind the same texture as both a shader resource and render target. This relies on the two resources being able to inherit data from each other, the requirements of which can be satisfied using simultaneous access textures.

This allows us to speed the Direct3D12 renderer up substantially, with some systems seeing over 5x improvements on specific games.

While NVIDIA and Intel Arc GPUs had no issues, lightningterror discovered that some AMD GPUs showed issues. While the Direct3D12 documentation implies that data inheritance should work even with undefined memory layouts, the texture layout needed to be specified for some generations of AMD GPUs. Once this issue was identified it was fortunately an easy fix to implement.

While reviewing the code, lightningterror spotted and fixed a regression with handling stencil DATE one.

There have also been other enhancements to the hardware renderer where games such as Enthusia gained a significant 9% improvement in Direct3D11.

GS/Direct3D11/12: Support Multidraw Framebuffer Copy​

13164131971320613365

Add implementation for Multidraw Framebuffer Copy for Software Blending, Framebuffer Masking, Software Destination Alpha Testing. In order to replicate the current behavior on our more accurate renderers such as Vulkan and OpenGL without the use of Texture Barriers, LightningTerror discovered that we can achieve the same accuracy with the use of Texture Copies albeit at a slightly higher performance cost compared to using barriers which Direct3D11 doesn't support. Direct3D12 does and such implementation is already implemented later on by AirGamer.

To give a bit of context why we need copies/barriers, it is because a texture cannot be bound at the same time as a render target view and shader resource view, a copy is created from the same render target so we can have two separate textures with the same data instead of using the same one which is a hazard, Vulkan and OpenGL use texture barriers that nullifies the need for a copy which allows one texture to be used for both.

To alleviate some of the performance hit, we later on added some optimizations which will be mentioned in the report.

To keep it short this makes Direct3D11/12 as accurate as Vulkan and OpenGL.

Here is some comparisons for those looking for visuals. It will be almost impossible to post all the fixes games since there are a lot, so here's just a few:

Before

After

Before

After

GS/Direct3D11/12: Implement Depth Testing and Sampling​

131801353913344

Similar to our issue with software blending, our old implementation for depth testing and sampling used copies for Direct3D11/12 to avoid the texture binding hazards being bound as a depth stencil view and shader resource view at the same time. However when we use a depth texture if we are not writing anything to the depth buffer in the case where both the source and destination texture are the same we can bind them at the same time:

• In Direct3D11's case we create and bind a new read-only depth stencil view, simultaneously also binding the same texture and binding it as a shader resource view which allows us sampling depth in the shader, but no writing to the depth buffer which is unnecessary.

• In Direct3D12's case we just transition the texture to be read only which also allows us to bind it both as a depth stencil view and shader resource view at the same time.

Some nice benchmarks showing the difference in cutting off the texture copies that we previously used:

GS: Texture Copies and Barriers Optimizations​

13276132981330513354135951357612969

In #13276 and #13298 following the implementation of software blending on Direct3D11, LightningTerror decided to improve the function itself that deals with texture copies. Some optimizations that were previously not present on OpenGL, Direct3D11 and Metal were backported from Direct3D12 and Vulkan which reduces the number of copies in some specific scenarios, and aborting invalid copies. This gave us a small boost in some games that used texture copies regardless of renderers as copies were required.

Afterwards in #13305 some ideas were floating around how to further improve copies/barriers so TJnotJT decided to take on the task, the improvements are as follows:

1. Unify and batch triangle primitives. This allows us to reduce the number of copies/barriers per draw.

2. During texture copies, only copy the region that we need, not the entire draw. This makes texture copies faster and use less VRAM on Direct3D11/12.

Why this is faster?

• Example #1: In the first case batching means instead of issuing 5 copies/barriers for 5 triangles separately we can batch all 5 if they don't overlap each other and issue only 1 copy/barrier which is much faster.

• Example #2: In the second case we only copy what is necessary. Previously we copied the entire draw which was much slower.

Next up in #13354, TJnotJT also implemented another optimizations which further reduces copies/barriers on all renderers:

1. Added utility functions for detecting when vertices form axis-aligned right triangles or quads.
2. Updated primitive overlap detection to account for pairs of triangles that together form axis-aligned quads.

But wait there's more!

A while back, we added extra barriers to fix some bugs in Time Crisis. In #13595 TellowKrinkle discovered that those barriers were getting added on all GPU vendors. Upon further inspection, it appears as an NVIDIA driver bug, rather than actual issues with our OpenGL API usage. This allowed us to cut down the barriers on OpenGL on other GPU vendors by a lot.

Here are the top 5 highest barrier reductions we have found:

WRC 4
Barriers: -6604 [13473=>6869]

Need for Speed: Most Wanted
Barriers: -2125 [4250=>2125]

James Bond 007: Agent Under Fire
Barriers: -1646 [3284=>1638]

Ace Combat 04: Shattered Skies
Barriers: -1304 [1306=>2]

Avatar: The Last Airbender
Barriers: -999 [17716=>16717]

More, more!

Following the adjustments by TellowKrinkle, LightningTerror has discovered that we can further cut down the barriers on OpenGL in #13576. We do this by only issuing a barrier when we modify the previous draw call or render pass. This ensures that writes are properly ordered.

The optimization involved the case where we were issuing both a render pass and barrier. The render pass already behaves as a barrier, so we skip the barrier and only do a render pass.

Here is even more barrier count reductions that we found:

Ace Combat 04: Shattered Skies
Barriers: -1302 [1306=>4]

Final Fantasy XII
Barriers: -1144 [2291=>1147]

The Getaway
Barriers: -1001 [2002=>1001]

Keroro Gunsou - Mero Mero Battle Royale
Barriers: -1530 [3071=>1541]

Need for Speed - Carbon
Barriers: -2073 [3769=>1696]

Need for Speed: Most Wanted Black Edition
Barriers: -2125 [4250=>2125]

Stuntman
Barriers: -2026 [4053=>2027]

Transformers Special Edition
Barriers: -2160 [4320=>2160]

WRC 4
Barriers: -6603 [13473=>6870]

MORE!

In #12969, Refraction found a way to improve dirty and readback handling.

This optimizations cuts out readbacks on some games (Dark Chronicle, Eveybodys Golf/Hot Shots Golf Fore, Kamen Rider- Seigi no Keifu) which brings massive performance boost. Here is more benchmarks:

GS/Texture Cache: Optimize Block Offset Calculations​

1333913349

An optimization was found in several loops where we can swap the x and y coordinates resulting in higher performance. This is because how CPU caching works where x is linear memory and y needs to jump around causing a cache miss every time, so by swapping them around it allows us to better use CPU caching.

We also added some extra conditions to avoid going through the loops, as well as some more caching mechanisms for even better performance.

Here are more benchmarks:

GS/HW: Abort Unnecessary Draw Calls​

135261361213651

In some specific scenarios, draw calls can be skipped when the render target remains unchanged and depth is not written. Expanding these conditions allows us to cancel unnecessary draw calls. This reduces GPU work, barriers, and copies, leading to significant performance improvements in some cases.

Here are even more benchmarks:

GS/Direct3D11/12: Destination Alpha Testing Optimizations​

13549135751369613525

With software blending added on Direct3D11/12, we can optimize some features. When software blending is already active, destination alpha testing can be done directly in the shader, which is faster than multiple passes. Texture copies are already enabled, allowing us to reuse them for destination alpha testing and eliminate the extra passes previously needed.

Some optimizations are missing on Direct3D12 like #13525 but will be implemented during the v2.7 dev cycle.

GS/HW: Shuffle improvements​

13142131381300513685

Several fixes have been made to texture shuffle emulation in order to fix some long-standing issues with games.

Handles Texture Shuffle With Pixel Reversals (#13142)​

We now detect when a game (Colin McRae Rally 2005) is doing a texture shuffle and (a) flipping pixel locations horizontally in columns and (b) correcting the pixel locations by flipping pixels horizontally again. We can then ignore both flips so that they cancel out. To keep it short, this fixes Colin McRae Rally and it is now playable with no hardware rendering issues.

Before

After

Handles Texture Shuffle Sprite Not 16-pixel-multiple Wide (#13138)​

Do special handling for texture shuffling sprites that are not 8 pixels wide or a multiple of 16 pixels wide. Align such sprites to 16 pixel boundaries horizontally. This fixes some issues on Alter Echo.

Add CRC for Sand Grain Games Palette Shuffle Effect (#13005)​

We have no way to do this effect directly without having 50-100 readbacks per frame, which is very very slow. This emulates the effect they're trying to achieve (G→A shuffle with palette).

This fixes some long-standing issues with Cabela's games, image comparisons below:

Before

After

Before

After

Detect offset shuffle on TexIsFB (#13685)​

Updates our “current texture is the framebuffer” heuristics to handle horizontally offset shuffles. This fixes a Timesplitters 2 issue where the wrong data was copied.

GS/SW: Do Pre-Clamping of ST Coordinates When They May Overflow​

13240

The input texture ST coordinates can sometimes be extremely large or NaN, for reasons that aren’t fully clear (it could be due to emulation quirks or game bugs). When these coordinates reach the rasterizer, they can cause issues with calculating vertex trace values, determining texture bounding boxes, and other related computations. These problems may lead to graphical glitches downstream. This PR aims to address these issues by applying the following fixes:

1. Add checks in the vertex trace for NaN ST values.
2. Add checks in the SW renderer for ST values that would overflow the fixed point format used for texture coordinates in rasterizer.
3. Rewrite vertices and clamp the problematic ST values to a value less that the maximum representable by the rasterizer. Rewrite any NaN values to 0.

Here is an example comparison:

Before

After

GS/HW: Remove Handling of Provoking First Vertex in Early Pipeline​

12986

Remove the handling of provoking first vertex in early pipeline. This is mainly for Direct3D11/12 as other renderers usually support provoking first vertex early in the pipeline. This allows us to fix some issues on Direct3D11/12 in some games where provoking first vertex isn't supported.

Before

After

GS: Miscellaneous Fixes​

133691312713028130841309413300129831350513171

Various smaller PRs which address crash fixes, bug fixes, regressions and such:

• Improved manual deswizzling detection which fixes some graphical issues on Stolen and shuffle detection. (#13369)
• Adjusts updating render target and depth stencil to improve resizing which fixes Final Fantasy X battle transitions. (#13127)
• Don't split/resize buffer when texture buffer width is 0, fixes Baldur's Gate regression. (#13028)
• Allow full dirty rect on zero age targets. This fixes Kaena graphical issues at the bottom of the screen. (#13084)
• Refactor autoflush handling; detect recursive draw on mipmap layer > 0. This fixes Conspiracy - Weapons of Mass Destruction and Warhammer 40,000 Fire Warrior where lights can be seen through walls. (#13094)

Before

After

Before

After

• Ignore output on RC1/2 when the data is not used. This fixes Sakura Setsugekka and Phantom of Inferno rendering issues. (#13300)

Before

After

Before

After

• Fix temp Z and clear detection regressions. Fixes an issue with temporarily offset Z and a clear misdetection. (#12983)
• Fix up invalidly selected Tex in RT targets. Fixes Tomb Raider Legends, Battlefield 2 and Xenosaga III regressions. (#13505)

Before

After

Before

After

Before

After

• Use accurate fog equation. Avoids using the mulhrsw instruction, since it rounds instead of truncating which improves fog emulation in software renderer in some games. (#13171)

The Resizing Saga​

136821369713614

It all started with #13613. One of our testers, JordanTheToast had recently upgraded to a Radeon RX 9060 XT. He noticed that resizing PCSX2 while in-game causes massive lag/delay during the resize. This ended up turning into a deep dive that confused the team for days. A look into GPU driver bugs, and the way Qt handles window resize events slowly uncovered the problem.

GovanifY put up a fight (#13614) by fixing the way Qt handles window resizing in order to make it not fire up multiple resize events per millisecond (yes, multiple per millisecond).

Following #13614, it was noticed that smooth rescaling stopped working on NVIDIA. This issue arose from how we handled swapchain recreation on resize. We were accidentally recreating it at the end of the frame, only on the NVIDIA platform.

During resizing, the swapchain would become invalidated between the end of one frame and the start of the next, causing rendering to appear frozen.

The fix was to simply defer recreating the swapchain until the beginning of the frame.

But It doesn't end there...

It was also noticed that RDNA 4 would experience significant delay in resizing even after #13614 was merged.

This was determined to be due to a Vulkan function vkAcquireNextImageKHR taking two seconds to complete following a swapchain re-creation. A workaround for this driver bug was to not link the old swapchain to the new one.

While implementing this fix, support for VK_KHR_swapchain_maintenance1 was added. This may reduce the memory usage from resizing on AMD GPUs with updated drivers. NVIDIA supported the older version we had already been using, so no change is expected there.

Quality of Life Improvements​

Add Qt Buddies and Tabstops​

13388

This addition to PCSX2's menus improves accessibility by allowing screen readers to more reliably navigate the interface. It also significantly improves the order of screen elements when navigating with keyboard keys like tab.

Buddies​

Buddies are properties in Qt which associate a label with an interactive element. This is transparent for most users, but for users with a screen reader this means you can actually tell what an interactive element does. It's a win for accessibility!

For example, focusing a dropdown will just say that you've focused a dropdown without saying what it's supposed to be for – rendering much of our UI totally unusable. With a buddy, it will read out the label on top of the element type. As an example, with buddies the OSD scale option will read approximately as "OSD Scale: Spin Box 100", but without, it will only read "Spin Box 100".

Tabstops​

Have you been in a situation where you have to use a keyboard to navigate your way through PCSX2 and found out that the ordering between options are complete nonsense? Tabstops are here to help!

Tabstops are another property of Qt which allow an explicit ordering of elements when tabbing through a widget (i.e. focusing on one element then pressing Tab). Without them, the tab order is subject to the physical ordering of the elements in XML, which does not inherently correspond to the row/column order displayed and is highly unreliable and unrealistic to maintain.

Improvements to PCSX2 related files handling on macOS​

1282912830

TellowKrinkle, our resident macOS housekeeper, has been working on adding file type associations for some of the file types that can be opened by PCSX2. This includes game dumps (ISO, CSO, ZSO, CHD, etc), save states, GS dumps, PNACH patches, and more.

PCSX2 on macOS Now Uses Qt 6.10​

13407

For a long time, macOS has been stuck on Qt 6.7, due to Qt 6.10 dropping support for older macOS versions. It turns out Tellow discovered that it's trivial to patch compatibility for older macOS versions back into Qt 6.10. The rest is history!

Improved Display Surface (And Wayland!)​

13466128641336013555135571357712864

We have enabled Wayland support by default since PCSX2 2.4.0 release and in this cycle, AirGamer has yet again spearheaded the work to improve Wayland support even further. This time we're cutting out the cruft, resolving technical debt, and implementing it the way it was intended with Qt.

For more technical details, previously the way we rendered into a "surface" was to render it to the widget directly. While this was the canonical method for older versions of Qt, the Qt maintainers mentioned that this was not recommended and a newer method was better suited. This has caused some issues, especially with Wayland.

Instead, this new method now uses a Qt Window instead of a Qt Widget, avoiding issues inherited by the previous method and allowing for the removal of a number of Wayland specific workarounds. This further improves Wayland compatibility with PCSX2.

Simplified Wayland Plugins AppImage Bundling (#12864)​

linuxdeploy doesn't correctly deploy some Wayland dependencies with the Wayland client modules.

Previously, we manually copied these dependencies into the AppImage. However, it was discovered that specifying the Wayland compositor module will copy the needed client dependencies. This allowed us to simplify our AppImage build script.

New Gamma Adjustment Option​

12653

Gonzalosilvalde has worked on adding gamma adjustment to shade boost within the post processing options. Adjusting the gamma allows you to intensify the shadows while keeping the overall color balance intact.

Adjustable Position for Various In-Game Overlays​

1295312698

SternXD and flavionm have worked on a feature where you can adjust the positions of all overlays inside PCSX2 (such as achievements and OSD notifications).

New Hotkey to Swap Memory Cards​

12640

Allow users to swap Memory Cards slot on demand using a hotkey (unbound by default).

To quote Haisom:

This is really useful on shared machines, specially with kids around (Forget kids accidentally overwriting your save games with over 100 hours of gameplay!).

Organize Game Screenshots by Name in Folders​

12934

Have you ever been in a situation where your snapshots folder turns into a disorganized mess of recordings and screenshots after you have used these features for a while?

Thanks to fthomys (This is also their very first contribution, thank you!), you can now organize your snapshots folder by game names.

New Indicators for Texture Dumping/Replacement​

13590

Ever wondered if your texture replacement is working? Tried eyeballing it to no avail? Worry no more! You can now enable the Texture Dumping/Replacement indicator to find out if you have the textures being dumped/replaced correctly.

Various Smaller Improvements in 2.6​

Automatically Launch Big Picture Mode on Startup​

1284812945

For those who want the true living room couch gaming experience, you can now launch PCSX2 directly into Big Picture Mode and start gaming right away!

Customizable Game List Column Header​

13559

You can now customize the columns of the game list, such as adding/removing and re-ordering the columns as you see fit!

Improved Mouse Lock DPI Handling​

1340313592

This improves upon #13403 while also fixing issues introduced in the Qt Window update. This fixes mouse lock on setups with multiple monitors using DPI scaling greater than 100%.

Now mouse lock should function correctly regardless of your monitor setup on Windows and Mac.

Support Full Axis Binds of SDL Gamepad Axes​

13623

In SDL, a controller has both a joystick instance and gamepad instance (if SDL has a mapping for it). An SDL joystick is just a collection of buttons and axis and an SDL gamepad has those buttons mapped to a standard gamepad layout. In PCSX2 we accept binds for both the gamepad inputs and any joystick inputs that SDL hasn't mapped. You might recognize these as "Axis X +" or Axis Y -".

Previously, we had separate code for loading joystick axis binds and gamepad axis binds, with only the former supporting full axis binds. This change adds support for "Full Axis" gamepad inputs, which should improve support for special input devices which have axes but do not necessarily have a positive and negative direction, such as the pedal on a wheel.

Improved Hotkeys Section​

13015

TheTechnician27 worked on rearranging and reorganizing the hotkey section to give you a more cohesive user experience.

This is only a small sample of the changes made for this release! If you are interested in all the other fixes and additions that made it into this release, a full list of commits can be found on GitHub.

PCSX2 2.2.0​

PCSX2 2.0 may well have been our biggest single release to date. With several major contributors stepping back, including longtime PCSX2 lead developer refraction, the remaining team – still energized to contribute – confronted reality: for the first time in a long time, we'd delivered what we had to offer in the way of big, bombastic new features. What we resolved for PCSX2 2.2 was to take it out of the furnace, let it cool, and hammer it into something more refined before getting up to speed again in 2.4. For this period of a few months, the word on everyone's mind was "polish".

New Emulated Peripherals​

1161411616116171163011633117151172312157

Almost immediately after 2.0, contributor Florin9doi got to work chipping away at the list of peripherals we haven't implemented yet. Not long after, first-time contributor joestringer began working on train controller support. Thanks to them, in just about the first month of 2.0, we now have support for:

• Trance Vibrator
• Gametrak/RealPlay device
• Jogcon and NeGcon
• Train Mascon controllers (Type 2, Shinkansen, and Ryojōhen)
• Konami Microphone
• Zip 100
• PictureParadise

On top of that, PCSX2's EyeToy emulation now has audio support, and Buzz! devices now have a custom UI!

Will It Blend?​

1173711748

That is the question! PCSX2 team member and graphics expert LightningTerror has improved upon our existing per-pixel alpha blending (PABE) implementation, increasing both accuracy and speed. Software blending, run in shaders on the GPU, is highly accurate but incurs a performance hit as it forces us to tell shaders run for one triangle to wait for all previous triangles' shaders to complete before starting to prevent them from fighting with each other over the values of pixels that overlap between the triangles. Hardware blending is run in special hardware blending units on the GPU, which are built to avoid this fighting, but can only run a very simple set of operations. The supported operations don't cover everything the PS2's blending unit can do, resulting in worse accuracy as PCSX2 tries to select the closest (but often not identical) supported operation.

The new PABE implementation blends (heh) software and hardware, specially crafting values in the shader such that when sent to the hardware blend unit, they result in accurate emulation of the PS2's per-pixel alpha blending for supported PS2 blend configurations.

Symbol Parsing Overhaul​

1022411901

Courtesy of contributor Chaoticgd is a massively improved debugger. This overhaul, in the works for almost a year, allows the debugger to read MIPS debug (.mdebug), SNDLL (.sndata), and ELF (.symtab) symbol tables from a game's executable binary if it has them included. If the .mdebug section is available, the debugger can now display information about global variables, local variables, and parameter variables, including data types. This means you can explore data structures in memory as a structured tree. He subsequently added settings that give you fine-grained control over how and when PCSX2 performs symbol analysis passes. A few games that shipped with their debug symbols include Pac-Man World 2, Sega Soccer Slam, Fatal Frame, and hundreds more shipped with symbols in general. Below is a screenshot showing the tree of global variables and the list of functions in Pac-Man World 2.

Savestate Compression Options​

11848

Thanks to KamFretoZ, you can now configure both the compression method and the level of compression for savestates! These formats are Zstandard (default), Deflate64, and LZMA2, and there are four compression levels for each. You can also choose to leave your states uncompressed if your 40 TB NAS feels lonely. Higher compression will result in lower file sizes but may increase the time needed to save the states.

DEV9 Fixes​

1188511911119081192511931

After 2.0, longtime contributor AirGamer launched into an effort to fix our DEV9 emulation and try to get PS2 Linux and PlayStation Broadband Navigator (PSBBN) working on PCSX2. His work has brought us tantalizingly close: as best we can tell, our lack of full emulation for the PS2's translation lookaside buffer (TLB) is now the only barrier still preventing PS2 Linux and PSBBN from working. Whoever steps up and conquers the TLB will bring the penguin to PCSX2.

Various Smaller Improvements in 2.2​

Before we move on to 2.4 and the big changes it brought, we want to stop and spotlight the smaller work that goes into making PCSX2 a polished experience. Below are just a few among hundreds, and we're grateful for every single one.

• #11562 – Team lead fobes adds little endian support to the debugger.
• #11372 – macOS expert TellowKrinkle fixes VAAPI support on Linux.
• #11593 – Team lead fobes adds selectable pixel formats on a per-codec basis to the video capture tool.
• #11571 – Wiki maintainer TheTechnician27 adds a way to go directly to a game's wiki page from the PCSX2 application.
• #11602, #11808 – DB maintainer JordanTheToast and UI artist KamFretoZ add hardware info to our statistics overlay.
• #11730 – UI artist KamFretoZ adds a game icon in our Discord Rich Presence for supported games using RetroAchievements.
• #11787 – Memcard and gamepad expert RedPanda4552 fixes an issue with input profiles being blocked by old settings.
• #11839 – Graphics expert LightningTerror fixes a longstanding graphical issue in Knights of the Temple: Infernal Crusade.
• #11935 – First-time contributor rares-fodor adds a search bar to the cheats list.

PCSX2 2.4.0​

After 2.0, the 2.2 development cycle had let us catch our breath and – for the most part – focus on finer details. Brewing under the surface, though, were fresh ideas and the zeal to bring them to life. We all wanted to get back to innovating, so that's what we did. The 2.4 development cycle comes with many performance improvements and new features.

RT in RT Support​

11461

For his capstone contribution to PCSX2 after over 20 years of unimaginable dedication, former lead developer refraction turned to his unfinished work on RT in RT support. Feeling duty-bound not to leave this to rot after he left, he agonized for months to get this working, and the end result is something to behold. First, though, let's address what this even is.

"RT in RT" stands for "render target in render target". If a game wanted to render to a subset of an image (e.g. only the right half) on the PS2, it had two options. The first, which is the way PC games have to do it, is to draw with triangles whose coordinates are positioned over the subsection they want to draw over (in the example, making sure all the triangles are positioned over the right half of the image). The second is to take the memory address of the pixels in the image and adjust it so it starts at the right half (so the new RT pointed to memory that was inside the old RT, hence the feature name). Now, drawing to the top left corner of the render target actually writes to the top left corner of the right half of the image (and drawing to the right half of the render target would corrupt the image, so don't do that).

Games that chose this second option confused PCSX2 very badly, and it would end up drawing to a separate RT that it never properly merged with the outer RT, effectively deleting all the triangles drawn this way. No longer! With this change, PCSX2 now recognizes when this is happening, figures out what section the PS2 game was trying to draw to, and moves the triangles accordingly, converting option 2 draws into option 1 draws, which PC APIs know how to handle.

This brings massive fixes to a huge variety of games – at minimum, multiple games with two-player splitscreen (such as Jak X: Combat Racing), multiple games that no longer need a hack to work (such as Ghost in the Shell: Stand Alone Complex), multiple games whose effects now work (such as Drakengard; comparison below), and multiple games that would only work before in software rendering (such as Hitman: Contracts; comparison below).

Before

After

Before

After

Before

After

Custom Real-Time Clock​

12208

The PlayStation 2 uses a real-time clock (RTC) to keep track of the date and time in the real world. Games often use the RTC in order to seed pseudorandom number generation (RNG) because of its high variability. Additionally, save files show a timestamp in the BIOS, and these timestamps are sometimes shown in-game too. However, some games use the RTC in a more interactive way. Ratchet & Clank 2 and Ratchet & Clank 3, for example, let you teleport to the post-game Insomniac Museum area from 03:00–04:00, bypassing completion checks. The Simpsons: Hit & Run, The Simpsons: Road Rage, SpongeBob SquarePants: Battle for Bikini Bottom, and Scooby-Doo! Night of 100 Frights have holiday-exclusive Easter eggs. Need for Speed: Hot Pursuit 2 displays the date and time on a camera recording when you get busted. And Metal Gear Solid 3... if you know, you know.

By default, when a user starts a game, PCSX2 sets the RTC to the date and time from the user's desktop. For input recordings which require perfect determinacy to function correctly, we instead used a fixed, arbitrary date and time after the release of Metal Gear Solid 3 (which crashes if the date is too old). With the introduction of RTC settings by TheTechnician27, you can now optionally select a custom RTC starting point in the per-game settings (Game Properties > Emulation > Real-Time Clock). This provides niche benefits for regular users (especially Ratchet players and enjoyers of Hideo Kojima's antics), and it brings PCSX2 closer to having a mature suite of tool-assisted speedrun (TAS) capabilities.

This currently requires you to have your BIOS set to GMT+0 and daylight savings time (DST) set to Summer Time (this is the default PCSX2 creates if no .nvm file exists). Additionally, it will only work within the bounds of 2000-01-01 at 00:00 and 2099-12-31 at 23:59, which is the range of an actual PlayStation 2. Below is the Halloween-exclusive title screen from The Simpsons: Hit & Run.

HDR Optimization​

12254

The PS2 doesn't have HDR support, so why does PCSX2 use HDR textures? When two numbers are added that sum to a result that won't fit in the output, like adding 200 + 200 with an 8-bit result (which can represent the values 0-255), there are two main ways computers may deal with this. The first is overflow / wrapping, famous for looping counters back to zero after they cross 255 in many NES games. In this case, the number wraps back around to 0, so 200 + 200 would result in the value 144. The second is clamping, where numbers greater than the maximum representable value are clamped to it, so 200 + 200 would equal 255. When rendering graphics, most humans consider clamping to look more visually pleasing than wrapping, since having brighter than white turn into white looks better than it turning into black or gray. As a result, PC blend hardware clamps the results of math on all 8-bit textures. But the PS2 lets developers pick between clamping and wrapping, so how do we emulate wrapping?

Well if we don't want the result to clamp, why not just use an HDR texture, which can store values much larger than 255. We can draw all the triangles to this texture, letting the numbers accumulate more and more, then at the end, run a separate shader that wraps them all back to 8 bits. One minus of this approach is that there's still clamping, it just happens at a value much larger than 255, decided by the HDR format we use. For a while we used 32-bit float textures, which could accurately represent values up to 16 million, allowing a minimum of 65 thousand overlapping triangles before problems started appearing, but a while back we switched to 16-bit normalized integer textures, which many GPUs process at twice the speed, giving a minimum of 257 overlapping triangles before problems. This was enough for all the games we tested.

But performance still wasn't great, so former lead PCSX2 developer refraction (codename: "One Last Job") came back from retirement swinging with a major optimization. Previously, for every group of triangles the game rendered, PCSX2 would convert the texture to an HDR texture, render the group of triangles, and then perform the wrapping while converting the texture back to non-HDR. But some games would render multiple groups of triangles in a row, and for each group, PCSX2 would convert, wrap, and convert again. Now, PCSX2 converts to HDR once at the beginning, and leaves the results in the HDR texture until the game stops using the wrapping mode, greatly reducing the number of conversions needed in games like Sly 2: Band of Thieves and Big Mutha Truckers.

Direct3D 11 Comes Back with a Speedy Vengeance!​

128841290712905

The Direct3D 11 renderer might have been the second-class citizen for some time now, but not this time! Graphics expert LightningTerror has come back with a toolbox in an attempt to revitalize the elder. How did he do it? The first phase was to lay out the groundwork by fixing the Direct3D 11 Resource Hazard API warnings, which paves the way of enabling him to implement Resource Shader Caching that manages to give noticable performance boost in quite handful of games. And as if those optimizations weren't enough, the daredevil himself has backported even more optimizations from other renderers which gives quite a performance boost in many games.

Don't believe us? Here is the benchmarks:

Signed macOS Binaries​

12255

macOS requires all code binaries to be signed. If not, macOS' Gatekeeper will report that the program cannot be opened because it is from an unidentified developer, thus it "cannot verify that this app is free from malware". This was a headache for users, who needed to explicitly allow an unsigned programs to run. As such, PCSX2's lead developer, fobes, worked to get PCSX2 formally signed. This means that when you download and run PCSX2 on macOS, it will now open normally.

Wayland by Default​

12333

In the Linux world, the last remaining hurdles to PCSX2 running on Wayland by default are finally gone! Thanks to upstream fixes in Qt 6.9 and some clever work by team member GovanifY, the I_WANT_A_BROKEN_WAYLAND_UI flag is history! This does not mean that no Wayland-specific bugs exist, but it means we've failed to find any we consider showstoppers. If your desktop environment uses X11, nothing will change, and we'll continue accepting reports for X11-specific bugs for the foreseeable future. If you find a Wayland-specific bug, the QT_QPA_PLATFORM=xcb environment variable can take you back to XWayland while we work to fix it.

New Upscaling Fix​

12350126361264512705

Thanks again to former PCSX2 lead developer refraction, PCSX2 now has a brand-new tool in its arsenal to fix misalignment issues caused by upscaling. Based on the existing Align to Native (AtN) half-pixel offset (HPO) option, Align to Native with Texture Offset (AtNTO) often combines the best of AtN and another HPO option called Special (Texture) to make a lot of games much sharper when upscaled. Thanks to a massive effort by GameDB specialist JordanTheToast, PCSX2 now applies this new setting automatically to over 100 games. These include Ace Combat 04: Shattered Skies, the Sly Cooper trilogy, God of War and God of War II, and Shadow of the Colossus. Below is a before and after comparison of Ace Combat 04.

Before

After

Debugger Redesign​

12241

Thanks again to months of work by Chaoticgd, the debugger has received a huge redesign using KDDockWidgets, massively improving usability. Not only can you now create a custom layout for your debugger (saved as a JSON file), but you can actually create and switch between multiple such profiles on the fly. Thanks to a new event system allowing widgets to communicate, you can even open multiple widgets of the same type – for example, two memory viewers looking at different areas of memory. We can't wait for you to try it out!

SDL3 Upgrade​

12311

The right answer to "What does SDL do?" is "What doesn't it?", but PCSX2 uses it to handle gamepads and audio output. In January 2025, SDL's release of its newest major version, 3.0, threatened to lock us out from its great new features if somebody didn't step up and make our codebase compatible. GameDB specialist and dependency coordinator JordanTheToast – along with his emotional support TheTechnician27 – boldly took action. Days later, DEV9 expert and resident lifeguard AirGamer noticed both drowning in the deep end and decided to save them. Thanks to weeks of work by AirGamer, PCSX2 now uses SDL3. The SDL Wiki has a comprehensive list of new features, but for PCSX2, the immediate benefits are full support for DualShock 3 on Linux and a cleaner API for easier development and the ability to utilize new features as they come. Special thanks goes to the unsung heroes at the SDL Wiki who wrote this guide and especially the authors of this symbol rename script who made this transition feasible.

Various Smaller Improvements in 2.4​

• #12157 – Contributor Florin9doi adds support for the MemCard PRO2.
• #12494 – First-time contributor recursean adds a adds a nice improvement to the debugger which adds column titles to Disassembly view.
• #12593 – Contributor TheTechnician27 fixed an issue with global settings overriding per-game settings in terms of audio.
• #12545 – Contributor Mrlinkwii has updated the redump database used for verifying dumped disc integrity.
• #12568 – Contributor KamFretoZ added the ability to load backup savestate directly from the UI.
• #12448 – Contributor Ziemas made it so BIOS ROM can be read in the IOP debugger.
• #12069 – Fobes managed to fix the EE Cache to not crash when changing from interpreter to the recompiler.
• #12572 - Contributor TheLastRar has updated Big Picture Mode's UI icons to use SVG for better scaling at higher monitor resolution.
• #12302 – Thanks to TJnotJT for adding new GS dumping options to the Debug settings.