GPU Architecture Explained: How Modern Graphics Cards Actually Render Frames

A modern graphics card does something remarkable: it takes a description of a 3D scene—positions of objects, properties of materials, positions of light sources—and produces a grid of 2D pixels representing how that scene would look from a particular viewpoint, several times every second. Doing this fast enough for interactive gaming (60–240 times per second) at 4K resolution requires extraordinary computational throughput and a specialised processing architecture fundamentally different from a CPU. Here’s how it actually works.

The CPU vs GPU Architecture Difference

CPUs are designed for latency-sensitive, sequential work. A modern CPU core can execute a complex instruction sequence, including branches, memory accesses, and dependency chains, with very low latency—optimised for single-threaded performance. A high-end desktop CPU has 16–32 cores, each capable of sophisticated out-of-order execution and branch prediction.

GPUs are designed for throughput over parallel, simpler work. An NVIDIA RTX 4090 has 16,384 CUDA cores—not cores in the CPU sense, but stream processors organised into Streaming Multiprocessors (SMs). Each individual CUDA core is much simpler and slower than a CPU core—it executes a single floating-point operation at a time without the sophisticated speculation and out-of-order execution logic of a CPU core. But there are thousands of them, running in parallel on thousands of threads simultaneously. The tradeoff: GPUs are extraordinarily good at applying the same operation to thousands of pieces of data at once; CPUs are better at complex, branchy, interdependent sequential logic.

Rendering 3D graphics is fundamentally a parallel task—computing the colour of each pixel is largely independent of every other pixel—which is why GPU architecture is well-matched to it.

The Rendering Pipeline: From Scene Description to Pixels

The traditional rasterisation rendering pipeline, which underlies most real-time 3D graphics, proceeds through several stages.

Geometry/Vertex Processing: 3D objects are represented as meshes of triangles, with each vertex having a position in 3D space. The vertex shader stage transforms these 3D positions using matrix mathematics: the game’s game world coordinates are transformed to view space (camera-relative coordinates), then to clip space (normalised device coordinates), projecting the 3D scene onto a 2D plane. Every vertex of every triangle in the scene goes through this stage—the GPU runs thousands of vertex shader instances simultaneously.

Rasterisation: Once triangles are projected into screen space, the rasteriser determines which screen pixels fall within each triangle and at what precise coordinates within that triangle. For each covered pixel, it generates a fragment—a candidate for contributing to that pixel’s final colour, with interpolated attributes (UV texture coordinates, normals, vertex colours) derived from the triangle’s vertices.

Fragment/Pixel Shading: This is where most of the visible complexity of rendering happens. The fragment shader runs once for each fragment, computing that fragment’s colour based on: its surface material properties (read from textures—images mapped onto surfaces), the surface’s orientation (normal vector), the positions and types of light sources, and the view angle. A realistic fragment shader evaluates physically-based rendering equations—accounting for diffuse reflection, specular highlights, ambient occlusion, shadows—to produce a colour that approximates how that surface point would look under those lighting conditions.

Modern games run fragment shaders that are hundreds of instructions long, executing on millions of fragments per frame. The GPU’s massive parallelism is what makes this practical: the RTX 4090 can execute over a hundred trillion floating-point operations per second (TFLOPS) to handle this workload at 4K/60fps.

Depth Testing and Output: Multiple fragments may cover the same pixel (from overlapping triangles at different depths). Depth testing determines which fragment is closest to the camera and therefore visible, and only that fragment’s colour is written to the final framebuffer.

Ray Tracing: A Different Approach

Rasterisation is fast and produces excellent results with artistic tricks (shadow maps, screen-space ambient occlusion, fake reflections). But it’s an approximation—it doesn’t directly simulate how light physically behaves. Ray tracing does.

In ray tracing, for each pixel, rays are cast from the camera position through that pixel into the scene. Where each ray intersects a surface, further rays are cast: a shadow ray toward each light source (to determine if the point is in shadow), reflected rays (for mirror-like surfaces), refracted rays (for transparent materials). This recursive light path tracing computes physically accurate shadows, reflections, global illumination, and caustics—effects that rasterisation approximates with difficulty.

The challenge: ray tracing is computationally more expensive than rasterisation by a large margin. Efficiently determining where each ray intersects scene geometry requires a data structure called a Bounding Volume Hierarchy (BVH), and traversing this structure for each ray still requires substantial computation. NVIDIA’s RTX GPUs include dedicated RT (Ray Tracing) cores—fixed-function hardware that accelerates BVH traversal operations, making real-time ray tracing possible at playable frame rates for selective effects (reflections, shadows, global illumination) rather than replacing rasterisation entirely.

DLSS, FSR, and AI Upscaling

One of the most significant changes in rendering over the past five years is the rise of AI-based upscaling. Rather than rendering natively at 4K (very expensive), games render at a lower resolution (1440p, 1080p) and apply an AI neural network that upscales the image to 4K using temporal information from previous frames. NVIDIA’s DLSS (Deep Learning Super Sampling) and AMD’s FSR (FidelityFX Super Resolution) do this in different ways—DLSS uses a trained neural network running on NVIDIA’s Tensor Cores; FSR uses a spatial scaling algorithm without a neural network—and both can produce output comparable to native resolution at substantially lower rendering cost.

DLSS and similar technologies have changed the performance economics of modern gaming significantly: games that would require a flagship GPU to run at 4K native can run at 4K DLSS quality on a mid-tier GPU, with minimal visual difference in motion. This is genuinely important for making high-quality rendering accessible at non-flagship hardware, and represents a direction of travel—AI-assisted rendering—that will likely continue to expand.

The GPU as General Compute Platform

The same massive parallel floating-point compute capability that makes GPUs exceptional at rendering also makes them powerful for general parallel computation: training neural networks, scientific simulation, video encoding, physics simulation, and AI inference. The current AI training boom is built largely on GPU clusters—NVIDIA’s H100 and H200 datacenter GPUs are the same architecture as gaming GPUs but optimised for compute throughput and different memory configurations. The rendering-focused consumer GPU and the AI-training datacenter GPU share the same fundamental architecture because the workload—massive parallel floating-point computation on independent data—is the same.