Hacker News

I think this is mainly so it can use the existing hooks for DLSS upscaling without requiring changes to the renderer, AMD is working on a comparable method which uses adapter networks to slot normals and material properties from the renderer into the diffusion model: https://gpuopen.com/learn/temporally-stable-generative-illum...

The official one seems to do, as well as other info from the engine (I think remember their mentioning LOD/UV map hints in one of the public demos, or articles, a few months back--or it might have been an Unreal Engine podcast)

Even relatively small RGB -> depth models are pretty good. Which kind of implies depth is well encoded in the RGB, and adding depth would not really reduce entropy, while costing bandwidth.

Well it's doing the same math as the original, apparently. Hard to do but makes enough sense.

With LLMs you can do whatever you want pretty much. I have upstream CUDA running llama.cpp under unmodified Nouveau on one of my boxes. Why? Well, why not?

I also have a modified Nouveau driver that, with the help of more and newer blobs, gets reclocking working for at least most of Pascal/GTX 10 series. I would love to try to upstream it but it desperately needs to be rewritten with that intent. Too much ugly garbage. Still, I wanted to know how possible it is. Possible, it turns out. Modern LLMs can blackbox analyze the real driver quite well, and debug the Falcons themselves. It's very interesting. People say coding is dead; I think it's probably not really true. However, it is certainly changing. I think someone less skilled than me could beat me to the punch with enough determination. That is interesting.

Given that you bring the weights from NVIDIA's DLSS. So basically, the repo contains reverse engineered machinery that produces the exact same output given the same model.

Claim != Reality most of the time

If done by a human, yes.

Nowadays it takes one well written prompt to a frontier LLM to produce something like this.

The load-bearing kind.

LLMs are really good at deobfuscating or even decompiling code.

Yes, see the numbers below. In most games, it's basically unusable if you want to play on 60 FPS or above unless you have a 5090.

The current implementation is more of a tech demo than a practical way to play games (+ officially it's available in 1 game). It's _fast enough_ to make some impressive YouTube videos but you most likely won't want to play anything with it yet.

Nvidia has stated that they're still working on improving the performance. No doubt future hardware generations will also include further hardware optimisations.

The potential for this kind of technology is pretty awesome, especially given that people have also found ways to add this to emulators.

Worth remembering it is running a single-step diffusion model working in pixel space to generate each frame, it's a technical feat in itself that people are even using the words "frames per second"

Yes the original is very expensive. It depends on the resolution and the GPU used:

RTX 5060: 9.9 ms at 1080p

RTX 5070: 10.2 ms at 1440p

RTX 5080: 13.7 ms at 2160p

RTX 5090: 8.2 ms at 2160p

Source: https://www.youtube.com/watch?v=3EfLjmdG29Q&t=600

The original does tend to reduce the FPS by half or more

probably, going by the reported massive performance hits

You think Jensen even thinks about the gaming market anymore?

Hope it will get a Linux port soon

But I thought Nvidia “loves open source” (they don’t) and they are now a supporter for open source and open weight models by acquiring Huggingface? (They don’t actually care)

But the line is drawn when it involves CUDA and any part of their closed source compilers (nvcc).

There are obvious reasons why they are closed source, but it’s becoming pointless since Deepseek have open sourced their AI compiler and compute libraries with DeepGEMM and eventually they will catch up.

that's essentially the whole thing

I assume this is meant to run with the weights people extracted from the latest NBA game, where it was first trialled.

> Isn't the mote that Nvidia has is they work with studios to generate the training data from the game, then they ship a model per game?

That was true for the very first version of DLSS, from DLSS 2 on the models have been universal - the per-game adjustments are done on the inference end by changing the effect intensity or masking out objects

They have a technical report on the neural rendering part of DLSS 5 which goes into it: https://research.nvidia.com/labs/adlr/files/DLSS5_Report.pdf

They used to ship one model per game but now there is a single model, however they still do minor updates to it presumably to fine-tune it on new games

I don't really understand why the weights aren't included... US law says they can't have a copyright, no? Maybe they're concerned about other countries or cautious about a litigious Nvidia.

>they ship a model per game?

They don't. Only DLSS 1 was trained specifically per each game.

> they ship a model per game?

there's no way that's true!?

I'm more upset about it being factually wrong, e.g. both mentions of "git-ignored" are absurd (why would you mention it if it's not in the repo?) and wrong (they are in the repo).

If you think about it, actually the author did write what they did (nothing), and also how it’s used (it isn’t).

Exactly. The code, whatever, it's for machines so I don't really care if it's by machines as long as it works. But if you can't even be bothered to think about the human-facing parts of your thing like docs and UX, I'm not really interested. It just feels cheap (in the bad sense) and offputting.

Agree.

I do feel like there's merit to having an open source implementation of anything, no matter who/what wrote it. I'm just hoping the results are validated well.

> what they did

bold of you to assume the code wasn't llm generated as well.

you think a human wrote the code? in a month? Do you think that's air you're breathing? might be time to challenge preconceptions

I'm fine with it

If the README is >90% AI generated and it is as long as a novel, I am not going to read it and will assume that the author did not read or write it either.

Unfortunately it is slop, beyond the comprehension of the author unless they are experienced with DLSS internals to explain it in depth.

"Am I the only one who feels a sense of disinterest in a project where the code is LLM-generated? Does the author not have time to code the project?"

This is how I feel about every single project announcement on HN recently, they are already bragging about models all over the place, why shouldn't they go full way down being replaced by the Borg?

Slop is a new language and you will learn it read it

Because this was most likely written entirely by an LLM?

The maanHimself repository appears to be 35 hours older than the aloshdenny one based on `created_at` from the GitHub API. maanHimself's `pushed_at` predates aloshdenny's `created_at` too.

That doesn't guarantee maanHimself is the original author, but it's looking likely.

Same exact commits at the same time as well, but different repository names and authors. What the hell?

bit-exact against the original )

just unsure who's original ))