God of War’s AMD FSR 2.0 upscaling takes on Nvidia DLSS

AMD’s FidelityFX 2.0 super resolution is slowly gaining traction. Its initial release for Arkane’s Deathloop has since been joined by integration into Farming Simulator 2022 and, more interestingly, the PC port of Sony Santa Monica/Jetpack Interactive’s God of War – and 16 more titles have just been announced. God of War in particular deserves some attention, as some might argue that the game’s aesthetic is heavily based on intricate, very high-frequency detail – a proper workout for “smart” scaling techniques. Not only that, but it already includes impressive Nvidia DLSS support alongside Santa Monica Studio’s in-house time scaler.

This is one piece where I’m going to have to refer you to the embedded video to get the full picture of how FSR 2.0 compares to these alternatives. You see, all the upscalers I’ve looked at do pretty well when looking at static images. To get a sense of how these technologies actually work, it’s important to see them in motion. The secret to their success is that they are based on the concept of temporal accumulation – pixels from previous frames are injected into the current frame. Therefore, the less motion, the more of a supersampling effect you get. Conversely, the more variation there is between the images (e.g. fast motion), the less data there is to work with to reconstruct the image.

Digital Foundry’s Alex Battaglia has come up with a ten-point image/motion quality analysis that puts all reconstruction-based upscalers – including FSR 2.0 – to the test.

Most of the tests I ran were at 4K resolution, which is the perfect canvas for these techniques – individually shading 8.3 million pixels per frame is a challenge, but the “smart upscalers” do a great job of rendering at a much lower resolution and then basically calculate the difference. Technologies such as FSR 2.0 and DLSS 2.x – and potentially Intel’s upcoming XeSS – are notable for their scalability. It’s possible to get a nice picture from a native frame of just a quarter of the pixels: meaning a 4K-like 1080p internal picture.

As a general rule, the lower your output resolution (e.g. 1440p or 1080p), the higher your base native pixel count should be – and by extension, the less gain you get from your upscaler. This applies to DLSS for sure, but it seems to be amplified in FSR 2.0. 4K, ultra HD or 2160p is where these techniques work best.

So, how do you judge the image quality of these new techniques? After years of watching DLSS and other scalers, we’ve come up with a ten-point plan that you’ll see unfold in the video above. Essentially, we have ten test cases that challenge all of the time-scaling solutions that incrementally increase the difficulty that each algorithm faces. These techniques all work well with static imagery and also hold up quite well to camera shake.

However, once we start to consider things like particle effects, water rendering, animation, and sub-pixel detail scaling, that’s where you can really see how effective these techniques are. In the video, I also talk a lot about “deocclusion” – what I mean by this is the introduction into the image of visual data previously obscured by other objects. With no time information to work with, this is very difficult to solve – and with God of War’s Kratos, his every move can reveal previously obscured footage.

The first title supported by FSR 2.0 was Arkane’s Deathloop – see how it performs against native resolution rendering and DLSS in this video.

It takes about 20 minutes of video to go through all of these tests, but the takeaways are obvious. FSR 2.0 performs well overall, but further iteration is needed to match the overall fidelity of the DLSS feature set. The main challenge facing AMD is solving deocclusion issues – quickly revealing previously hidden frames causes a noticeable fizzing effect that DLSS does not suffer from. Transparent elements, especially water, also see detail smudging which isn’t quite right. Sub-pixel details of foliage and hair also struggle to achieve effective resolution.

Ultimately, FSR 2.0 – perhaps predictably – acts as it does in Deathloop, the first game to receive support for AMD’s new scaler. The difference is that the more detailed approach to the visuals amplifies its issues, which are further amplified when downscaling to lower output resolutions such as 1440p and especially 1080p, where the image looks particularly blurry in motion. Even so, I think FSR 2.0 offers a viable alternative to the in-game scaler, even in times when it delivers less appealing results, as it tends to resolve more detail.

Summarizing all of these tests, FSR 2.0 performs well for its purpose, but we should expect to see improved iterations of the technique, just as we did with DLSS. Even so, it’s still a promising start in that as a second-gen upscaler, rebuilding from a quarter of the output resolution, it does a very good job – certainly better than the Santa Monica time scaler. FSR 2.0 is much heavier on the GPU to the point where testing on an RX 6800 XT found that rendering FSR 2.0 internally at 1440p is about as fast as the Santa Monica Studio scaler running at a base resolution of 1620p. This might sound quite alarming, however, the end result is that at equalized performance levels the extra pixels make little difference – overall the FSR 2.0 is better with improved reconstruction and a more stable image. The only downside is that FSR 2.0 has more ghosting issues than the internal alternative.

FSR 2.0 versus DLSS? Similar to my findings with the debut of FSR 2.0 in Deathloop, if you’re using an RTX card, Nvidia’s technique is still the way to go: it runs a bit faster than FSR 2.0 and fixes a lot of issues that AMD still has to solve. , providing an image that is generally of a higher level of quality – and can even render native resolution for its money in some scenarios. However, for non-RTX cards (remember, there are still plenty of GTX GPUs out there) and for AMD cards, FSR 2.0 works well and can only get better.