explaingit

rolaand-jayz/re-of-fsr-4.1.0-upscaling

Analysis updated 2026-05-18

3PythonAudience · researcherComplexity · 5/5Setup · hard

TLDR

A static reverse-engineering study of AMD's FSR 4.1.0 neural upscaler DLL, cataloging 602 shaders, extracting weight blobs, and mapping the 27-pass dispatch pipeline without running the binary.

Mindmap

mindmap
  root((repo))
    What it does
      Static binary analysis
      Shader catalog
      Weight blob extraction
    Key Findings
      602 shader blobs
      27 neural passes
      Dispatch structure
    Tools Used
      Ghidra disassembly
      DXIL analysis
      Python scripts
    Scope Limits
      No runtime capture
      Research only
      No replacement DLL
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Study the internal structure of AMD FSR 4.1.0's neural network pipeline for academic or interoperability research

USE CASE 2

Reproduce the shader catalog and weight blob extraction using the provided Python tools

USE CASE 3

Compare FSR 4.1.0's pipeline architecture against the open-source FSR 4.0.2 reference code

What is it built with?

PythonGhidraDXILDirectX 12x86-64 disassembly

How does it compare?

rolaand-jayz/re-of-fsr-4.1.0-upscaling0marildo/imagoagentlexi/agent-lexi
Stars333
LanguagePythonPythonPython
Setup difficultyhardeasymoderate
Complexity5/52/54/5
Audienceresearchergeneralvibe coder

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · hard Time to first run · 1day+

Requires Ghidra, DXIL tools, and familiarity with GPU shader pipelines and binary disassembly, no runtime testing environment is provided.

In plain English

AMD FidelityFX Super Resolution 4.1.0, known as FSR 4.1.0, is a technology built into modern graphics cards that uses a small neural network to reconstruct high-resolution images from lower-resolution inputs. AMD ships this technology as compiled Windows DLL files with no public documentation of how the internal pipeline works. This repository documents a static analysis of those files, meaning the author examined the raw binary code without ever running it, to understand the structure of the neural network inside. The analysis found and cataloged 602 shader programs (small GPU programs that process pixel data) embedded in the DLL, and identified 27 distinct passes the neural network runs through when upscaling an image. It also extracted 6 weight blobs, which are the actual learned values that make the neural network work, each 131,072 bytes in size. The format of those weight blobs was decoded, revealing 16-bit bias values, 8-bit weight values, and a small region of 32-bit output values. The tools used include Ghidra (a reverse-engineering tool released by the NSA), DXIL (the intermediate shader language for DirectX), and raw x86-64 disassembly. The repository is careful to mark which findings are confirmed from static analysis and which are only inferred. Things the project can prove include the shader catalog, the weight blob contents, and the basic dispatch loop structure. Things it cannot prove include the actual order the passes run in during a real game session, the exact values fed to each pass, and whether any reconstructed output would match AMD's original binary behavior. A dedicated validation document tracks the status of every claim. The audience is researchers who want to understand how FSR 4.1.0 works internally, developers studying GPU pipeline architecture, or anyone interested in neural-network-based image upscaling. The project is not a replacement for AMD's driver and is not meant to be run in games. The full README is longer than what was shown.

Copy-paste prompts

Prompt 1
Walk me through the key findings in this FSR 4.1.0 reverse-engineering study: what shaders were found, what the weight blobs contain, and what parts are still unconfirmed.
Prompt 2
How do I use the compare_sections.py script in this repository to verify the data DLL section reconstruction without modifying the rebuilt output?
Prompt 3
Explain the difference between STATIC-REPRODUCIBLE and STATIC-INFERRED findings in this analysis, and give examples of each from the findings table.
Prompt 4
What is the weight container format decoded in this FSR 4.1.0 study? Describe the byte offsets and data types for each section of the blob.

Frequently asked questions

What is re-of-fsr-4.1.0-upscaling?

A static reverse-engineering study of AMD's FSR 4.1.0 neural upscaler DLL, cataloging 602 shaders, extracting weight blobs, and mapping the 27-pass dispatch pipeline without running the binary.

What language is re-of-fsr-4.1.0-upscaling written in?

Mainly Python. The stack also includes Python, Ghidra, DXIL.

How hard is re-of-fsr-4.1.0-upscaling to set up?

Setup difficulty is rated hard, with roughly 1day+ to a first successful run.

Who is re-of-fsr-4.1.0-upscaling for?

Mainly researcher.

Open on GitHub → Explain another repo

This repo across BitVibe Labs

Scan in gitsafehub Deploy in gitdeployhub rolaand-jayz on gitmyhub

Verify against the repo before relying on details.