A modern game image may contain geometry, textures, simulated
light, reconstructed pixels and details predicted by a neural network.
“Graphics” is no longer one act of drawing.
Press a button and a character turns. The camera swings, light slides
across a wall and reflections rearrange themselves in a puddle. The
screen may show millions of coloured pixels, thirty, sixty or more times
each second.
No artist has painted every one of those completed frames. Artists
designed the objects, materials, lighting and visual rules; the computer
assembles a new picture while you play.
Nvidia’s DLSS 5 has renewed an old argument in a new form. If
software predicts parts of an image rather than calculates every pixel
conventionally, is it still rendering — or has the machine begun to
redraw the artist’s work?
The question makes sense only after we understand how much invention
was already involved.
When the picture really
was a picture
Early video games used tiny grids of light. Hardware limitations
forced designers to build characters from simple shapes or sprites:
small bitmap images moved across a background.
Even then, the screen was an illusion made from rules. A sprite could
be reused, flipped or recoloured. Limited memory encouraged artists to
suggest more than they stored. A few blocks became an alien, a racing
car or a plumber because movement and context completed the idea in the
player’s mind.
As machines improved, sprites became larger and more detailed. Some
games used hand-drawn animation; others photographed models or actors
and converted them into digital frames. The computer still combined
prepared elements rather than photographing an actual world.
Turning a 3D world into
triangles
Most modern games describe scenes in three dimensions. Objects are
built from meshes, usually collections of triangles. Textures provide
surface colour and detail. Mathematical descriptions tell the system
whether a material should appear rough, metallic, transparent or
wet.
To place that world on a flat screen, the graphics processor projects
the geometry from the virtual camera’s point of view. Rasterisation
determines which screen pixels the triangles cover. Shaders calculate
colour using textures, lights, shadows and material properties.
This happens fast because graphics processors perform many similar
calculations at once. But shortcuts are everywhere. Objects far from the
camera use simpler models. Surfaces outside the view may not be drawn.
Reflections may come from prepared images rather than a complete second
rendering of the scene.
Real-time graphics has always been the art of spending limited
computation where the player will notice it.
Following the light
Ray tracing approaches the image from another direction. The computer
traces simulated rays through the scene to work out how light would
interact with surfaces.
Tracing enough rays can produce convincing reflections, shadows and
indirect light, but it is expensive. Cinema images can take minutes or
hours per frame. A game has milliseconds.
Real-time systems therefore trace a limited number of rays and
combine them with rasterised graphics. Denoising software estimates what
a clean image should look like from noisy samples. The apparently pure
calculation already includes reconstruction.
Rendering fewer pixels than
you see
Upscaling is another bargain. The game renders internally at a lower
resolution, then software constructs a larger image for the display.
A simple upscaler may interpolate between neighbouring pixels. More
advanced systems use information from several frames: motion vectors,
depth, previous images and a model trained to recognise how
high-resolution pictures usually relate to lower-resolution inputs.
Nvidia introduced Deep Learning Super Sampling, or DLSS, as a way to
use specialised hardware and neural networks for this reconstruction.
Later versions added frame generation, creating intermediate frames to
make motion appear smoother.
The benefit is performance. The graphics processor can spend less
time drawing the base image or use the saved capacity for more complex
lighting. The risk is error: shimmering edges, invented detail, delayed
response or an object that looks different from what the underlying game
produced.
What is new about DLSS 5?
DLSS 5, scheduled to launch on 3 September 2026, extends the idea
into what Nvidia calls 3D-guided neural rendering. Instead of only
enlarging an image or inserting a frame, the system uses scene
information to generate more of the final appearance.
Nvidia presents this as a way to achieve extremely rich lighting and
material detail at playable speed. Critics focus on the same capability
from the opposite side: if the model can alter faces, textures or small
design features, it may change the art rather than simply reproduce it
more efficiently.
Both descriptions point to the same boundary. Traditional rendering
asks the machine to calculate an image from explicit assets and rules.
Generative rendering permits a learned model to infer more of what the
completed image should be.
The boundary is not perfectly clean. Denoisers and temporal upscalers
already predict missing information. DLSS 5 makes the prediction more
visible and potentially more consequential.
Who gets to choose?
The practical answer to “who draws the picture?” is a chain of
authorship.
Artists create models, animations, textures and reference material.
Technical artists build shaders and pipelines. Engineers design the
renderer. The game engine decides what information is available.
Hardware executes the calculations. A trained model may reconstruct or
generate detail. The player chooses where to look and causes the next
frame to exist.
Problems arise when one link overrides another without consent or
clarity. A developer may welcome neural rendering as part of the
intended style. A player may prefer a slower but more stable native
image. A studio may dislike a driver-level feature that changes details
after the art has left the engine.
Useful evaluation therefore needs more than a frame-rate number. Does
the image remain temporally stable while moving? Are important details
preserved? Is input responsiveness acceptable? Can the feature be
disabled? Was the game designed and tested around it?
The picture was never
finished in advance
A video game is not a reel of images waiting to be projected. It is a
machine for producing images in response to action.
The history of game graphics is a history of increasingly clever
guesses: which pixels matter, which light paths can be skipped, which
detail can be borrowed from the previous frame and which absence the
player’s eye will forgive.
Generative rendering does not begin that story. It changes the
confidence and complexity of the guess — and makes authorship harder to
see.
Quick facts
- Rasterisation converts projected 3D geometry into screen
pixels. - Ray tracing simulates paths of light but is computationally
expensive. - Temporal upscaling combines a lower-resolution frame with
information from earlier frames. - Frame generation creates intermediate images; it does not increase
the rate at which the game processes input in the same way as native
frames. - Nvidia describes DLSS 5 as 3D-guided neural rendering.
The Knowledge Back Catalogue 
Leave a comment