DLSS 5 Mod Runs on RTX 30 GPUs, but Frame Rates Collapse

Nvidia Tom coverage now shows leaked DLSS 5 code running on RTX 30-series GPUs, despite frame rates falling as low as 2 FPS. Modders have crossed an important compatibility barrier, but they have not made the technology practical on Ampere hardware.

The experimental results create an uncomfortable contrast. DLSS built its reputation by improving performance, while this early neural rendering model can multiply frame times and introduce severe latency. Some high-end Ampere cards approach 40 FPS, but only under compromises that reduce base image quality.

This is not an official Nvidia release or a controlled benchmark suite. The software came from an early NBA 2K27 build, then passed through several community patches. The results nevertheless offer an unusually direct look at the hardware cost behind Nvidia's next rendering strategy.

The DLSS 5 leak has reached Ampere

Modders have made the experimental neural renderer execute on RTX 30-series hardware, but execution alone does not establish usable support.

The story began on August 26, 2026, when Renan Maniero identified a new Nvidia library inside the early-access PC build of NBA 2K27. The file was named nvngx_dlssnr.dll, with "nr" apparently referring to neural rendering.

Its presence did not prove that NBA 2K27 actively used DLSS 5. The game exposed no public neural rendering setting, and Nvidia had not announced it as a supported title. Still, the filename and contents gave developers something concrete to inspect.

Members of the RenoDX community soon injected the library into Remedy Entertainment's Control. RenoDX is a collection of modifications that can alter rendering pipelines in existing games. ReShade helped provide another layer for activating and controlling the experimental code.

That first implementation applied the model to character rendering rather than rebuilding each complete frame. Seven exposed controls reportedly adjusted properties including intensity, tone, style, and structure strength.

The initial version operated on RTX 50-series Blackwell hardware. Modders then patched incompatible CUDA binaries, which are compiled GPU programs, and made the library load on RTX 40-series Ada Lovelace cards.

A modder using the name Uncle Burrito told Tom's Hardware that the process involved identifying Blackwell-only binaries and replacing them with compatible versions. Tom's Hardware subsequently reported that it verified the Ada patch on an RTX 4080.

The RenoDX community then pushed the same experiment back another generation. Its patched library loaded on Ampere cards ranging from mobile RTX 3070 systems to high-end RTX 3090 desktops.

That progression matters because Ampere lacks native support for FP8, an eight-bit floating-point format used to accelerate neural network calculations. Newer architectures can process those operations more efficiently through dedicated hardware paths.

Nvidia has already acknowledged this architectural limitation in a related product. Its official DLSS 4.5 guidance says RTX 20 and RTX 30 GPUs lack native FP8 support. Nvidia warns that its newer transformer models therefore impose a heavier performance cost on those cards.

The community patch bypasses a software compatibility boundary. It cannot add execution units that Ampere lacks. This distinction explains why successful loading produced technically interesting screenshots alongside punishing frame rates.

The nvidia tom report should therefore be read as an experiment, not a compatibility announcement. Nvidia has not confirmed DLSS 5 support for RTX 30 hardware, released these patches, or validated the reported configurations.

Nvidia Tom results expose the performance cost

Most reported Ampere results fall far below playable performance, while the better outcomes depend on lower resolutions or visible image compromises.

The widest collection of tests appeared in the Ampere performance report. These were community submissions gathered from RenoDX discussions, not standardized laboratory benchmarks.

An RTX 3080 Ti reportedly ran Grand Theft Auto V between 20 and 30 FPS at 1440p. That performance might produce an acceptable visual demonstration, but it remains unsuitable for smooth play in a fast-moving action game.

Dying Light 2 reached roughly 40 FPS on an RTX 3080. The user also described the output as very noisy, illustrating how a frame-rate figure can hide serious image defects.

Hogwarts Legacy reached 30 FPS on an RTX 3090 in one test. The same game produced only 2 FPS on an RTX 3070 under another reported configuration.

Mortal Shell 2 ran at 34 FPS on an RTX 3080 Ti, but the output displayed shimmering. Ready or Not reached 30 FPS on an RTX 3080, while Neverness to Everness remained around 29 to 30 FPS on the same GPU class.

A mobile RTX 3070 produced 25 FPS in NBA 2K27 at 1080p with DLAA. DLAA applies neural anti-aliasing at native resolution rather than relying primarily on spatial upscaling.

Several results were much worse. Cyberpunk 2077 reportedly ran at 7 FPS on an RTX 3080 Ti. Deep Rock Galactic dropped from more than 130 FPS to 4 FPS on an RTX 3080 after the neural renderer was enabled.

That Deep Rock Galactic comparison represents roughly a 97% performance loss if the starting result was 138 FPS. However, the underlying community test lacks the controls required for a formal GPU comparison.

The settings, model selection, driver version, patch revision, internal resolution, and scene conditions were not documented consistently across submissions. Those omissions prevent direct comparisons between individual GPUs or games.

The most revealing high result came from Cyberpunk 2077. One user reached 41 FPS, but only after lowering the output resolution to 720p and selecting an ultra-performance upscaling preset.

Ultra-performance modes begin with fewer conventionally rendered pixels. The system then reconstructs a much larger portion of the final image. This reduces the initial graphics workload but places greater pressure on reconstruction quality.

The result captures the experiment's central contradiction. Users can recover some speed by removing base image information, then ask the neural model to restore fidelity afterward.

At some point, the trade becomes self-defeating. Lowering conventional quality enough to fund neural enhancement can produce noise, instability, lost detail, or additional latency.

The reported frame rates also do not capture responsiveness. A game running at 30 displayed FPS can still feel poor when frame delivery is uneven or input processing waits behind a long neural workload.

Tom's Hardware reported that frame times sometimes grew by a factor of ten. Frame time measures how long the system needs to produce each frame, so a sharp increase directly affects fluidity and latency.

That burden is especially damaging for interactive games. Neural lighting might improve skin, hair, fabric, and shadows, but those benefits become difficult to appreciate when camera movement feels delayed.

The nvidia tom findings consequently show two separate limits. Ampere struggles with raw inference throughput, and the experimental integration lacks the optimization needed to manage the workload efficiently.

The mod reveals why neural rendering needs newer hardware

DLSS 5 changes the purpose of Nvidia's AI graphics stack, moving from reconstructing performance toward generating visual properties inside each frame.

Traditional DLSS versions were sold primarily as performance tools. Super Resolution reconstructs a higher-resolution image from a lower-resolution input, while Frame Generation inserts additional frames between conventionally rendered ones.

DLSS 5 targets a different problem. Nvidia says its model accepts frame color and motion vectors, then adds more realistic lighting and material responses. Motion vectors describe how visible objects move between frames.

According to Nvidia's DLSS 5 overview, the model analyzes characters, hair, fabric, translucent skin, and environmental lighting. It can then modify properties such as subsurface scattering, which describes light moving beneath a material's surface.

This approach is closer to a controlled image transformation than ordinary resolution reconstruction. It tries to reinterpret existing pixels while preserving the scene's geometry and semantic structure.

Nvidia says the output remains grounded in the developer's 3D content. The company also provides controls for masking, intensity, and color grading, allowing artists to restrict where the model operates.

Those controls address a basic concern about generative graphics. A game cannot accept unpredictable changes to a character, object, competitive signal, or narrative detail each time it renders a frame.

Nvidia claims the model produces deterministic and temporally stable results. Deterministic means the same inputs should produce consistent outputs, while temporal stability means details should remain coherent across consecutive frames.

The leaked implementation has not independently established either claim. Noise and shimmering in community tests show that the patched model can still become unstable under unsupported conditions.

The computational cost is also fundamentally different from a conventional shader. A shader executes hand-written instructions for surfaces, lighting, or post-processing. The neural model performs inference across image data and scene signals.

FP8 support matters because lower-precision formats let compatible Tensor Cores process more neural operations within a given period. Ampere's inability to execute FP8 natively removes that advantage.

The library might translate or emulate unsupported operations using formats that Ampere can process. That workaround increases computational work, memory movement, or both.

The Ada patch demonstrated that software binaries also create compatibility barriers. RTX 40 GPUs support FP8, but the leaked build reportedly contained code compiled for Blackwell. Replacing those binaries allowed Ada hardware to run the model.

Ampere presents the more difficult case. A patch can replace a Blackwell-specific binary, but it cannot recreate Ada or Blackwell's native FP8 throughput in software.

The result resembles running a modern workload through a compatible but inefficient path. The operation succeeds, yet each frame spends too long inside the model.

This explains why the experiment pressures RTX 30 owners without establishing that their cards are suddenly obsolete. The hardware still performs its supported rendering tasks. It simply lacks an efficient path for this particular neural workload.

Nvidia previously extended transformer-based Super Resolution to every RTX generation. However, the company also lets older cards remain on the lighter DLSS 4 model when DLSS 4.5 imposes too much overhead.

DLSS 5 could follow a similar pattern with selectable models, reduced quality levels, or limited features. It could also remain restricted to architectures that meet Nvidia's performance targets.

The leaked DLL cannot answer that product question. It appears to be a pre-release build packaged for one game, with no guarantee that it contains final kernels, hardware paths, or quality presets.

Even Blackwell performance shows the software remains demanding. In an early Control performance test, an RTX 5070 Ti reportedly fell from 71 FPS to 35 FPS at 4K.

That result lacks complete settings and internal-resolution data. It nevertheless shows that native compatibility does not make the workload free.

Nvidia first demonstrated the technology using two RTX 5090 GPUs, according to Tom's Hardware. The company later described a distilled model capable of running on one GPU during a SIGGRAPH 2026 presentation.

Model distillation transfers behavior from a larger neural network into a smaller one. It can reduce the resources needed for inference, although the smaller model still requires suitable optimization and hardware.

The real contest is therefore not simply RTX 30 against RTX 50. It is Nvidia's visual ambition against the strict time budget of an interactive frame.

Compatibility does not equal official support

The leaked build reveals architectural possibilities, but its uncontrolled patches cannot predict Nvidia's final support list or launch performance.

Community modifications often answer whether software can execute. Product support requires a much higher standard involving stability, image consistency, driver validation, game integration, and acceptable performance.

The current DLSS 5 experiment fails several of those tests. Users must obtain an unofficial library, apply community patches, inject the model into games, and adjust controls that developers never shipped.

Different patch revisions can also produce different results. A new binary might improve one architecture while breaking another, and an altered model could change both performance and image quality.

The DLL came from an early-access game build rather than Nvidia's public SDK. It might contain debugging code, incomplete kernels, uncompressed resources, or narrow assumptions about one integration.

NBA 2K27's inclusion of the file does not establish that the game will ship with active DLSS 5 support. Developers sometimes package dormant libraries, test components, or assets before enabling a feature publicly.

The performance numbers require the same restraint. They show what particular users observed, but they do not establish a reliable RTX 30-series hierarchy.

An RTX 3090 result cannot be compared directly with an RTX 3070 result unless the game, scene, resolution, settings, model, and software environment match. Most available reports lack those controls.

Even the apparent 41 FPS ceiling does not represent a general Ampere maximum. It describes one Cyberpunk 2077 configuration at 720p with ultra-performance upscaling.

Image comparisons are equally difficult. Screenshots can reveal changes in skin, hair, shadows, or material response, but they cannot show temporal instability, input delay, or inconsistent frame pacing.

Compressed videos may hide fine noise while exaggerating contrast changes. Static captures can also make a more dramatic image look preferable even when it conflicts with the developer's intended lighting.

Artistic control remains a second source of uncertainty. Nvidia argues that masks and grading controls preserve creative direction. The leaked implementation places those controls in modders' hands rather than the original artists' workflow.

A neural renderer can make a face look more photographic while making it less faithful to the character design. It can create richer light transmission while changing the mood established by the game's lighting team.

This issue received attention after Nvidia's March reveal. Some early comparisons appeared to shift facial appearance or scene character, creating debate over whether the system enhanced art or replaced it.

The company says the model remains anchored to source content. Final games will need to demonstrate that claim across motion, different environments, diverse character designs, and prolonged play.

Performance also needs evaluation without relying on generated-frame totals alone. Multi Frame Generation can increase displayed FPS, but it cannot erase a slow base frame or restore responsiveness lost before generation.

A high output number can therefore coexist with poor controls. Reviewers will need base frame rate, generated frame rate, end-to-end latency, frame-time consistency, and image-quality comparisons.

The nvidia tom tests are useful because they expose this distinction early. Neural features cannot be judged through a single FPS counter, especially when reconstruction and frame generation affect different stages.

Security and licensing provide additional reasons for restraint. Pre-release DLL files and third-party patches do not carry the trust, update path, or validation of signed official releases.

Users should not treat a community demonstration as a recommended installation. The experiment is valuable evidence for technical analysis, but it remains unsupported software.

Most importantly, Nvidia has not announced an RTX 30-series support commitment for DLSS 5. The company has announced a fall 2026 launch and named several participating developers, including Bethesda, Capcom, Ubisoft, and Warner Bros. Games.

Its published game list includes Starfield, Hogwarts Legacy, Resident Evil Requiem, Assassin's Creed Shadows, and Neverness to Everness. Official launch integrations will offer far stronger evidence than the leaked DLL.

What Nvidia and RTX 30 owners should watch next

Three signals will determine whether the Ampere experiment becomes meaningful: Nvidia's support matrix, independent launch benchmarks, and official model options.

The first signal is Nvidia's final compatibility list. The company has confirmed that DLSS 5 will arrive in fall 2026, but its public announcement does not clearly promise support for every RTX generation.

Explicit RTX 30 support would weaken the conclusion that neural rendering requires a near-term hardware upgrade. It would indicate that Nvidia found a reduced model, alternate precision path, or acceptable quality setting for Ampere.

A Blackwell-only launch would strengthen the opposite conclusion. It would position architecture-specific neural acceleration as a more important dividing line than ordinary raster performance.

RTX 40 support would provide a revealing middle case. Ada offers native FP8 capabilities, and modders have already shown that replacing incompatible binaries can make the leaked model run on that generation.

The second signal is a controlled benchmark of a shipping game. Reviewers need matching scenes across RTX 30, RTX 40, and RTX 50 hardware, with every relevant setting documented.

That testing should separate native rendering, Super Resolution, neural rendering, and Frame Generation. Combining every DLSS feature into one result would conceal the cost of the new model.

Base frame rate and frame time deserve particular attention. A game that displays 80 generated FPS from a very slow base might look fluid in a video while responding poorly to player input.

Image quality must be assessed in motion. Reviewers should examine hair, skin, transparent materials, fine geometry, particles, menus, and rapid camera movement.

They should also test whether visual improvements survive lower-quality presets. The Ampere demonstrations suggest that reducing base fidelity can recover speed while introducing noise or instability.

Consistent gains at useful base resolutions would weaken the leaked build's bleak performance picture. Similar single-digit results would strengthen the case that the problem is architectural rather than developmental.

The third signal is Nvidia's model-selection strategy. DLSS 4.5 already gives older RTX owners the option to retain a lighter transformer model when newer FP8 models impose excessive overhead.

A comparable DLSS 5 structure could offer several neural rendering models. A smaller model might preserve selected material or lighting improvements without applying the full workload.

Nvidia might also expose per-object masks, quality levels, or architecture-specific presets. These controls would let developers spend neural compute where it creates the largest visible return.

A single heavy model would leave fewer options. It would make DLSS 5 support depend more directly on native inference throughput and strengthen Blackwell's hardware advantage.

There is also a broader product question. DLSS historically helped older cards extend their useful lives by trading spare AI capacity for higher output resolution or frame rates.

DLSS 5 reverses that expectation when used without compensating performance features. It spends substantial GPU time to improve lighting and materials, placing visual quality ahead of raw speed.

That change does not make the technology misguided. High-end PC gaming has always traded performance for features such as anti-aliasing, ray tracing, path tracing, and higher-quality shadows.

However, the trade must remain understandable and adjustable. Players need to know whether neural rendering costs 10%, 50%, or nearly the entire base frame rate on their hardware.

Developers also need predictable budgets. A feature that consumes most of the frame cannot simply be added after conventional graphics settings have already exhausted the GPU.

Official integrations may redesign settings around the model. Studios could reduce selected conventional effects, target specific objects, or reserve neural rendering for slower cinematic modes.

The current mod cannot perform that optimization because it injects an unfamiliar workload into games built without it. Its frame-rate collapse reflects both unsupported hardware and unsupported integration.

That qualification should prevent two premature conclusions. The leak does not prove that shipping DLSS 5 will perform this badly, and successful execution does not prove RTX 30 cards will receive official support.

For Ampere owners, the sensible question is not whether a patched DLL can load. It is whether Nvidia and game developers can deliver stable improvements without destroying responsiveness.

The nvidia tom experiment has already answered the narrower question. RTX 30 hardware can produce DLSS 5 output through community patches. The cost, for now, ranges from serious compromise to practical failure.

Watch Nvidia's final hardware list, then compare independent base-frame and latency tests in the first supported games. Those two checks will reveal whether this leak previewed a flexible graphics feature or exposed a firm architectural boundary.