DLSS Neural Player

An experimental Windows video player that presents decoded video through Direct3D 12, allowing an external ReShade, Feeder, and RenoDX stack to process the frames.

The player provides video playback and controls. Neural processing depends on separately supplied add-ons and NVIDIA runtime binaries; those components are not included in the source project.

Download a portable release

Download the Windows x64 ZIP from GitHub Releases, extract the entire archive, and open DLSS Neural Player.exe. Read START-HERE.txt in the package. Portable releases include the FFmpeg libraries, shaders, and neural-processing payload; the source checkout does not contain these binaries.

To package a local Release build with your payload:

powershell -ExecutionPolicy Bypass -File scripts/package-release.ps1 -Version 0.1.0

Output is written to dist/, with a SHA-256 checksum and an internal file manifest. The packager refuses to overwrite an existing output directory. A matching source archive is attached to the release, including Dear ImGui and the FFmpeg source/build-recipe archives.

Features

• H.264 and H.265/HEVC playback through FFmpeg, with D3D11VA hardware decoding when available.
• Audio decoding and resampling through FFmpeg, with XAudio2 output.
• Direct3D 12 rendering with aspect-ratio preservation.
• Floating playback controls, seek bar, volume, mute, and fullscreen mode.
• A cancellable preparation window while the neural processing stack initializes.
• File picker, command-line file opening, and drag-and-drop onto the executable.

The application interface currently contains Brazilian Portuguese text.

Requirements

• 64-bit Windows with Direct3D 12 support.
• A dedicated NVIDIA RTX GPU with at least 8 GB of VRAM and at least 16 GB of system RAM. The application checks these requirements at startup.
• Visual Studio 2022 with the Desktop development with C++ workload and a Windows SDK.
• CMake 3.20 or later.
• A compatible FFmpeg shared development package with headers, import libraries, and matching runtime DLLs.
• Dear ImGui sources in external/imgui (provided as a Git submodule).

Neural processing additionally requires a compatible driver and the external ReShade/RenoDX/Feeder payload. Compatibility depends on the versions of those components.

Build from source

Run the following commands in PowerShell from the project root. First, initialize the bundled source dependency:

git submodule update --init --recursive

1. Prepare FFmpeg

Extract a Windows x64 shared development package into this layout:

external/ffmpeg/
  include/libavcodec/avcodec.h
  include/libavformat/avformat.h
  lib/avcodec.lib
  lib/avformat.lib
  lib/avutil.lib
  lib/swscale.lib
  lib/swresample.lib
  bin/*.dll

Run powershell -ExecutionPolicy Bypass -File scripts/fetch-ffmpeg.ps1 to download the pinned Windows x64 GPL shared package and verify its upstream SHA-256 checksum. Manual extraction is also supported. Keep headers, libraries, and DLLs from the same package.

2. Compile

cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DUSE_FFMPEG=ON
cmake --build build --config Release

Check the configure output for successful FFmpeg detection. FFmpeg is required. Configuration now fails if it is disabled or if the runtime DLLs are missing; Media Foundation playback is not implemented.

3. Copy runtime files

CMake copies the HLSL shader and five FFmpeg runtime DLLs into the executable directory after building. The MSVC runtime is linked statically. To refresh runtime files manually:

New-Item -ItemType Directory -Path build/Release/shaders -Force | Out-Null
Copy-Item shaders/blit.hlsl build/Release/shaders/ -Force
Copy-Item external/ffmpeg/bin/*.dll build/Release/ -Force

4. Run

# Open the file picker
& ".\build\Release\DLSS Neural Player.exe"

# Open a specific video
& ".\build\Release\DLSS Neural Player.exe" "C:\Videos\sample.mp4"

You can also drag a video onto the executable. The picker lists MP4, M4V, MKV, MOV, AVI, and TS files; the video stream must use a supported codec.

Optional neural processing setup

The deployment script expects a local payload directory inside the project root (excluded from Git):

DLSS-Neural-Player/
  CMakeLists.txt
  scripts/
  payload/
    reshade-vulkan/ReShade64.dll
    renodx-dlss5.addon64
    feeder/
      dlss5-feed.addon64
      reshade-shaders/
        Shaders/
        Textures/
    streamline/
      sl.common.dll
      sl.dlss.dll
      sl.interposer.dll
      nvngx_dlss.dll
      nvngx_dlssnr.dll

The exact required files and deployment destinations are listed in scripts/payload-manifest.json. Keep only those files in payload/, including their license notices. The deployment script validates the entire manifest before copying and ignores any extra files. The payload is local and excluded from Git; it is not downloaded by this repository.

After compiling and copying the player shader, run from the project root:

powershell -ExecutionPolicy Bypass -File scripts/deploy-reshade.ps1 -TargetDir build/Release

This writes ReShade.ini and ReShadePreset.ini, replacing any existing versions in the target directory. The script checks required payload inputs before copying and stops on errors. Use -PayloadDir to supply a different payload location.

During playback, press Home to open ReShade. The generated preset enables these techniques in order:

1. vort_MotionEffects@vort_Motion.fx
2. DLSS5_Feed@DLSS5_Feed.fx

The deployment sets DLSS5_MV_PROVIDER=2 and NeuralUplift=1. Look for the neural rendering panel under ReShade's Add-ons tab.

Controls

Input	Action
Space	Play / pause
Left / Right	Seek backward / forward 5 seconds
Up / Down	Adjust volume by 10 percentage points
H	Seek to the beginning
End	Seek near the end
F or F11	Toggle fullscreen
C	Toggle control-panel pinning
Home	Open the ReShade overlay, when installed
Esc	Close the player / cancel preparation

Move the mouse to reveal the playback panel. Use its timeline to seek and its speaker button to mute or restore audio.

Limitations and troubleshooting

• Codec support: the current decoder explicitly accepts H.264 and HEVC. Installing FFmpeg does not enable every codec in this player.
• HDR: a complete HDR output and tone-mapping pipeline is not implemented. Do not assume accurate HDR reproduction.
• Neural startup: readiness is inferred from RenoDX/Feeder logs. Changes to their log formats may require updates to src/neural-startup.h. The startup timeout is checked between rendering calls and cannot interrupt a blocked driver call.
• Missing shader or DLLs: repeat the runtime-copy step and keep the executable, shaders directory, and matching FFmpeg DLLs together.
• Playback or add-on errors: inspect player.log, ReShade.log, and dlss5-feed.log in the executable directory. Add-on logs are available only when the corresponding components are installed.
• Image quality: successful add-on initialization or evaluation does not establish an improvement in visual quality. Results depend on the input and external processing stack.

Source layout

CMakeLists.txt             Build configuration
src/main.cpp              Decoding, audio, rendering, and window handling
src/player-controls.h     Playback controls
src/neural-startup.h      Neural readiness detection and preparation window
src/startup-view.h        Preparation-window drawing
shaders/blit.hlsl          Video presentation shader
scripts/                  Download, deployment, packaging, and payload manifest
external/imgui/            Dear ImGui sources

Build output, downloaded FFmpeg packages, runtime logs, and local deployment files are excluded by .gitignore. Keep final release ZIPs and checksums in dist/; build directories and extracted test packages can be regenerated. Preserve external/ffmpeg for rebuilding, including any corresponding source archives stored under external/ffmpeg/source-dependencies.

Project and third-party licensing

The player source is licensed under GPL-3.0-only; see LICENSE. Third-party components retain their own licenses. See THIRD-PARTY-NOTICES.md and the licenses folder in portable releases.