O projeto DLSSNR-AMD roda DLSS 5 na RX 9070 XT por meio de uma nova implementação em Vulkan criada especificamente para placas Radeon RX 9000 com arquitetura RDNA 4. O desenvolvedor mochizuki0323 tornou o código público em 24 de setembro de 2026 e apresentou testes em jogos reais no Linux, incluindo Dying Light: The Beast, 7 Days to Die e Tomb Raider (2013).

Nos resultados publicados pelo autor, Dying Light: The Beast alcançou 56 FPS em saída 4K usando FSR 4 Performance e Neural Rendering antes do upscaler. O teste não utilizou Frame Generation. Quando o projeto executou a mesma rede neural depois do upscale, diretamente em 4K, o desempenho caiu para 27 FPS.

A diferença ajuda a demonstrar por que o chamado Pre-SR ganhou importância nos experimentos com DLSS 5. Em vez de executar a rede neural na resolução final de 3840 × 2160, o sistema pode processá-la na resolução interna do jogo e deixar o FSR 4 realizar posteriormente o upscale para 4K.

DLSSNR-AMD reimplementa o Neural Rendering do DLSS 5 em Vulkan

O DLSSNR-AMD possui código-fonte aberto no GitHub e reimplementa a rede de Neural Rendering do DLSS 5 como compute shaders Vulkan.

O projeto utiliza extensões como VK_KHR_cooperative_matrix e VK_EXT_shader_float8. Na arquitetura RDNA 4, essas operações podem utilizar as instruções de matriz FP8 disponíveis no hardware.

Além disso, o código procura reproduzir a precisão utilizada pelo modelo original. O desenvolvedor usa FP8 nos pontos em que identificou operações FP8 no runtime da NVIDIA e mantém FP16 ou FP32 nas demais etapas.

No entanto, o próprio projeto ressalta uma limitação importante: a saída visual fica próxima ao resultado da NVIDIA, mas não é numericamente idêntica.

Portanto, o DLSSNR-AMD não deve ser confundido com uma execução oficial do DLSS 5 em placas Radeon. Trata-se de uma reimplementação independente da rede neural.

O projeto também não possui vínculo ou suporte da NVIDIA ou da AMD.

O que muda em relação aos outros projetos de DLSS 5 em placas AMD?

Esta não é a primeira demonstração de Neural Rendering do DLSS 5 em uma Radeon. Outros projetos já executaram a rede em GPUs AMD por caminhos diferentes.

Por exemplo, o projeto DLSS-NR-on-AMD, de Daniel Balanescu, desenvolveu um runtime próprio para placas Radeon e avançou anteriormente em testes com RX 9070 XT e outras GPUs.

Já o DLSSNR-AMD segue outra arquitetura. Em vez de utilizar HIP como backend principal, ele executa a rede diretamente por meio de Vulkan.

Essa diferença se torna especialmente importante no Linux. Jogos DirectX executados pelo Proton já passam por uma camada Vulkan através de tecnologias como DXVK e vkd3d-proton.

Assim, o DLSSNR-AMD consegue inserir o processamento neural no mesmo dispositivo Vulkan que o jogo já utiliza.

Segundo a documentação técnica da arquitetura, o sistema registra os shaders da rede no fluxo de comandos da própria GPU. Dessa forma, ele evita transportar cada quadro até uma API de computação separada e depois copiá-lo novamente para o pipeline gráfico.

Esse desenho também explica por que o desenvolvedor escolheu Vulkan em vez de HIP/ROCm para a versão Linux.

Como o DLSSNR-AMD funciona dentro dos jogos?

O projeto oferece diferentes caminhos de integração conforme a API gráfica e os recursos do jogo.

Em jogos DirectX 11 ou DirectX 12 que já oferecem DLSS, FSR ou XeSS, o usuário pode utilizar o OptiScaler-NR. Nesse modo, o sistema aproveita informações reais fornecidas pelo motor gráfico, incluindo os vetores de movimento.

Por outro lado, jogos DirectX 10, 11 ou 12 que não possuem um upscaler compatível podem usar a rota baseada em ReShade.

O projeto também oferece caminhos para Vulkan e DirectX 9:

• DirectX 12 com DLSS, FSR ou XeSS: OptiScaler-NR no Linux.
• DirectX 11 com DLSS, FSR ou XeSS: OptiScaler-NR no Linux.
• DirectX 10, 11 e 12 sem upscaler: ReShade.
• Vulkan: ReShade carregado como camada Vulkan.
• DirectX 9: DXVK converte o jogo para Vulkan, enquanto o ReShade funciona como camada Vulkan.
• OpenGL: ainda não possui suporte.

Além disso, a versão Linux oferece pacotes para jogos de 32 bits por meio da arquitetura i686. Nesse caso, porém, a rota do OptiScaler não funciona.

A versão para Windows permanece limitada a aplicações de 64 bits.

Pre-SR leva Dying Light: The Beast a 56 FPS em saída 4K

Os testes de Dying Light: The Beast mostram uma das diferenças mais interessantes do novo projeto.

O desenvolvedor configurou o jogo para saída em 4K com FSR 4 no modo Performance. Nesse cenário, o jogo renderiza internamente em 1080p e depois amplia a imagem para 3840 × 2160.

Sem Neural Rendering, o autor registrou 97 FPS.

Quando o sistema executou a rede neural depois do FSR 4, portanto sobre uma imagem em 4K, o desempenho caiu para 27 FPS.

Entretanto, o Pre-SR alterou significativamente o resultado. Com a opção “Generate model before upscaler”, o OptiScaler-NR executou o modelo na imagem interna de 1080p antes do FSR 4.

Nessa configuração, o jogo atingiu 56 FPS.

Assim, os resultados publicados ficaram desta forma:

Nenhum desses números utiliza Frame Generation. Portanto, os 56 FPS do teste com Pre-SR representam os quadros produzidos pelo pipeline de renderização, sem multiplicação posterior de frames.

Por que executar o Neural Rendering antes do upscale melhora tanto o desempenho?

A explicação principal está na quantidade de pixels que a rede neural precisa processar.

Quanto maior a resolução, maior fica o custo computacional da inferência. Por isso, executar o modelo em 4K exige muito mais trabalho do que processar uma imagem em 1080p.

O benchmark isolado da rede na RX 9070 XT mostra claramente essa progressão.

Esses números medem somente a execução da rede neural. Portanto, eles não correspondem ao frametime completo de um jogo.

Ainda assim, a diferença mostra por que o Pre-SR oferece uma vantagem tão grande nos testes publicados. Em 1080p, a rede consome 6,2 ms no benchmark Linux. Já em 4K, o custo sobe para 23,5 ms.

Por isso, o pipeline pode economizar muito tempo quando executa o Neural Rendering antes de ampliar a imagem.

Depois disso, o FSR 4 assume a tarefa de reconstruir a resolução final.

7 Days to Die também praticamente dobra o desempenho com Pre-SR

O desenvolvedor encontrou um padrão semelhante em 7 Days to Die.

Com saída 4K e FSR 4 Performance, o jogo registrou 136 FPS sem Neural Rendering.

Em seguida, o autor executou a rede neural na resolução final de 4K. O desempenho caiu para 29 FPS.

Já o Pre-SR executou o modelo em 1080p antes do FSR 4 e elevou o resultado para 68 FPS.

Portanto, nesse teste específico, reduzir a resolução usada pela rede aumentou o desempenho de 29 para 68 FPS.

O resultado não significa que o Pre-SR sempre produzirá exatamente o dobro dos FPS. Outros jogos, configurações gráficas, processadores e versões de driver podem apresentar diferenças consideráveis.

Mesmo assim, os três jogos testados pelo autor mostram a mesma tendência: processar a rede abaixo da resolução final reduz significativamente seu custo.

Tomb Raider mostra o mesmo efeito ao reduzir a resolução do modelo

O desenvolvedor também utilizou Tomb Raider, de 2013, para testar a relação entre resolução neural e desempenho.

Nesse caso, o jogo atingiu 130 FPS sem Neural Rendering.

Com a resolução do modelo configurada em 100%, ou seja, 4K, o resultado caiu para 30 FPS.

Por outro lado, ao configurar o modelo em 50%, equivalente a 1080p nesse teste, o jogo alcançou 60 FPS.

Assim, Tomb Raider também dobrou a taxa de quadros registrada pelo autor quando a rede deixou de trabalhar diretamente em 4K.

Os números dos três jogos formam um padrão consistente dentro da configuração testada, embora ainda não exista uma reprodução independente ampla desses benchmarks.

RX 9070 XT é a única placa testada até agora

O DLSSNR-AMD exige atualmente uma Radeon RX 9000 baseada em RDNA 4.

Segundo a documentação, placas RX 7000 e gerações anteriores não oferecem as instruções de matriz FP8 que esta implementação utiliza.

Além disso, o desenvolvedor realizou os testes apenas em uma Radeon RX 9070 XT.

Portanto, o suporte técnico à família RX 9000 não significa que o autor já tenha validado todas as placas da geração.

O ambiente principal de testes utiliza:

• GPU: Radeon RX 9070 XT.
• Sistema: Linux.
• Driver: Mesa 26.2.
• Compatibilidade: GE-Proton 11-7.

O projeto ainda está na série 0.0.x. Consequentemente, o próprio autor alerta para possíveis travamentos, artefatos, incompatibilidades e resultados diferentes em outras máquinas.

Versão Windows existe, mas ainda apresenta problemas sérios

O repositório também contém uma implementação para Windows. No entanto, o desenvolvedor afirma claramente que ela ainda não está pronta para uso normal.

Primeiramente, os benchmarks isolados já mostram uma diferença de desempenho.

Em 1080p, a rede leva 6,2 ms no Linux e 9,4 ms no Windows. Já em 4K, o Linux registra 23,5 ms, enquanto o Windows sobe para aproximadamente 33 ms.

Além disso, a versão Windows precisa executar os jogos por meio de DXVK ou vkd3d-proton para criar o ambiente Vulkan necessário.

Isso pode alterar tanto o comportamento quanto o desempenho original do jogo.

O desenvolvedor também relata incompatibilidades com alguns títulos e overlays. Por enquanto, ele não fornece pacotes Windows pré-compilados; quem pretende testar precisa compilar o projeto.

Por isso, o Linux representa atualmente a plataforma principal do DLSSNR-AMD.

Projeto não distribui os pesos do DLSS 5

O repositório publica o código da implementação, mas não inclui os pesos da rede neural da NVIDIA.

Para instalar o sistema, o usuário precisa fornecer sua própria cópia do arquivo nvngx_dlssnr.dll versão 310.8.0.

Então, o instalador extrai o modelo localmente.

O processo verifica 599 entradas contra hashes conhecidos antes de gerar o arquivo final. Se alguma entrada não corresponder ao conjunto esperado, o instalador interrompe a operação.

Da mesma forma, o sistema rejeita DLLs de outras versões.

Quando a extração termina corretamente, o modelo resultante possui aproximadamente 140,9 MiB.

Assim, o repositório mantém os pesos proprietários fora do código distribuído publicamente.

DLSSNR-AMD não produz exatamente a mesma saída da NVIDIA

Outra diferença importante aparece quando o DLSSNR-AMD entra em comparação com o OpenDLSS-NR.

O OpenDLSS-NR também reimplementa a rede Neural Rendering do DLSS 5 em Vulkan. No entanto, seu desenvolvedor afirma reproduzir resultados bit-exact em relação às referências do runtime original.

Esse projeto utiliza, entre outras configurações, uma RTX 4070 SUPER para validar a execução.

Já o DLSSNR-AMD adota uma abordagem voltada diretamente para RDNA 4 e deixa claro que sua saída se aproxima da NVIDIA, mas não permanece idêntica bit a bit.

Portanto, os dois projetos compartilham parte do objetivo técnico, mas não devem ser tratados como implementações equivalentes.

Os 56 FPS em 4K não significam Neural Rendering processado em 4K

Esse detalhe merece atenção porque os números podem gerar uma interpretação incorreta.

Dying Light: The Beast realmente produz uma saída final de 3840 × 2160 no teste de 56 FPS.

No entanto, o Neural Rendering não trabalha sobre um frame 4K nessa configuração.

O jogo usa FSR 4 Performance e renderiza internamente em 1080p. O Pre-SR executa a rede neural nessa mesma resolução interna. Depois disso, o FSR 4 amplia o resultado para 4K.

Quando o desenvolvedor executa o Neural Rendering diretamente sobre o frame 4K, o resultado cai para 27 FPS.

Portanto, uma descrição mais precisa do teste seria: saída 4K com Neural Rendering em 1080p antes do FSR 4, a 56 FPS.

Essa diferença também mostra por que comparar somente a resolução final pode esconder uma parte importante do custo computacional.

Frame Generation não participa dos benchmarks publicados

O desenvolvedor afirma explicitamente que nenhum dos resultados apresentados utiliza geração de quadros.

O OptiScaler pode ativar Frame Generation em outras configurações. Contudo, o autor manteve esse recurso desligado nos números divulgados para o DLSSNR-AMD.

Assim, o teste permite comparar de forma mais direta o custo do Neural Rendering antes e depois do upscaler.

Isso também diferencia esses resultados de demonstrações nas quais Frame Generation eleva o contador final de FPS mesmo quando o pipeline base trabalha em uma taxa muito menor.

Vale testar o DLSSNR-AMD agora?

Para usuários com Radeon RX 9000 e Linux, o projeto já oferece uma base funcional para experimentos, especialmente para comparar Pre-SR e Neural Rendering na resolução final.

No entanto, o estágio de desenvolvimento ainda exige cautela.

O próprio autor testou apenas uma RX 9070 XT, uma configuração Linux e um conjunto pequeno de jogos. Além disso, o projeto ainda pode apresentar travamentos e artefatos.

No Windows, as limitações são maiores. Portanto, essa versão ainda funciona melhor como ferramenta experimental do que como solução pronta para uso cotidiano.

O desenvolvedor também recomenda explicitamente não utilizar a injeção em jogos online com sistemas anti-cheat. DLLs injetadas no processo podem provocar bloqueios ou até punições de conta.

Mesmo com essas limitações, o DLSSNR-AMD adiciona uma abordagem técnica relevante aos experimentos com DLSS 5 fora do hardware oficialmente suportado pela NVIDIA.

Além de executar a rede em jogos reais, o projeto publica o código, documenta sua arquitetura e apresenta números que separam o custo do processamento neural em 1080p, 1440p e 4K.

Os testes também reforçam uma tendência importante: executar Neural Rendering antes do upscale pode preservar uma parcela muito maior do desempenho.

No caso mais representativo divulgado até agora, Dying Light: The Beast passou de 27 FPS com a rede processada em 4K para 56 FPS quando o Pre-SR executou o modelo em 1080p antes do FSR 4 — ambos os resultados sem Frame Generation.

Fontes: DLSSNR-AMD — repositório e documentação oficial | DLSSNR-AMD — documentação da arquitetura Vulkan | mochizuki0323 — testes publicados no Reddit | OpenDLSS-NR — implementação Vulkan usada para comparação técnica.