DLSS5 AMD Swapper v0.3.0-pre.3

DLSS5 AMD Swapper v0.3.0-pre.3

This preview updates compatibility with DLSS-NR-on-AMD v0.3.1 and makes failed Lossless Scaling startup diagnosable.

• Verified v0.3.1 installer size/hash support in the manager and CLI, with strict digest validation and retained game-specific compatibility pins.
• Modern Lossless Scaling configuration explicitly selects asynchronous colour-only processing (Async=1, PreUpscale=0) while retaining legacy Inline=0.
• The bridge rejects incompatible runtime modes before starting and records initialization, capture, Present/occlusion and HIP progress in bridge-startup.log.
• HIP timing samples are flushed during startup and failure, fixing the misleading header-only evidence described in issue #3.
• Direct Game diagnostics recognize completed neural work without GPU profiling and keep completion counts separate from timing measurements.
• Settings → Check runtime updates checks official AMD and OptiScaler release metadata and explains the custom pre-SR package boundary. Latest stable OptiScaler checked: v0.9.4; no verified newer compatible custom fork was substituted.

Download and extract the portable ZIP, then run Dlss5AmdSwapper.exe or Install.cmd. Close Lossless Scaling and run its setup/update in the new manager to deploy the bridge and regenerate its runtime configuration. Updating only the manager does not replace an installed bridge. External runtimes and proprietary neural files remain user-supplied and are not bundled.

Validation: C# smoke/regression suite, 52 Python tests, native bridge CPU tests, auto-scale harness and four installer configurations, 15 packaging/rollback tests, five desktop lifecycle processes, 1,899 theme/contrast checks, and self-contained package checksum verification. Light/dark settings renders were inspected locally.

No new GPU performance benchmark or affected-machine neural run was performed. Issue #3 remains open for retest: the v0.3.x configuration fix and startup telemetry fix are verified, while the original v0.2.18 RX 9060 XT runtime stall is not yet confirmed resolved. Native visible output, neural workload cap, and completed-job readiness checks remain in place.

See upstream research and retest instructions.

DLSS5 AMD Swapper v0.3.0-pre.2

DLSS5 AMD Swapper v0.3.0-pre.2

This preview release adds session-scoped runtime diagnostics, render hook failure detection, single-flight evidence refreshes, and explicit settings persistence for the direct-game on/off toggle. It also documents fresh compatibility testing on the updated Crimson Desert build.

What changed

• Session-scoped diagnostics: Diagnostics evaluate only the newest dlssnr_amd ... loaded into <game exe> session in dlssnr_on_amd.log. Earlier successful sessions can no longer mask a stalled or failed launch.
• Render hook failure detection: The manager and CLI detect failed render detours (detour of <function> failed (<code>)) and report when hooks fail to install, diagnosing inactive launches immediately rather than waiting for an engine timeout.
• Truthful runtime status strings: Updated status reporting to distinguish hook failures and startup stalls: Neural engine stalled - render hooks failed this launch, Neural engine stalled - effect inactive this launch, Runtime loaded - Neural Rendering not active yet, and Neural Rendering active - log verified.
• Single-flight diagnostics refresh: Automatic and manual evidence inspections are now guarded against concurrent execution, preventing overlapping inspections.
• Explicit on/off hotkey persistence: Ctrl+Alt+F6 now explicitly toggles and saves the on/off setting to dlssnr_on_amd.ini and notifies the user. The post-FSR runtime has no external live-toggle API, so the upstream End overlay remains the live control.
• Unmanaged proxy conflict guard: Install and update workflows now detect and refuse to proceed when an additional unmanaged proxy DLL appears next to a managed install.
• OptiScaler package validator updates: The validator accepts dlss-enabler-headless.dll and a real dlssnr_on_amd_weights.bin placed beside a package folder whose name starts with OptiScaler-AMD-PreSR-Multipass.
• Pre-SR proxy block and migration for Crimson Desert: The manager blocks the AMD pre-SR v1.2 proxy (SHA-256 07a1e2ca3fbf6c9c9a2923a755603c69fabf115b0904c92f10efe95fdb2b0caa) for CrimsonDesert.exe due to startup access violations and migrates existing installs back to the official post-FSR route.
• Pinned runtime version for Crimson Desert: For CrimsonDesert.exe, the post-FSR route pins upstream v0.2.17 (7,538,418 bytes, SHA-256 4fcd167d07bc4964eaf9162aa8f4f11e852b91bf866b28cb48d45934022440bc), validated against GitHub release tag metadata.
• Diagnostics export and CLI parity: Exported diagnostics include hookFailures, failedHooks, swapchainsCreated, hooksInstalled, engineInitialized, fidelityFxDispatchObserved, presentQueueObserved, and startupStalled. The CLI --diagnose command outputs the same session-scoped fields (session_scoped, runtime_version, engine_initialized, hook_failures, failed_hooks, swapchains_created, hooks_installed, hooks_failed, present_queue_observed, startup_stalled).
• UI styling and configuration fixes: Fixed dark-theme ComboBox selectors in App.xaml, disabled DXGI spoofing for Crimson Desert in generated OptiScaler.ini, and added a known-hash fallback for upstream v0.2.18 (7,570,162 bytes, SHA-256 dad67cc649ad91ba28e83c30049fc899900ae532daf818803bd1123e6e2315c3).

What did not change

• Lossless Scaling bridge and compositor: The Lossless Scaling desktop route, WGC capture pipeline, native presentation, and neural residual filtering remain unchanged.
• Core Direct Game install architecture: Reversible manifests, file preservation on modified files, and hash-backed verification remain unchanged.

Known incompatibility

• Crimson Desert current build: Following its 11 September 2026 Steam update (buildid 25246367), CrimsonDesert.exe causes three DirectX 12/DXGI render hook detours (ExecuteCommandLists, CreateSwapChain, Present) to fail with error code 5 in both upstream v0.2.17 and v0.2.18. The game process stays running, but no frames reach the runtime and Neural Rendering cannot activate. The pre-SR v1.2 proxy also causes startup access-violation faults and is blocked for this title. See Direct Game verification — 12 September 2026 for logs, mitigation checks, and reproduction details.

Third-party boundary

This repository and its release packages do not contain:

• OptiScaler.dll, dxgi.dll, or OptiScaler dependency libraries
• dlssnr_amd_pass*.dll proxy binaries or dlssnr_on_amd_weights.bin
• official DLSS-NR-on-AMD installers or runtimes
• paid Lossless Scaling binaries or Lossless_original.dll
• NVIDIA Neural Rendering DLLs, models, or SDK files
• private manifests, logs, machine paths, or unreviewed captures

OptiScaler is licensed under GPL-3.0; because source code for the pre-SR fork has not been published, its binaries cannot be redistributed with source obligations satisfied. Upstream DLSS-NR-on-AMD forbids redistribution and modification. All third-party runtime binaries and weights remain strictly user-supplied and local.

Verification

• 54 C# smoke and regression tests passed, covering session-scoped parsing, hook failure reporting, single-flight refresh guards, OptiScaler package validation, rollback, and runtime controls.
• 15 direct-game Python unit tests passed across post-FSR and pre-SR install, update, removal, and session-scoped diagnostic flows.
• Publication provenance check (tools/Check-Publication.py) passed with forbidden-filename verification.
• Package build is pending controller completion (package hashes and binary sizes will be populated upon final build).

DLSS5 AMD Swapper v0.3.0-pre.1

DLSS5 AMD Swapper v0.3.0-pre.1

This preview release introduces the OptiScaler pre-SR route for Direct Game, adds Lossless Scaling layer adjustments, and strengthens the repository publication gate.

What changed

• OptiScaler pre-SR route: Added support for evaluating the neural model on the unscaled render buffer before super-resolution upscaling (FSR (ffx)) using an OptiScaler pre-SR fork (amd-presr-multipass-local).
• Package discovery and validation: The manager automatically discovers local package folders and zip archives under Downloads, Desktop, and Documents, validates PE x64 binaries, verifies the amd-presr version string and dlssnr_amd pass DLL marker, and checks file integrity against SHA256SUMS.txt.
• Reversible pre-SR installation: Hash-backed manifests (.dlss5-amd-swapper.json, schema 3) record before-and-after hashes. Rolling back or restoring an install cleanly removes newly created files while preserving pre-existing dependencies.
• Quality and Performance presets: Added pre-configured presets for pre-SR upscaling (Quality) or ratio override with multi-frame generation (Performance).
• Pre-SR runtime diagnostics: The manager and CLI parse amd_presr.log and OptiScaler.log to report active passes, HIP adapter, model and target dimensions, and GPU evaluation times.
• Lossless Scaling layer controls: Added Structure, Skin, and Tone sliders with an optional "Skin follows structure" mode on the Lossless Scaling page.
• Layer hotkeys: Added Ctrl+Alt+F9 (cycle active layer), Ctrl+Alt+F10 (decrease strength by 0.1), and Ctrl+Alt+F11 (increase strength by 0.1) while LosslessScaling.exe is running, alongside existing Ctrl+Alt+F6/F7/F8 controls.
• CLI parity: The direct-game Python helper (direct-game/amd_dlss5.py) supports the --route optiscaler-presr backend for checking, installing, updating, diagnosing, and removing pre-SR installs.
• Publication gate: Added forbidden-filename scanning to tools/Check-Publication.py and app/Build-Package.ps1 to prevent OptiScaler fork binaries, pass proxy DLLs, weights, and private logs from entering repository commits or release packages.

What did not change

• Core Lossless Scaling transport and composition: The shared GPU transport, WGC capture path, native visible presentation, and asynchronous neural residual filter remain unchanged.
• Official post-FSR direct-game route: The existing amd-fsr-direct path using the official DLSS-NR-on-AMD installer remains fully supported; the setup dialog offers both backends and preselects pre-SR only when a verified package and local weights are present.

Third-party boundary

This repository and its release packages do not contain:

• OptiScaler.dll, dxgi.dll, or OptiScaler dependency libraries
• dlssnr_amd_pass*.dll proxy binaries or dlssnr_on_amd_weights.bin
• official DLSS-NR-on-AMD installers or runtimes
• paid Lossless Scaling binaries or Lossless_original.dll
• NVIDIA Neural Rendering DLLs, models, or SDK files
• private manifests, logs, machine paths, or unreviewed captures

OptiScaler is licensed under GPL-3.0; because source code for the pre-SR fork has not been published, its binaries cannot be redistributed with source obligations satisfied. Upstream DLSS-NR-on-AMD forbids redistribution and modification. All third-party runtime binaries and weights remain strictly user-supplied and local.

Verification

• 44 C# smoke tests passed, including OptiScaler package discovery, validation, preset generation, reversible installation, rollback, restore, log parsing, and runtime layer controls.
• 8 direct-game Python unit tests passed across post-FSR and pre-SR install, update, and removal flows.
• Publication provenance check (tools/Check-Publication.py) passed with forbidden-filename verification.
• The genuine OptiScaler-AMD-PreSR-Multipass-v1.2 package was validated with real files by both the manager and the CLI, and Crimson Desert was switched from the post-FSR route to the pre-SR Quality preset on the development machine (files, manifest and app discovery verified).
• In-game gameplay verification and performance capture recording for the pre-SR route are still pending; this preview is published before a hashed capture exists, so no performance number is claimed.

DLSS5 AMD Swapper v0.2.0-pre.1

DLSS5 AMD Swapper v0.2.0-pre.1

This is the first release under the DLSS5 AMD Swapper name and the first one built around the Windows manager instead of the old bridge-only workflow.

What changed

• Added the WPF DLSS5 AMD Swapper manager with the dark coral/graphite UI.
• Added universal installed-game scanning across Steam, Epic, GOG, EA, Ubisoft, Battle.net, Xbox/Game Pass, Rockstar, and standalone folders.
• Added the Direct Game route with compatibility checks, automatic install/update, runtime-source verification, restore support, and log-backed diagnostics.
• Added the Lossless Scaling route with automatic activation when Scale is pressed.
• Added Ctrl+Alt+F6/F7/F8 toggle and strength controls.
• Kept native visible output while allowing the Lossless Scaling neural branch to run at a lower internal workload.
• Added the in-app game-scan verification overlay and kept scans from selecting a game automatically.
• Added the app icon, portable package, and desktop-shortcut workflow.
• Reworked the public documentation around the Swapper instead of the old NR Auto Scale prototype.

Package boundary

The portable ZIP contains the manager and project-owned bridge/wrapper/scripts only. It does not contain paid Lossless Scaling files, NVIDIA Neural Rendering runtime files, DLSS-NR-on-AMD binaries/weights, third-party AMD runtime binaries, private logs, machine-specific configuration, or personal files.

The external runtime files remain user supplied and keep their own licenses and terms.

Verification

The release build passed the manager smoke suite, installed-game scan, Lossless Scaling bridge recognition, publication provenance check, package hash validation, and forbidden-file gate before upload.

NR Auto Scale v0.1.0-pre.3-dev.6

v0.1.0-pre.3-dev.6

This checkpoint publishes the native-output / low-resolution-neural path after I manually confirmed the dev.6 visual behavior through Lossless Scaling.

The visible bridge now stays at the captured application's native resolution while only the neural branch is capped at 480 pixels high. A 2560×1440 source uses roughly 854×480 for Neural Rendering and remains 2560×1440 for the visible composite.

What changed

• added NeuralMaxHeight, defaulting to 480
• kept the native captured source as the visible image base
• kept the neural branch source-relative and aspect-correct
• replaced dev.5's high-frequency-only neural filter with a temporally matched neural-delta compositor
• retained one previous 480p input so asynchronous neural output can be matched to current/prior color input
• added a lightweight confidence gate that fades broad stale corrections in moving regions
• reduced the visible compositor from five neural texture samples per pixel to three low-resolution samples per pixel
• kept the same neural model/weights, precision/settings, Inline=0, and Interop=1
• retained Ctrl+Alt+F6 toggle and F7/F8 strength controls
• extended native neural-delta strength up to 4.0
• kept automatic activation through the normal Lossless Scaling Scale workflow

Manual acceptance

The previous dev.5 build was fast but looked mostly like sharpening because the compositor intentionally discarded most low/mid-frequency neural reconstruction. After installing dev.6, I confirmed that the effect now behaves as intended visually.

The earlier dev.4 version of this 480p-neural/native-output layout was about 60 FPS without frame generation in my World of Tanks test. I did not record a new numeric FPS value during the final dev.6 acceptance, so this release does not present that earlier number as a fresh dev.6 benchmark.

Runtime limitation

The Lossless Scaling bridge has the final color frame but not the game's engine depth/motion buffers. The runtime can use those guide buffers in a real FSR hook, so this color-only bridge cannot claim full parity with a native in-game integration. Dev.6 uses temporal color matching to retain the broader neural correction without adding a second neural pass.

Package contents

The ZIP contains the project-built bridge/proxy, setup and uninstall scripts, documentation, checksums and the previously approved historical comparison images.

It does not contain:

• paid Lossless Scaling binaries or app assets
• Lossless_original.dll
• AMD compatibility proxy/runtime binaries
• NVIDIA runtime DLLs, models or weights
• private INIs, logs, backups or machine paths
• any new screenshots

Users provide required third-party runtime files from their own legitimate copies during setup.

Exact project artifact hashes are in RELEASE.json; every packaged file is listed in CHECKSUMS.json inside the ZIP.

See Installation, Performance, and Verification.

v0.1.0-pre.3-dev.3

v0.1.0-pre.3-dev.3

This checkpoint is the first public build of my reduced neural working-resolution path.

On my RX 9070 XT with a 2560×1440 source, WorkingScale=0.75 runs Neural Rendering at 1920×1080 and lets Lossless Scaling perform the final upscale. In the manual test I observed about 30 FPS without frame generation and about 60 FPS with Lossless Scaling 2× frame generation.

A clean full-effect section of the non-FG bridge log recorded 1,417 changed RGB submissions over 49.127 seconds (28.84/s). A separate 2× frame-generation session used the same 2560×1440 → 1920×1080 GPU path and recorded 28.52 changed RGB submissions/s in the selected window while I observed about 60 FPS output through Lossless Scaling.

The bridge does not count generated LSFG frames, so the 60 FPS figure is recorded as a manual Lossless Scaling observation rather than a bridge-derived display metric.

What changed

• added WorkingScale for source-relative neural resolution
• new installs default to WorkingScale=0.75
• generalized shared GPU transport to reduced/fixed neural sizes
• kept WGC capture at source resolution
• added GPU bilinear source → neural resize when dimensions differ
• kept exact texel loads for the 1:1 path
• retained alternating shared output/history slots to avoid the full-strength history copy
• retained direct shader-capable WGC capture with GPU-copy fallback
• disabled bounded HIP kernel timing by default; --hip-kernel-timing turns it back on for diagnostics
• kept the same neural model, weights, precision/settings and full effect strength

For a 2560×1440 source, WorkingScale=0.75 means 1920×1080 NR, or 56.25% of the native neural pixel count.

Compared with pre.2

Version	Neural size	Base output	Changed RGB cadence
v0.1.0-pre.2	2560×1440	~19 FPS	18.46/s complete run
v0.1.0-pre.3-dev.3	1920×1080	~30 FPS	28.84/s selected full-effect window

The base-output change is roughly +58%. This is a deliberate resolution/workload change, not a same-resolution micro-optimization, so I do not claim pixel-identical quality versus native NR.

Package contents

The ZIP contains only project-built binaries, setup/uninstall scripts and documentation. It does not contain:

• paid Lossless Scaling binaries
• Lossless_original.dll
• AMD compatibility proxy binaries/installers
• NVIDIA runtime/model files
• raw logs or private configuration
• any new screenshots

Users provide the required external runtime files from their own legitimate copies during setup.

Exact release artifact hashes are in RELEASE.json and package file hashes are in CHECKSUMS.json.

Restore native NR

To disable the reduced working-resolution path and return to 1:1 neural processing:

WorkingScale=0
NativeResolution=1

See Performance, Verification, and Pre-upscale performance.

NR Auto Scale v0.1.0-pre.3-dev.15

v0.1.0-pre.3-dev.15

Dev.15 keeps the accepted dev.14 Lossless Scaling compositor and adds the first verified direct-game AMD Neural Rendering route.

Added

• direct-game/amd_dlss5.py for supported x64 DX12/FSR games.
• Verification of the user-supplied official DLSS-NR-on-AMD setup file before installation.
• Target checks for FSR/DX12 evidence and common anti-cheat markers.
• Verification of the upstream rich temporal configuration (UseFsrInputs, depth, temporal history, interop and inline mode).
• Hash-safe direct-game install/update/remove/rollback state.
• Runtime diagnostics for FidelityFX dispatch, FSR color/motion/depth dimensions, depth mode, exposure, interop, HIP selection, timing samples and fault/error markers.
• tools/Capture-Performance.ps1 for PresentMon game/display timing captures.
• Schema-2 bridge/scripts/Analyze-Run.py output with raw-source SHA-256 provenance.
• tools/Check-Publication.py to block hand-entered FPS prose and untraceable measurement JSON.
• Static DLSS reference comparison tooling that does not publish the supplied reference images.

Lossless Scaling path

The main branch keeps dev.14's native-source compositor, 480p default neural-height cap, motion rejection, stable correction reuse, automatic Scale integration and Ctrl+Alt+F6/F7/F8 controls. No new screenshot was added.

Direct-game validation

The v0.2.17 route was exercised on an x64 DX12/FidelityFX game. The runtime log confirmed FidelityFX dispatch interception, color/motion/depth staging, inverted-Z depth, zero-copy input/output interop, inline mode, completed Neural Rendering jobs and HIP selection on the RX 9070 XT. No runtime fault/GPU-error marker appeared in the sampled run.

A PresentMon capture was also recorded and analyzed with source hashes. It was a runtime smoke run at full-resolution FSR input rather than a controlled A/B benchmark, so this release does not publish it as an optimized performance headline.

Release boundary

The public repository and ZIP contain no paid Lossless Scaling files, Lossless_original.dll, third-party AMD runtime/proxy binaries or installers, NVIDIA DLSS-NR DLLs/models/weights, raw logs, private INIs/manifests, backups, personal files, or new/unreviewed screenshots.

v0.1.0-pre.3-dev.14

v0.1.0-pre.3-dev.14

This checkpoint publishes the best visual/performance balance I have reached so far on the AMD color-only Lossless Scaling path.

The visible output stays at the captured application's native resolution while only the neural branch is capped at 480 pixels high. A 2560×1440 source uses roughly 854×480 for Neural Rendering and remains 2560×1440 for the visible composite.

What changed since dev.6

• kept the native source as the visible base and the neural branch capped at 480p
• kept automatic activation through Lossless Scaling and the existing F6/F7/F8 controls
• preserved the high-rate visible presentation path so duplicate suppression does not starve Lossless Scaling
• removed cross-frame native-image blending that caused ghost trails and wet-paint smearing in intermediate experiments
• spatially filters broad asynchronous neural residual color/luminance changes
• strongly suppresses stale chroma and stale correction magnitude as source motion increases
• reuses an accepted correction only for effectively unchanged native pixels
• keeps the runtime/model settings and baseline neural quality unchanged

Manual acceptance

After installing dev.14 I confirmed that stationary flicker was fixed, flicker while moving was barely noticeable, and performance was still good. I did not record a fresh numeric game-FPS value, so the release does not turn bridge submission cadence into an FPS claim.

Verification

The bridge and proxy built successfully. BridgePixelTests passed, the auto-scale/installer harness passed on a fresh rerun, and the installed bridge matched the final build by SHA-256. A standalone runtime probe completed real 480p neural jobs on the RX 9070 XT while preserving high-rate visible submissions.

Runtime limitation

The Lossless Scaling bridge has the final color frame but not the game's engine depth/motion/exposure buffers. The current AMD compatibility runtime reports this path as asynchronous color-only output with runtime history off. Dev.14 stabilizes that residual, but it does not claim parity with a native in-game guided DLSS-NR integration.

Package contents

The ZIP contains only project-built bridge/proxy binaries, setup and uninstall scripts, documentation, checksums, and the previously approved historical comparison images. It does not contain paid Lossless Scaling files, AMD proxy/runtime binaries, NVIDIA runtime/model files, private INIs/logs/backups, machine-specific paths, or new screenshots.

v0.1.0-pre.2 — Native performance preview

v0.1.0-pre.2

This is my first public native-resolution performance checkpoint after moving more of the bridge path onto shared GPU resources and cutting repeated host work.

On my RX 9070 XT at 2560×1440, the recorded run produced 1,112 changed RGB submissions in 60.238 seconds (18.46/s) and I observed roughly 19 FPS base output. I am not calling the nominal 19 × 2 = 38 FPS frame-generation multiplier a measured display result because the bridge did not independently measure LSFG/display FPS.

Changes since pre.1

• native-resolution capture/forwarding with WGC routing preserved across profile changes
• shared GPU transport for the native path
• exact RGB duplicate-output suppression
• fewer redundant feed/check iterations
• direct full-strength neural presentation where the current GPU path allows it
• bounded HIP host timing
• inference-aware feed pacing based on observed worker waits
• sanitized measurement and release metadata

Selected intervals moved from about 17.53 to 18.69 changed RGB submissions/s while GPU feed/check iterations dropped from about 105.49 to 26.08/s. That is a useful reduction in repeated work; it is not a matching neural speedup. Sampled HIP device waits remain around 52 ms.

Package contents

The release contains the project-built DlssNrBridge.exe and project-built Lossless.dll wrapper plus setup/uninstall scripts and documentation.

DlssNrBridge.exe SHA-256:

d902dc89c6977a9012028844da6acd788a2386e2c1bb43da71fa805cd230a85f

The package does not contain AMD/NVIDIA runtime files, model weights, paid Lossless Scaling files, private config, profiles, or raw logs. RELEASE.json and CHECKSUMS.json carry the project artifact metadata.

The compatibility runtime exercised for this checkpoint was danielblnc/DLSS-NR-on-AMD v0.2.15 / build f47996ae; it is supplied separately.

Setup note

Fresh setup defaults to fixed 1280×720 processing. For the native path measured here, use:

.\Setup.cmd -NativeResolution 1

Limits

This preview does not establish 60 FPS native output, universal AMD compatibility, full hardware pixel equivalence across systems, end-to-end latency, or independent LSFG/display FPS.

See Performance, Verification, and Licensing for the current boundaries.

NR Auto Scale v0.1.0-pre.1 — experimental preview

Experimental preview of NR Auto Scale for Windows x64.

Download the ZIP, extract it outside the Lossless Scaling installation, close Lossless Scaling, and run Setup.cmd. Supply your own AMD compatibility proxy and NVIDIA NR runtime files; install the required HIP/runtime prerequisites described in the documentation.

• Native-resolution bridge mode is the default; no geometry upscaling is requested.
• Ctrl+Alt+F6 toggles NR, F7 decreases blend, and F8 increases blend.
• The README includes matching crops from a frozen 2560x1440 CS2 frame. Crops contain no account details and have no resizing or color edits.
• Native bridge pixels are verified. Automatic Scale/Unscale was tested with the earlier fixed-size path; the final native-resolution Lossless Scaling end-to-end test is incomplete. This is a preview for testing, not a stable release.
• Native neural jobs took about 63 ms each on the tested GPU. This is not recommended for competitive CS2.

The ZIP includes only this project's binaries, scripts, documentation, notices, and approved comparison crops. No paid Lossless Scaling application files, AMD/NVIDIA runtime DLLs, models, logs, settings, or personal files are included. Runtime licenses still apply; the project does not grant NVIDIA/AMD runtime permissions.