wouter/d4r
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrite README for native Windows RDNA4 installation and validation

Browse Source
This commit is contained in:
Codex committed 2026-10-02 10:36:10 +03:00
1 parent 541c9838f7
commit cf43794450
1 file changed
+113 -155
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+113 -155
View File
@@ -1,190 +1,148 @@
# d4r (dlss 4 radeon) # d4r для Windows / RDNA4
**This fork includes a native Windows 11 / RX 9070 XT (gfx1201) port.** Windows-форк [countervolts/d4r](https://github.com/countervolts/d4r) для запуска
Start with [Windows build and validation](docs/windows-rdna4-port.md) and DLSS Super Resolution на **AMD Radeon RX 9070 XT / gfx1201** через D3D12,
[OptiScaler installation](docs/windows-game.md). K/M have hardware validation; OptiScaler, ZLUDA и HIP. Целевые модели: **DLSS 4 preset K** и
K performance is still being improved. The Linux upstream description follows. **DLSS 4.5 preset M**. Runtime работает непосредственно в Windows 11.
d4r runs NVIDIA's official DLSS Super Resolution library (`nvngx_dlss.dll`) in Windows games on AMD Radeon GPUs under Linux and Proton. The game asks for DLSS as usual; the DLSS network runs on the AMD GPU through [ZLUDA](https://github.com/vosen/ZLUDA) (CUDA on ROCm/HIP), with the heaviest DLSS kernels replaced by hand-written RDNA3 and RDNA4 code. **Статус: development / prerelease.** K и M работают на тестовой RX 9070 XT,
включая 4K в Silent Hill 2. Текущий приоритет — производительность K.
**Supported DLSS models:** DLSS 3 CNN (E), DLSS 4 transformer (K, default), and DLSS 4.5 transformer (M, plus experimental L). DLSS 5 is PURPOSELY not supported. ## Скачать и запустить
Preset L is NVIDIA's DLSS 4.5 model for Ultra Performance, especially at 4K. Set `[DLSS] Model = L` in `d4r.ini` and select Ultra Performance in game or OptiScaler; selecting L alone does not change the input resolution. L shares M's native Swin layers and has its own texture-kernel build. Its unfolded input/output arithmetic remains translated, so performance and image quality need game testing; the M benchmarks below do not apply to L. [Готовые сборки](https://github.com/xdfnx-dev/d4r/releases) содержат Windows
shim, исправленный ZLUDA, изолированный HIP runtime, patched OptiScaler,
11 native K kernels, 5 native M kernels и исходники соответствующего commit.
**Proof of concept:** d4r shows that DLSS can run on an AMD GPU, but it is not really that practical for everyday use yet. It has been tested on one GPU in a handful of games and depends on unreleased patches to ZLUDA and vkd3d-proton. Понадобятся Windows 11 x64, RX 9070 XT и D3D12 игра без anti-cheat.
Проверенный AMD driver: `32.0.31041.1004`. Другие GPU и драйверы пока
не прошли такую же проверку.
**Windows / RDNA4 development:** `windows-rdna4` runs native K and M networks Предоставьте собственные локальные `_nvngx.dll` и `nvngx_dlss.dll`.
in a standalone Windows D3D12 harness on an RX 9070 XT (gfx1201). All K layers Проверенная пара: NGX `32.0.16.1714`, DLSS `310.9.1.0`. Native manifest
and all spatial blocks in forty temporal M launches pass NumPy/PTX validation. проверяет SHA256 DLSS DLL. NVIDIA binaries в сборку не включены.
The Windows shim imports D3D12 VRAM through HIP, executes DLSS at command-list
submission, and returns output in the same frame without CPU image copies.
RGBA16/32F, R11G11B10, RGBA/BGRA8, depth, exposure and motion formats have
independent D3D12 typed SRV/UAV conversion tests. Four-frame K/M runs with packed
output match the FP16 baseline exactly after resource-format quantisation.
The build incorporates upstream updates through `aa447b2`. Patched OptiScaler now
passes standalone K/M native-network tests with exact RGB agreement against
the direct-d4r baseline; see [the source patch](patches/optiscaler/README.md).
Silent Hill 2 now renders K through the native Windows backend; M also renders
a saved gameplay level with GPU output NaN/Inf checks. Startup depth/stencil
and swap-chain lifetime issues found in the game have regression checks.
Both K and M now pass 3840x2160 game output scans. K reaches a user-reported
62 FPS / 63% GPU with optional async interop, compared with the earlier
49-51 FPS / 53% synchronous run. The fixed async build completes 16941 finite
4K frames including feature recreation; queued-frame/recreation outputs match
synchronous controls exactly. These user readings are not a controlled FSR4
benchmark; the K performance gate remains open. Windows preset L is not yet
validated. Native M FP8 is separately replay/network validated; the
default keeps the FP16-equivalent baseline based on measured performance.
All sixteen CTest gates pass with the final native Windows ZLUDA runtime. See
[the reversible game package](docs/windows-game.md) and
[build instructions and hardware results](docs/windows-rdna4-port.md).
See [supported games](SUPPORTED_GAMES.md) for the tested games and DLSS models. Распакуйте ZIP и выполните команду из его каталога, подставив свои пути:
> **Not affiliated with NVIDIA or AMD.** ```powershell
.\windows-game.ps1 -GameExe "D:\Games\SILENT HILL 2\SHProto\Binaries\Win64\SHProto-Win64-Shipping.exe" -NgxCore "C:\Users\Administrator\d4r\_nvngx.dll" -DlssDll "C:\Users\Administrator\d4r\nvngx_dlss.dll" -Preset 11 -AsyncInterop
## Results
[DLSS Ultra Performance demo video](https://cdn.ayois.gay/dlss).
Radeon RX 7700 XT (RDNA3, gfx1101), SILENT HILL Townfall at 2560×1440, every DLSS result is presented in the frame it belongs to (no added latency).
| Mode | DLSS 3 CNN (preset E) | DLSS 4 (preset K) | DLSS 4.5 (preset M) | FSR 4\* |
|---|---|---|---|---|
| Quality (1705×960) | **71.7** fps | 67.9 | 49.3 | 76.0 |
| Balanced (1488×837) | **80.8** | 75.9 | 58.0 | 84.5 |
| Performance (1280×720) | **89.7** | 84.1 | 69.0 | 94.0 |
| Ultra Performance (853×480) | 89.1 | **95.5** | 92.2 | 107.3 |
\* FSR 4 was measured in an earlier session (2026-09-27); the DLSS columns on 2026-09-29, when the same machine ran about 2–4% slower overall. Run back to back on the same day, this release is faster than 0.1.1 at Quality with every model (E 71.2 → 71.9, K 67.9 → 68.1, M 48.4 → 49.3 fps), and more in games whose DLSS settings differ from Townfall's, whose kernel variants now run natively too.
For reference, native 2560×1440 without upscaling (the game's TSR at 100%) runs at 49.1 fps on the same walk.
On the same GPU DLSS starts at a disadvantage: its networks were designed for NVIDIA's tensor cores, and parts of them still run as translated NVIDIA code. How the numbers were measured, and what each optimisation contributed, is in [docs/performance.md](docs/performance.md).
## Known issues
- In some games using some models native upscaling can show visible artifacting.
For users who prioritize fidelity over speed, set `[Kernels] PreferAccuracy = true` in `d4r/d4r.ini` and restart the game. It defaults to `false`. This selects accuracy variants of every native kernel and restores conservative translation settings. It aims to match NVIDIA's arithmetic; 1:1 image quality against RTX DLSS is not yet proven. See [native kernel numerics](docs/native-kernels.md#numerics).
## GPU support (Linux upstream)
d4r builds for RDNA3 and RDNA4. A newly built release compiles native DLSS 4 and 4.5 network kernels for the targets below and selects the matching set at runtime. Only the RX 7700 XT has been tested by this project on a real GPU; an external video reports DLSS 4.5 running through d4r 0.1.2 on an RX 7900 XTX. RDNA4 runtime and performance remain unverified on hardware.
| GPU | Chip | FP8 math | Runtime testing |
|---|---|---|---|
| RX 7700 XT, RX 7800 XT, RX 7700, Radeon PRO W7700 | gfx1101 | widened to f16 | RX 7700 XT only |
| RX 7900 GRE / XT / XTX, Radeon PRO W7800 / W7900 | gfx1100 | widened to f16 | RX 7900 XTX: [external video](https://www.youtube.com/watch?v=_GLjJ2Dn5pU) (DLSS 4.5); other cards untested |
| RX 7600 / 7600 XT, RX 7650 GRE | gfx1102 | widened to f16 | untested |
| RDNA3 integrated GPUs | gfx1103 | widened to f16 | untested |
| RX 9070 XT / 9070 / 9070 GRE, Radeon AI PRO R9700 | gfx1201 | native FP8 (`NativeFp8`, default on) | RX 9070 XT: [external video](https://www.youtube.com/watch?v=lZ0BLYqAtCs), other cards untested |
| RX 9060 XT / 9060 | gfx1200 | native FP8 (`NativeFp8`, default on) | compile only |
| RDNA2 and older | | | unsupported |
Native network kernels are built for all listed gfx11/gfx12 targets. Texture kernels are compiled for each target by `d4r_emit` when supplied to the package script; RDNA4 also has a `-fp8` variant. The bridge selects the KFD GPU with the most SIMDs, avoiding an integrated GPU when a discrete GPU is present; `D4R_GPU_ARCH` overrides that choice. Missing native kernels fall back to ZLUDA and can be much slower. Earlier translated K layers produced invalid values; preserving FP16 denormal handling fixes that failure in recorded captures, but RTX image-quality parity remains unverified. Preset E does not use the native network kernels.
## How it works
```
game (D3D12) ──► OptiScaler (DLSS inputs) ──► d4r_nvngx.dll (NGX D3D12 API, tools/d4r_nvngx_shim.cpp)
│ inputs/output stay in VRAM (vkd3d-proton Vulkan interop,
│ command list split around DLSS for same-frame results)
▼
official NGX core + nvngx_dlss.dll (their CUDA path)
▼
nvcuda.dll (Wine CUDA bridge, tools/wine_nvcuda_bridge.c)
▼
ZLUDA (patches/zluda: PTX → AMDGPU, WMMA, native kernel overrides)
▼
native RDNA3 and RDNA4 kernels (kernels/: DLSS 4 and 4.5 network layers)
``` ```
- **The shim** (`d4r_nvngx.dll`) implements the D3D12 NGX entry points OptiScaler calls, copies the game's colour, depth and motion vectors into buffers shared with HIP, evaluates DLSS through the CUDA version of NGX, and writes the result back into the game's output texture. В игре выберите upscaler, который перехватывает OptiScaler. `-Preset 11`
- **The bridge** is a Wine builtin `nvcuda.dll` that forwards the CUDA driver API to ZLUDA on the Linux side, plus a few helpers the shim needs (Vulkan memory import, asynchronous array copies, GPU-side waits). выбирает K, `-Preset 13` — M. Начинайте проверку M без `-AsyncInterop`:
- **ZLUDA** compiles NVIDIA's PTX for the AMD GPU. The patches add what DLSS needs (textures, surfaces, FP8 and tensor-core MMA on RDNA3/RDNA4 WMMA) and a hook that serves hand-written kernels in place of selected PTX kernels. асинхронный путь сейчас проверяется прежде всего на K. Первый запуск может
- **Native kernels** reimplement the DLSS 4 and 4.5 network layers for RDNA3 and RDNA4 and replace parts of a few texture-heavy kernels. The 2–3× speedup was measured on the RX 7700 XT; RDNA4 speed is unverified. занять время на PTX compilation; следующие используют cache.
Details: [docs/architecture.md](docs/architecture.md) and [docs/native-kernels.md](docs/native-kernels.md). Скрипт устанавливает `dxgi.dll`, конфигурацию OptiScaler и каталог `d4r`
рядом с EXE, предварительно сохраняя заменяемые файлы. Вход и выход текущего
кадра остаются в VRAM. Восстановление исходных файлов:
## Install the release ```powershell
.\windows-game.ps1 -Action restore -GameExe "D:\Games\SILENT HILL 2\SHProto\Binaries\Win64\SHProto-Win64-Shipping.exe"
```
The release zip works like an OptiScaler release: its contents go into the folder that holds the game's main `.exe`. Подробные параметры установки и восстановления:
[docs/windows-game.md](docs/windows-game.md).
1. Extract `d4r-<version>.zip` there. It contains: ## Что проверено
- OptiScaler 0.9.4 as `dxgi.dll`, with an `OptiScaler.ini` set up for d4r;
- the d4r-patched vkd3d-proton (`d3d12.dll`, `d3d12core.dll`);
- an `d4r` folder with the shim, the CUDA bridge, ZLUDA, the ROCm 7.2.4 runtime, the native kernels, this game's `d4r.ini`, and NVIDIA's `nvngx_dlss.dll` (310.7) and `_nvngx.dll`.
2. In Steam, select GE-Proton 11 for the game and set these launch options: `PROTON_FORCE_NVAPI=1 DXVK_NVAPI_GPU_ARCH=AD100 %command%`.
When updating, replace `d3d12.dll` and `d3d12core.dll` together with `d4r/nvngx.dll`. The shim requires their matching resource-lifetime extension. | Проверка | Результат на RX 9070 XT |
| --- | --- |
| Обнаружение GPU | HIP автоматически определяет `gfx1201`; проверяется D3D12/HIP LUID |
| HIP и CUDA через ZLUDA | Native HIP kernel и CUDA Driver API / PTX tests проходят |
| D3D12 ↔ HIP | Shared VRAM buffers и fences; import/release lifetime test проходит |
| K transformer | Все 11 native layers, NumPy/PTX/replay validation |
| M transformer | Все 5 native layers, 40 temporal captures, exact baseline |
| Async K | Очередь кадров и Release/CreateFeature точно совпадают с synchronous RGB |
| Silent Hill 2 / K / 4K | 16 941 кадр с проверкой NaN/Inf, 203 292 native launches, 0 backend errors |
| Windows hardware tests | Все 16 CTest gates проходят |
ROCm does not need to be installed: the zip includes its runtime (from AMD's Ubuntu 22.04 packages, which run under Steam's container runtime on any distribution). The zip's NVIDIA files and the kernels built from NVIDIA's code are not covered by this repository's license (see [NOTICE](NOTICE)). The Proton prefix and the system are not changed. [packaging/D4R_README.txt](packaging/D4R_README.txt) is the full guide that ships in the zip; `scripts/package_release.sh` builds the zip (see [docs/building.md](docs/building.md#7-package-a-release)). Точные совпадения относятся к проверенным reference/control implementations
этого проекта. Сравнение с DLSS на физической RTX ещё не выполнено.
Проверка одной игры не подтверждает совместимость со всеми D3D12 играми.
## Requirements (building from source) ## Производительность и ограничения
- Linux with an AMD RDNA3 or RDNA4 GPU. The native kernels use gfx11 or gfx12 WMMA. `scripts/package_release.sh` builds network kernels for gfx1100–gfx1103 and gfx1200–gfx1201 by default; `D4R_GPU_ARCH` selects one target for a standalone `kernels/build.sh` invocation. Runtime support outside the RX 7700 XT remains unverified on hardware (see [GPU support](#gpu-support)). В локальной 4K сцене пользователь наблюдает около **62 FPS / 63% GPU** с
- ROCm with HIP and its clang (tested with ROCm 7.2). async interop, против **49–51 FPS / 53%** в предыдущем synchronous варианте.
- GE-Proton with OptiScaler integration (tested with GE-Proton11-3). Замеры также используют локально построенные и проверенные K output-store
- Build tools: a Rust toolchain and git-lfs (ZLUDA), meson and ninja (vkd3d-proton), `winegcc`/`winebuild` (bridge), `x86_64-w64-mingw32-g++` and `clang-cl` (shim), Python 3. kernels. Они содержат NVIDIA-derived code и в публичный ZIP не входят;
- NVIDIA's `nvngx_dlss.dll` 310.7 and a matching NGX core `_nvngx.dll`. команды их локальной сборки есть в
[docs/windows-performance.md](docs/windows-performance.md).
## Build and run Производительность K ещё дорабатывается. Замеры не являются контролируемым
сравнением с FSR4. `-AsyncInterop` опционален и требует одной D3D12 command
queue. Feature release и resource reconfiguration ожидают завершения GPU
consumers; обычная отправка кадра не удерживает CUDA mutex.
The full sequence is in [docs/building.md](docs/building.md). In short: M использует проверенную FP16-equivalent baseline. Native RDNA4 FP8 отдельно
валидирован, но не показал выигрыша для полной сети и выключен по умолчанию.
Windows preset L пока не валидирован. Frame Generation и DLSS 5 не входят
в текущую задачу.
1. Build ZLUDA `ee2f25a` with `patches/zluda/0002`–`0007` applied, including its `d4r_emit` example for offline texture builds. Package использует TheRock `10.2.0a20260929` / HIP `7.17.26386`. Stable HIP
2. Build the patched vkd3d-proton: `scripts/build_vkd3d_proton_d4r.sh OUT_DIR`. 7.2 воспроизводит leak при освобождении mapped external memory; поэтому
3. Build the shim and bridge: `scripts/build_d4r_nvngx_shim.sh`, `scripts/build_wine_nvcuda_bridge.sh`. закреплён отдельный TheRock runtime. GPU architecture не подменяется.
4. Stage the runtime with your NVIDIA files: `scripts/install_d4r_runtime.sh _nvngx.dll nvngx_dlss.dll`.
5. Build the native kernels: `D4R_ROCM_DIR=… D4R_DLSS_DLL=… D4R_ZLUDA_EMIT=… kernels/build.sh`.
6. Fill in `~/.config/d4r/d4r.ini` (created from `config/d4r.ini.default` on first launch) and start the game with `scripts/d4r_play.sh`.
The launcher backs up and restores everything it touches in the Proton prefix: OptiScaler.ini, the prefix's `d3d12.dll`/`d3d12core.dll`, and the game's Engine.ini when cvars are set. ## Сборка из исходников
## Preset videos ```powershell
git clone https://github.com/xdfnx-dev/d4r.git
cd d4r
```
Gameplay recordings of each DLSS model at the Quality, Performance and Ultra Performance presets. Подготовка закреплённых toolchains и patches описана в
[docs/windows-rdna4-port.md](docs/windows-rdna4-port.md). Нужны CMake + Ninja,
LLVM/MinGW, Rust GNU toolchain, TheRock HIP, а для OptiScaler — MSVC v143
и Windows SDK. Setup-скрипты используют `.tools`; source dependencies — `external`.
**Ready or Not** После подготовки зависимостей выполните из корня репозитория:
| Model | Quality | Performance | ```powershell
|---|---|---| .\scripts\windows\build-zluda-windows.ps1
| DLSS 4.5 | [video](https://cdn.ayois.gay/sk-ant-api03-OPG1vqqsmDkNduG5fXJBelDI-1APyL9_ytJrnOSekZxoh-2NL8NqNuqL3pCI24kJQsudaB896GYpu5TFv93tabAgK1H2sAA) | [video](https://cdn.ayois.gay/sk-ant-api03-d-4XS1it5mtMkm-QRz0Qnkfu9FAjz_dFJURvsh_3gPZTnC1sljpWc28F6fyjUWIC6xlZm-FckWGjaP-KuIipYmroa3dQ8AA) | .\scripts\windows\build-windows-rdna4.ps1 -RuntimeProfile therock -ZludaRoot "$PWD\dist\zluda-windows-final" -InstallDirectory "$PWD\dist\windows-rdna4-command-list"
| DLSS 4 | [video](https://cdn.ayois.gay/sk-ant-api03-uXTWm4hN5jZksiSm4fvgIOr0dw43hGJ0TpZLe2ZghIbGb7aR9CGGlTV-1paBYO7G6lzIf83tOrCdaKdJerJ4re6epRWDEAA) | [video](https://cdn.ayois.gay/sk-ant-api03-fcZCkctdFOv513z1u6rPBrRseY47Qnw43Gnv5mZf_GekHw-yUoWYcBixjp2qqqbBIf7sVmht0Y676U96n2cwmFIsRgWkHAA) | .\scripts\windows\stage-native-k.ps1 -DlssDll "$PWD\nvngx_dlss.dll" -PackageRoot "$PWD\dist\windows-rdna4-command-list"
| DLSS 3 | [video](https://cdn.ayois.gay/sk-ant-api03-_vuywLcsMzZiJxcNgucBeeXFzWi44mes5A1777bg_4XQ2X0MH22J9M7JFpTS0_q6yaGWMXf3FvL8MDiv_dc7UANxrCmlGAA) | [video](https://cdn.ayois.gay/sk-ant-api03-WzaIy34WIesQeOOTVQNXZwpPPE8khmbUynvMw9B-Luj8GFcZ_sJvGXfg6aW00TD0Rr3nWu43ELJGx2K6qs_HL6FkLdmb1AA) | .\scripts\windows\stage-native-m.ps1 -DlssDll "$PWD\nvngx_dlss.dll" -PackageRoot "$PWD\dist\windows-rdna4-command-list"
.\scripts\windows\build-optiscaler-windows.ps1
.\scripts\windows\package-windows-game.ps1 -ArchivePath "$PWD\dist\windows-rdna4-game.zip"
```
**Townfall** Создание distributable ZIP требует committed source. Package включает manifest
с hashes, dependency licenses, source patches и snapshot этого commit.
| Model | Quality | Ultra Performance | ## Тесты и диагностика
|---|---|---|
| DLSS 4.5 | [video](https://cdn.ayois.gay/sk-ant-api03-p8uL0hOUklvA-BSeEafS8LQU-gayzbqAE3NacWAmckLoXOSf2sXGf7OeG1LmvOqeGFRh_ceCWi4pLBl9yxJlvYwQWH3Y1AA) | [video](https://cdn.ayois.gay/sk-ant-api03-Mz0BzYTrLjaYSuQXtOEHTw4ydYVbPvHmMjflm8UhFp976ftXqMExD8BCMYlo93JLEGwVL3rMWoZR0CH_deJJU7jX8_s3GAA) |
| DLSS 4 | [video](https://cdn.ayois.gay/sk-ant-api03-WgNoUPTwH0vt55Ag7RaWprXXINU5OOOEtuDXOvIjHgfAScSiIPIJGVaERoF-EA3JO7LS8xkohUlb6AFsW8AVZ2vMB14JwAA) | [video](https://cdn.ayois.gay/sk-ant-api03-skXZVD6G4DUdAfQw0RLz_UJW8GOfBlpZx1N4ezaF_UIXm7OIY1ciQysfRu4zRsxSXA8plZJi4NSzkXkV7Oxmg9ytg9zaaAA) |
## Repository layout После сборки hardware gates:
| Path | Contents | ```powershell
|---|---| & .\.tools\python\cmake\data\bin\ctest.exe --test-dir build/windows-rdna4-therock --output-on-failure
| `tools/` | the NGX shim, the Wine CUDA bridge, a D3D12 DLSS harness, probes and kernel replay tools | ```
| `kernels/` | native RDNA3/RDNA4 kernels (`k/` DLSS 4, `m/` DLSS 4.5, `tex/` texture-kernel parts, `common/` WMMA layouts), their build script, validation tools and numpy reference models |
| `patches/` | ZLUDA and vkd3d-proton patches |
| `scripts/` | build, install, launch and probe scripts |
| `config/` | the default `d4r.ini` for the developer launcher |
| `packaging/` | the release's `d4r.ini`, OptiScaler settings, user guide and install check |
| `docs/` | architecture, build, native kernel and performance notes |
## Star History Async K regression с локальными NVIDIA DLL в корне репозитория:
<a href="https://www.star-history.com/?type=date&repos=countervolts%2Fd4r"> ```powershell
<picture> .\scripts\windows\test-async-k.ps1 -ZludaRoot "$PWD\dist\zluda-windows-final"
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=countervolts/d4r&type=date&theme=dark&legend=top-left" /> ```
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=countervolts/d4r&type=date&legend=top-left" />
<img alt="Star History Chart" src="https://api.star-history.com/chart?repos=countervolts/d4r&type=date&legend=top-left" />
</picture>
</a>
## License Успех: `PASS`, exact RGB, finite output и `passed: true` в `validation.json`.
Для ограниченного game test добавьте `-RunSeconds 120 -ValidateOutput` к
команде запуска. Скрипт сохраняет один ZIP с stdout/stderr, runtime/driver
information, native/translated kernel records и OptiScaler logs. Для crash
диагностики используйте `-CaptureExceptions`.
Apache License 2.0 (see [LICENSE](LICENSE)). The patches in `patches/` are offered under the licenses of the projects they modify: ZLUDA (Apache-2.0 or MIT) and vkd3d-proton (LGPL-2.1). See [NOTICE](NOTICE). `-ProfileStages` измеряет host stages, `-ProfileCudaApi` — существующие CUDA
API waits, `-ProfileGpuBoundary` вместе с `-AsyncInterop` — D3D12 GPU intervals
вокруг interop. `-ProfileKernels` синхронизирует HIP events и меняет scheduling.
При замере обычного FPS оставляйте profiling и output scans выключенными.
To contact me my discord is `._ayo`. ## Документация и лицензии
- [Архитектура, зависимости, milestones и результаты](docs/windows-rdna4-port.md).
- [Game install / restore](docs/windows-game.md).
- [Измерения K/M и FP8](docs/windows-performance.md).
- [OptiScaler source patches](patches/optiscaler/README.md).
- [ZLUDA source patches](patches/zluda).
Проект основан на работе countervolts; Linux upstream code и документация
сохранены для совместимости. Форк не связан с NVIDIA или AMD. Лицензия d4r:
[LICENSE](LICENSE); лицензии зависимостей включены в package.