Meet the modder who hacked AMD’s new upscaling tech into Cyberpunk 2077

News PC
Spread the love

Earlier this week, news broke of a modder that hacked AMD’s FSR 2.0 temporal upscaling technology into Cyberpunk 2077, allowing users of non-RTX graphics cards the chance to play the game at higher frame-rates with substantially better visual quality than with FSR 1.0 upscaling. That’s massive for owners of AMD GPUs, and the mod even works beautifully on Steam Deck.

We contacted the mod’s creator, the gloriously named PotatoOfDoom1337, to find out exactly how it works – and whether it means that FSR 2.0 will soon be available in a tonne of existing games. Here’s the interview, edited lightly for clarity. Enjoy!

Alex Battaglia’s primer on FSR 2.0 shows off the feature in God of War, one of three released FSR 2.0 games.

What’s your background in programming and game modding? On NexusMods, it looks like you’ve only been creating mods since April last year?

PotatoOfDoom: I am studying computer science, have always been interested in the technical aspect of video games and was fascinated when I learned about projects like Reshade, Special K or DXVK. I see programming as my favorite hobby and additionally like reverse engineering and messing around with code a lot. I made my first Cyberpunk 2077 mod because CDPR fixed a very fun bug in the game. This annoyed me so much that I downloaded the development tools and re-implemented the bug myself. The process of creating this mod got me hooked, I learned more about the game over time and started creating more complex mods.

What motivated you to try to hack FSR 2.0 into Cyberpunk 2077?

PotatoOfDoom: Mainly my aging GTX 1080, a bit of envy towards RTX users because of their exclusive DLSS technology, and curiosity about how temporary upscaling solutions work in general. Also, FSR 2.0 and DLSS were described as being very similar, so I just wanted to see if it was possible.

How did you develop the mod?

PotatoOfDoom: I initially started the mod a few weeks ago in anticipation of the FSR 2.0 open source release. The first steps were to get the game talk to my custom .dll and tell the game that it supports DLSS and report the available DLSS resolutions to the game by implementing the required interfaces. Then I wrote a small shader that just displays a blank red image. My goal was to use this as a base to verify that the DirectX parts of my code were working correctly. Then I just waited for the open source release. After AMD released the source code, I immediately replaced my test code with FSR 2.0. I expected to work on it for several days, but was pleasantly surprised that it only took me a few hours to integrate. I used debuggers like x64dbg and reverse engineering software like IDA and Ghidra to find the specifics of the DLSS behavior in the game code. Also, for debugging the buffers, RenderDoc was incredibly helpful.

Please enable JavaScript to use our comparison tools.

Here’s how the mod looks in action in Cyberpunk 2077 and Dying Light 2, compared with DLSS, FSR 1.0 and native 4K.

Were there any surprises in terms of things being harder or easier to accomplish?

PotatoOfDoom: The main DLSS and FSR input buffers are the same. I basically just copied the FSR integration from the AMD example, set the FoV/Depth values, launched the game and immediately got a pretty decent image. The worst thing was a quirk in Cyberpunk where the game wouldn’t reset a special DirectX structure (ComputeRootSignature) after running DLSS. This is not so important for Nvidia’s DLSS since it uses CUDA, but unfortunately FSR uses ordinary DirectX compute shaders, which break the game. So I had to find a way to restore that structure after running FSR.

In terms of the FSR 2.0 CP2077 implementation, what is working well at the moment and what needs to be fixed?

PotatoOfDoom: Ghosting and animated textures are the biggest problems right now. Both DLSS and FSR use separate masks to give the algorithm hints about whether to reuse old temporal material or discard it, but they don’t seem to be compatible and I need to create a shader that translates the DLSS masks into FSR masks.

DLSS and FSR masks… are they similar to a Photoshop mask?

PotatoOfDoom: Yeah, basically like that. You can imagine them as a greyscale image with values ranging from 0.0 to 1.0 and the temporal upscaler reprojects old frames depending on those values. The FSR documentation goes into more in detail about that.

Here’s a visual example. I threw a fire grenade on the street, and as you can see there is nothing in the motion vectors or in the depth buffer. That is because neither the 2D fire texture, nor the spark particles have a 3D representation in the game. To ensure that the small sparks do not cause unsightly traces, they are masked in the InputBiasColorMask so that the reprojection algorithm ignores these pixels and does not reproject anything at that location.

Do FSR 2.0 and DLSS have similar requirements in terms of what inputs they require?

PotatoOfDoom: Yes, otherwise this mod would not be possible. Both integrations need color, motion vectors and a depth buffer as input. In addition, they use the masks I mentioned earlier. They are very important for things that don’t have motion vectors, like particles or animated textures like smoke and computer screens in the game and wrongly applied masks are the main reason for ghosting appearing in a game. Also, FSR needs to know the FOV and the near and far planes of the depth buffer. DLSS doesn’t need that additional information (I guess it figures that out via the integrated ML algorithm).

With what you know now, how easy would it be to develop a similar solution for other DLSS games?

PotatoOfDoom: Yes, I think so. I am still not finished with this one but if other games are similar this really shouldn’t take longer than a few days per game. I’ve already done some initial tests with Death Stranding and the first results look very good.

For example, could FSR 2.0 be added to Control, a game that famously runs extremely poorly on AMD GPUs, even with RT disabled?

PotatoOfDoom: Yes, I think so. Control got updated to DLSS 2.0 which means the DLSS interface the game communicates with is the same or is at least very similar to Cyberpunk. This is the most important part.

Given the massive public interest in the mod, what are your plans going forward? Would you be open to other devs joining the project to improve the results, or implement similar mods for other games?

PotatoOfDoom: I really didn’t expect this much interest in my mod, and if I had known that, I would have prepared a bit more when I hit the publish button last Thursday. I want to finish Cyberpunk first (if the real devs aren’t faster than me XD) and then move on to other DLSS games. And yes, of course I would love other developers to join me and help me get this project out of the proof-of-concept stage faster and into something people can use. I heard there is already someone who wants to port my mod to Red Dead Redemption 2.


The mod's official image is a Photoshop masterpiece - wow, so graphics.
Wow, so graphics. The mod’s official image is a masterpiece.

Will it be possible to create a drop-in DLSS replacement that works across a range of games (‘dlss2fsr’, as suggested by a Github user) or do you see it being more of a series of mods each tailored to a given game?

PotatoOfDoom: Only with a few compromises. It would be possible to create some kind of mod that gets the FoV and Depth values from a simple ini file. This mod could work for almost any DLSS game, but the image quality might not be as good as it could be. I mean even Nvidia optimizes DLSS for certain games. For example, the first versions of DLSS had terrible ghosting in Cyberpunk, while later updates to DLSS improved the situation. I can’t speak for other games, but for example Cyberpunk unintentionally sends the object ID buffer to DLSS (which is a buffer that assigns a single color value to each object in the scene). DLSS doesn’t need this buffer and can’t do anything with this information, but this allows me to improve anti-ghosting (especially when driving) tremendously. Also, the ComputeRootSignature bug I mentioned earlier is unique to Cyberpunk and makes this version of the FSR mod incompatible with any other game. Every single game has some unique quirks or even bugs that make it important to optimize each game to get the best experience. I obviously can’t do something like this for every single game, but I think if there is some kind of DLSS2FSR framework, it should be possible for other developers with some programming experience to easily integrate and optimize FSR for other DLSS games.

Anything else that you’d like to share about the process of making the mod, or that you’d like people to know about?

PotatoOfDoom: I think my answers above should cover everything about the mod for now. This mod is only a few days old and is already so well received. I’m sure we’ll see a ton of exciting developments in the upcoming weeks. Stay tuned for more.


To see this content please enable targeting cookies.

Exciting stuff indeed! Since this interview took place, another contributor by the ID of mnnx successfully adapted the mod for Dying Light 2, and I’d expect to see many more games supported over the next few weeks if everything goes well. Thanks to PotatoOfDoom for their time creating the mod and talking to us!

If you’re interested in trying the mod out for yourself, you can find it on NexusMods. Installation is pretty straightforward – replace a few files in your CP2077 directory, and make a registry change. You can also follow the mod’s development on PotatoOfDoom’s GitHub repository.