github mavismmg/MFGAdaUnlock-RenoDx 1.10.0
MFG Unlock 1.10.0 - XeMFG DLSS-G (was XMX) in more games and in Vulkan, frame generation for DLSS-SR-only games, six panel languages

2 hours ago

Naming. The method called XMX until 1.9.0 is now XeMFG DLSS-G: Intel's XeFG multi-frame model generates the frames, and NVIDIA's DLSS-G presents and paces them (Reflex, flip metering). XMX is the name of Intel's matrix hardware, not of a frame generator. The panel's methods are now DLSS-G, XeMFG (XeFG with its own presentation) and XeMFG DLSS-G. The INI keys keep their names ([DLSSG] XmxGenerator, XmxVulkan, ...), so existing settings still apply.

Diagnostics for RTX 20/30 (block 1)

The first real RTX 3060 Ti reports after 1.9.0 showed two failures the panel could not explain: The Outer Worlds 2 and Keeper accepted the frame generation request and generated nothing, and Ratchet & Clank: Rift Apart started Streamline before the addon could hook it. This release adds what a report needs to say why:

  • Streamline log. [DLSSG] StreamlineLog=1 (also under Support → All settings) makes the addon set SL_LOG_LEVEL, SL_LOG_PATH and SL_LOG_NAME for the game before it starts Streamline, so Streamline writes its own sl.log beside the game; Save support files copies it. The Support page names the registry route for games that start Streamline before the addon.
  • NGX capability answers. The values NVIDIA's plugin reads about frame generation (FrameGeneration.Available, NeedsUpdatedDriver, the minimum driver version, DLSSG.MultiFrameCountMax) are logged once each and listed in the support report. Nothing is changed.
  • NGX feature line in the Frame generation chain card (RTX 20/30): created, could not be created, or not created after the game turned frame generation on. A warning in the log says the same 5 s after the request, with the next step.
  • System line and System check. The log starts with GPU, driver, Windows and HAGS; the General page has a System check section (GPU, driver, Windows, HAGS, NGX core, early loading, addon files) and a problem card when hardware-accelerated GPU scheduling is off, which DLSS Frame Generation requires.
  • Streamline start says "started before the addon could hook it" when the DLSS-G plugin was mapped by an slInit the addon never saw.
  • The CreateFeature hook now goes in when the game turns DLSS-G on, not only after the first Present, so a game that enables frame generation before presenting (Ghost of Tsushima) is observed too; the RTX 20/30 preparation relies on that observation not to rewrite a provider in use.
  • A removed graphics device is logged with its reason, and XeMFG DLSS-G stops evaluating on it.
  • The VRAM sampler keeps one DXGI adapter per device instead of creating a factory every second while the panel is open, which filled field logs with Redirecting CreateDXGIFactory1 lines; the swap chain's colour space is read four times a second instead of every Present.

RTX 20/30: admission when Streamline starts before the addon (block 2)

NVIDIA's runtime asks NVAPI for the GPU's architecture and refuses frame generation below Ada. Since 1.8.5 the addon answered "Ada" only on the thread running slInit (and inside its own re-query of slIsFeatureSupported). In Ratchet & Clank: Rift Apart Streamline was already starting when ReShade loaded the addon, so the plugin decided outside that window, kept no adapter, and the game offered a Frame Generation option that did nothing.

  • The answer now also goes to NVIDIA's runtime modules wherever they ask from: Streamline's own DLLs, the NGX core, and the frame generation files, including the NVIDIA app's renamed copies of both (...\NGX\models\sl_dlss_g_0\...\190_E658700.dll and ...\models\dlssg\...\160_E658700.bin). The game's own queries keep the real answer. The NVAPI hook goes in as soon as Streamline or nvapi64.dll appears.
  • slIsFeatureSupported no longer turns a lasting refusal into OK: when the plugin decided against the GPU, the game gets the real answer and the log says why.
  • How this was tested without an RTX 30: [DLSSG] SimulatePreAda=2 (test only) makes NVAPI answer Ampere on an Ada GPU. NVIDIA's Streamline Sample 2.14.16 then refuses DLSS-G exactly as the RTX 3060 Ti reports did (Disabling DLSS-G since it is not supported on current hardware, adapter mask 0x0), in the same load order as Rift Apart. With the admission, the plugin keeps the adapter (mask 0x1) and reports multi-frame support up to 6x. The first version of the new rule still failed there: the trace showed the refusal came from the NVIDIA app's renamed copies, which is why the rule matches paths, not only sl.*.dll. This run is now part of the automated suite.
  • Not proven yet: The Outer Worlds 2 and Keeper may fail for another reason; sl.log from the first test build will say.

RTX 20/30 and crash reports: from dashdogy's MFG Unlocker

Four items follow findings in dashdogy/MFG-Unlocker (MIT) v1.7.1; the code is ours unless stated.

  • NGX's frame generation check failing while Streamline starts. When the game starts Streamline, NGX is asked whether frame generation is supported. It can fail before looking at the GPU: no DLSS-G file mapped yet (FeatureNotFound), or the driver refusing the game's project ID (InvalidParameter, which dashdogy traced to driver 617.42's GUID rule). The Streamline Sample showed that sl.dlss_g then turns DLSS-G off even though the addon answers "Ada" to its architecture question. The addon now answers "supported, minimum Turing" in that case, only on RTX 20/30, only while Streamline starts, and only if a DLSS-G file exists (the game's nvngx_dlssg.dll or the NVIDIA app's copy). [DLSSG] PreAdaRequirementsAnswer=0 turns it off. The support report's chain_ngx_requirements line names the failure and the game's project ID, and says whether that ID passes the driver's rule. Tested with [DLSSG] SimulateRequirementsFailure (test only) on the Streamline Sample, with both failure codes: with the answer off the plugin keeps no adapter (mask 0x0); with it on, it keeps the adapter (mask 0x1) with multi-frame support.
  • The provider's own minimum. The addon already lowered the NVSDK_NGX_GetGPUArchitecture export. It now also lowers the minimum architecture each DLSS-G file records for NGX in its D3D11, D3D12 and Vulkan requirements functions: {feature 0x0B, minimum 0x190}, found in the game's copy and two NVIDIA app versions. The match uses two exact instructions and must be unique, or the file is left as it is. The Sample run shows all three records lowered in both files.
  • Stop Streamline retrying a refused feature. After NVIDIA's runtime refuses to create frame generation 3 times in a row on RTX 20/30, the addon sends Off instead of the game's mode for the rest of the session. dashdogy saw video memory grow until Doom: The Dark Ages crashed while Streamline retried every frame. The chain card says it happened. Not tested end to end: the Sample does not turn frame generation on in this mode.
  • DLSS-G older than 310.7 at 2x. These files have no generated-frame check to unlock (dashdogy found it in AION 2 with 310.6). When every DLSS-G file in the game is older than 310.7, the chain card's gate line now says so and names the fix: the NVIDIA app's DLSS override or a newer file.
  • Crash record ([Diagnostics] CrashDump=1, off by default, also in the panel). When the game is about to close from a crash, the addon writes MFGAdaUnlock-crash.txt (exception, module and offset) and a small dump beside the game; Save support files copies both. It runs only after the game's own crash handling and then hands the crash to the game's previous handler. It is meant for crashes that end with nothing in the log, such as Dying Light 2 at start. An automated test crashes a child process and checks both files.
  • Streamline log modes. [DLSSG] StreamlineLog is now a mode, after JavieEm's streamlineLogMode: NVIDIA's setting (0, the default), verbose (1, as before), standard (2), or off for this game (3).
  • Investigated, not changed: Darktide at 2x on RTX 30 (Streamline 2.12). dashdogy's fix is in its own replacement of NVIDIA's frame generation wrapper, which this addon does not have: here NVIDIA's own sl.dlss_g runs. This PC cannot reproduce Streamline 2.12. Even the 2.11.1 Sample runs the 2.14.16 plugin the NVIDIA app's override supplies, and there is no RTX 30 Darktide report yet. The chain card and sl.log from such a report would show it.

XeMFG DLSS-G in Vulkan games (experimental)

XeMFG DLSS-G now reaches Vulkan games with DLSS frame generation. dashdogy's Vulkan DLSS-G provider (MFG Unlocker v1.7.1, MIT) replaces NVIDIA's frame generation feature from the addon's NGX Vulkan hooks: Intel's ported model records into each evaluation's command buffer on the game's own device, through the xvk layer, and Streamline's DLSS-G still presents and paces. NVIDIA's feature is never created, so its video memory is not spent. The Vulkan host only adds the provider's features to the game's device and never takes a swap chain. If the provider refuses, NVIDIA's frame generation runs instead. This replaces JavieEm's GPL approach (copying the game's images to Direct3D 12 and presenting through a DXGI swap chain of its own, which ReShade would not see); none of that code was used.

  • On by default with XeMFG DLSS-G ([DLSSG] XmxVulkan=1). It acts only when ReShade is loaded as the game's Vulkan layer, so Direct3D games are not touched. The General page shows it under XeMFG DLSS-G options with its status.

  • XeFG's own UI composition is off. With it on, XeFG left the generated frames uninterpolated in DOOM: The Dark Ages (and in KCD2 on Direct3D 12). [DLSSG] XmxUiComposition=1 brings it back for testing.

  • Tested in DOOM: The Dark Ages (launched with +r_allowBlackListedLayers 1, which the game needs for ReShade's layer).

  • Pacing in Vulkan games ([DLSSG] XmxVulkanPacing, on by default, also in the panel):

    • The problem: XeMFG DLSS-G costs more GPU per frame than NVIDIA's generator, and the game's Reflex still aims at the display's refresh ÷ multiplier. When the GPU could not hold that (DOOM: The Dark Ages with path tracing), the queue filled until presentation stalled: about 0.8 s of real frames at ~45 ms, every ~2 s.
    • The fix: the addon reads the interval between real frames from the driver's own Reflex reports. At the first stall it applies an output frame limit just under the rate the GPU held, backs off at each new stall, and raises the limit slowly when it holds.
    • Result in DOOM: steady at ~115–120 fps (4x) instead of swinging between ~165 and ~95.
    • Expected cost: with the GPU at its limit (DOOM with path tracing), XeMFG DLSS-G runs about 20 fps below NVIDIA's generator. XeFG's network runs on the shader and tensor cores (~4–5 ms per real frame at 4x), where NVIDIA's generator uses the GPU's optical flow hardware.
    • A frame rate cap of the player's own takes its place. The panel shows the current limit; the support report's chain_xmx_vulkan_pacing line says what applied.
  • Also fixed on the way:

    • A rare black screen at start: the XeMFG DLSS-G hooks and the NGX Vulkan discovery patched code at the same time, each suspending the other, or a thread was suspended while it held the process heap's lock.
    • A crash when the output frame rate cap was turned on in a Vulkan game.
    • The provider no longer adds NVIDIA's present metering extension to the game's device; only the XeMFG host uses it.

DLSS frame generation in games without it (experimental)

Add frame generation on the General page ([DLSSG] AddFrameGeneration=1, off by default) gives NVIDIA's DLSS frame generation to games that integrate Streamline for DLSS Super Resolution but not for frame generation, using only what the game already gives Streamline: its depth and motion vector tags and its camera constants. The addon adds DLSS-G to the features Streamline loads in slInit, then turns it on at the panel's multiplier from the game's constants. XeMFG DLSS-G works there too, since it replaces NVIDIA's generator inside a real DLSS-G. Unlike JavieEm's GPL "force FG" (whose code was not used), nothing is invented: no synthetic camera, no own Streamline session (that is the next section, for games without Streamline), and no change in games that ask for frame generation themselves. It needs the game's Reflex and the addon loaded early. See the README.

Tested with NVIDIA's Streamline Sample made into an SR-only game (tools/sl_sample.py, MFG_SAMPLE_SR_ONLY=1). Without the option Streamline loads no DLSS-G. With it, DLSS-G runs at 4x with +583 MiB, the sample's own cost, and with XeMFG DLSS-G selected, XeMFG DLSS-G generates every frame (1686 of 1686 in 10 s). This is part of the automated suite (force_fg_sl_sample). No game tested yet. Open point: in the full suite, the XeMFG DLSS-G case missed XeMFG DLSS-G in 2 of 4 runs: NVIDIA's generator ran although XeMFG DLSS-G's hooks were in place on the provider NGX loaded, and the cause is not found yet. The test retries that case once and says so.

DLSS frame generation and XeMFG DLSS-G in games with DLSS Super Resolution only (experimental)

Games such as Red Dead Redemption 2, Kingdom Come: Deliverance II and Metro Exodus Enhanced Edition call DLSS Super Resolution straight through NGX and have no Streamline at all, so the forced route above cannot reach them. For these, the addon now starts NVIDIA's Streamline 2.14.16 itself, in Streamline's manual hooking mode, and gives the game DLSS frame generation, or XeMFG DLSS-G when it is selected (XeMFG DLSS-G then runs as in any game with DLSS-G, with the video memory fix). Each DLSS SR evaluation tags its depth and motion vectors for DLSS-G. There is no camera in NGX, so the constants are a fixed projection with the camera motion left in the vectors, and automatic scene change detection stays off.

  • One switch. Add frame generation under Games without frame generation on the General page ([DLSSG] AddFrameGeneration=1, off by default) turns on both routes. Each stays inert where it does not apply. A game that has its own Streamline, or ships sl.interposer.dll, is never hosted. The older ForceFrameGeneration and HostStreamline keys become this one.
  • Files. The MFGUnlock-Streamline folder goes beside the addon, with sl.interposer.dll, sl.common.dll, sl.dlss_g.dll, sl.reflex.dll, sl.pcl.dll and nvngx_dlssg.dll from the bin/x64 folder of NVIDIA's Streamline SDK 2.14.16 (https://github.com/NVIDIA-RTX/Streamline/releases). They are not part of this release. The panel says when the folder or a file is missing.
  • Direct3D 12. Streamline wraps the DXGI swap chain below ReShade, so the panel and ReShade's effects stay on the real frames.
  • Vulkan ([DLSSG] HostVulkan=0 turns it off alone). When ReShade is the Vulkan layer, slInit runs before the game creates its device. The game's device gets the extensions, features and queues DLSS-G, Reflex and PCL ask for. Then the swap chain, acquire, present and wait calls go through Streamline's proxies. RDR2 needed four fixes:
    • slInit could not wait for itself, because DLSS-G's plugin creates its own Vulkan instance inside it.
    • When a queue family is full (RDR2 asks for all 8 compute queues), Streamline's queues go to another family that can do the work. When every family is full, they share one of the game's queues.
    • The game's window surface predates Streamline, so it is shown to Streamline again.
    • vkAcquireNextImage2KHR goes through Streamline's proxy too.
  • HUD fix ([DLSSG] HudFix=1, on by default, Direct3D 12 only):
    • The addon copies the last render target of the back buffer's size before the game draws its HUD, and gives it to DLSS-G as the HUD-less image.
    • With XeMFG DLSS-G, a compute pass puts the real frame's HUD over each generated frame, so the crosshair and the HUD do not repeat.
    • Show what counts as HUD ([DLSSG] XmxHudDebug=1) paints it magenta.
    • The copy is used only for the frame it was captured in, and the composition runs only at the back buffer's size. This fixed Metro Exodus in HDR, where XeMFG DLSS-G had interpolated an older, smaller copy (a dim image with black flicker).
  • Tested:
    • Kingdom Come: Deliverance II, Direct3D 12: XeMFG DLSS-G with the HUD fix.
    • Red Dead Redemption 2, Direct3D 12: DLSS-G and XeMFG DLSS-G.
    • Red Dead Redemption 2, Vulkan: DLSS-G and XeMFG DLSS-G.
    • Metro Exodus EE: a tester's report led to the HDR fix above. The fix is not confirmed by the tester yet.
  • Not tested: a Vulkan game whose queue families are all full (the shared-queue case). The HUD fix in Vulkan does not exist yet.

XeMFG DLSS-G video memory: NVIDIA's unused generator is no longer created

A player saw XeMFG DLSS-G use almost twice the video memory of NVIDIA's frame generation on an RTX 4080. Measured on this PC (RTX 4070 SUPER), NVIDIA's Streamline Sample at 2560x1440 and 4x, with Windows' per-process counter (tools/measure_fg_vram.py):

Dedicated video memory Cost of frame generation
No frame generation 1267 MiB
NVIDIA's DLSS-G 1847 MiB +580 MiB
XeMFG DLSS-G in 1.9.0 (XmxSaveVram=0) 2242 MiB +975 MiB
XeMFG DLSS-G in 1.10.0 1818 MiB +551 MiB

Where the memory went. A diagnostic trace of every Direct3D 12 allocation by calling module (MFG_VRAM_TRACE=1, vram_trace.hpp) showed:

  • NVIDIA's frame generation feature: 406 MiB in 48 resources (full- and half-resolution intermediates, weights and scratch), allocated when DLSS-G creates it. XeMFG DLSS-G never used it, because XeMFG DLSS-G replaces NVIDIA's generator.
  • Streamline's own buffers for the presentation (still needed).
  • XeFG's model (230 MiB).
  • XeMFG DLSS-G's input and output copies (160 MiB).

The change. With XeMFG DLSS-G ready, the addon answers NGX's creation of frame generation itself, in the NGX loader _nvngx.dll (the same place as the existing creation hook, which NVIDIA does not refuse). NVIDIA's feature is never created, and Streamline hands each frame straight to XeMFG DLSS-G. XeMFG DLSS-G's generation code is the same.

  • Measured on the Streamline Sample: the same −424 MiB, with XeMFG DLSS-G generating 1686 of 1686 frames in 10 s, on Streamline 2.7.32, 2.9.0, 2.11.1 and 2.14.16. It works in the forced DLSS-G too (1832 MiB against NVIDIA's 1847). The waste grew with resolution, so at 4K the saving should be larger (an estimate: not measured).
  • On by default. To get the 1.9.0 behavior back, turn off XeMFG DLSS-G: free NVIDIA's unused memory on the General page (under XeMFG DLSS-G), or set [DLSSG] XmxSaveVram=0. The support report says which applied (xmx_nvidia_feature).
  • Fallback. NVIDIA's generator is no longer there to fall back to. A frame XeMFG DLSS-G cannot generate repeats the real one, as it already did.
  • No game tested yet.

Also kept from the measurement work:

  • The support report has a new chain_vram line: the process's video memory before frame generation and 3-20 s after it went on, and the size of XeMFG DLSS-G's copies. It needs a Direct3D game (DXGI reports no budget for Vulkan).
  • XeMFG DLSS-G's 10-second log summary also gives the size of its copies.
  • Creating XeFG's context for 3 generated frames instead of 5 changed nothing, so that option is not offered.

XeMFG engine updated to dashdogy's MFG Unlocker v1.7.1

The vendored XeMFG engine (pacing, the CUDA route, the D3D12-on-Vulkan layer and its host) moves from dashdogy's v1.7.0 to v1.7.1 (128d081, MIT). It is a three-way merge against v1.7.0: 25 files merged clean, 22 conflicts in 6 files resolved by hand, and the new files the merged ones need.

  • New pacer. v1.7.1 rewrote the XeMFG pacer: a flip queue with a jitter-buffer clock, a low-latency pacing controller and its own sizing of XeFG's native swap chain. It removed the metered-deadline planner that two of this project's comparison controls were built on, so these are gone from the panel and the INI: Queue metered frames early ([XeFG] MeteredQueueAhead, which was on by default), Use Intel SDK timing (SdkDeadlines), XeFGFlipQueueBufferPct and XeFGFlipQueueFirst. Driver flip metering and its live switch, XeFGNativeLatency (outside the flip queue), the panel's pacing status and the native build's runtime traces are kept.
  • Tensor cores in Vulkan games. The Vulkan host can now run the ported model's layers on NVIDIA tensor cores through the same CUDA fatbin as the D3D12 route, which is on by default as upstream ships it.
  • XeLL binding. When a game ships its own libxell.dll (Cyberpunk 2077), the Vulkan host binds XeFG to the XeLL beside it.
  • Not taken: XeMFG as OptiScaler's DLSS-G provider (vk_provider.h is a stub here: this build never runs under OptiScaler), the latency probe of upstream's own menu (a no-op here), and the LZMA packing of the embedded programs. The programs' generators did not change between v1.7.0 and v1.7.1, so this build keeps its own verified resources.
  • Tests. Upstream's latency_pacing and pacing_diag tests replace the cadence test of the removed estimator. Still to measure in games: pacing and latency against 1.9.0 with PresentMon, in at least one D3D12 and one Vulkan game. The suite has no way to judge smoothness.

Panel languages (block 5)

The panel now speaks English, Portuguese (Brazil), Spanish, Japanese, Korean and Simplified Chinese.

  • It follows ReShade's own language by default, then the Windows display language. The selector at the bottom of the panel changes it at once and remembers it ([Panel] Language in MFGAdaUnlock.ini: auto, en, pt-BR, es, ja, ko or zh-CN).
  • The five translations are machine translations, not yet reviewed by native speakers; the selector marks them with *. Corrections are welcome: each language is one file, src/addons/mfgunlock/i18n/strings_<language>.inl.
  • Logs, the support report and the names of settings stay in English, so whoever helps with a problem reads the same words. Status values shared with the support report (for example REFramework's "Not detected") also stay in English.
  • Fonts for Japanese, Korean and Chinese. ReShade draws its whole interface with one font, and the Cascadia Mono the addon sets since 1.8.1 has no CJK characters. When one of these languages is chosen and ReShade's font is empty or the addon's own Cascadia Mono, the addon sets the Windows font ReShade itself would use (Yu Gothic UI/BIZ UDGothic or MS Gothic, Malgun Gothic, Microsoft YaHei). A font you chose is never replaced. If the current font cannot draw the language, the panel shows English until the next start instead of empty boxes.
  • The automated suite checks that every translation keeps the English text's format codes, list separators and edge spaces, that every language is complete, and that no visible panel text is left outside the tables (tools/extract_panel_strings.py --check, tools/sync_panel_tables.py --check).

Compatibility matrix and reports (block 3)

  • Compatibility matrix, generated from docs/compat/compat.json by tools/build_compat_matrix.py: one row per report, with backend, API, GPU, runtime versions, result, source and date. It starts with the README's tables (RTX 40) and the first RTX 3060 Ti list (15 games with XeMFG DLSS-G, from Calledme_kev on the OptiScaler Discord). The suite fails when the page is stale.
  • Game report form on GitHub: it asks for the panel's support report pasted whole, and the support files when frame generation does not start.
  • Admission test on a simulated RTX 30: see block 2; it runs NVIDIA's Streamline Sample in the load order that broke Rift Apart.
  • Image regression: image_ssim compares two images by SSIM (mean and worst 8x8 window). The suite renders the XeMFG panel in all six languages and compares each with a reference, so a clipped translation or a missing glyph fails. Game captures for the same comparison need a field session and are not part of this release.

Project (block 4)

  • A GitHub Actions build of the DLSS-G addon with the tests that need no game, GPU or local file (about 20). It pins the same RenoDX commit as the local gate. It has not run yet: it runs on the first push.
  • .clang-format for new code (git clang-format); existing files are left as they are.

Panel code

  • The panel's pages moved out of addon_overlay.inl into one file each (overlay_page_*.inl), and the legacy overlay, unused since 1.8.1, is gone: 5,089 lines became 2,146 plus five page files.

General page

  • The General page is grouped in cards: Frame generation (method, multiplier, Dynamic MFG) and Frame rate.
  • Three collapsible sections follow: XeMFG DLSS-G options (video memory, Vulkan games), Games without frame generation (the switch, its status and route, the HUD fix) and Add-on.
  • Switches are toggles, each status is a coloured chip, and the footer holds the version, the language and the GitHub link.
  • Returning from Japanese, Korean or Chinese to another language puts back the addon's Cascadia Mono font.

Validation

Pending.

Don't miss a new MFGAdaUnlock-RenoDx release

NewReleases is sending notifications on new releases.