How Graphics Cards Render 3D Games: Rasterization vs Ray Tracing

A graphics card is not one processor. It is thousands of small processors, dedicated texture samplers, ray-tracing accelerators, and a fast strip of dedicated memory, all working through a fixed sequence of steps roughly 60 to 240 times per second. Understanding how a GPU actually renders a frame — from CUDA cores to VRAM bandwidth to the pipeline stages in between — explains why a $2,000 graphics card exists, why frame rates crater in some games and not others, and why "more cores" alone does not tell the whole story of GPU performance.

Key takeaways

• GPUs are built for parallelism, not speed per instruction: a modern flagship GPU has more than 20,000 small arithmetic cores, compared to a CPU's 8 to 32 large ones, because every pixel on screen needs the same math applied to different data.
• The rendering pipeline is a fixed assembly line: vertices, then rasterization, then pixel shading, then depth testing, then output — each stage feeds the next, and a bottleneck anywhere slows the whole chain.
• VRAM bandwidth, not just capacity, decides performance: the RTX 5090's 32 GB of GDDR7 moves data at up to 1,792 GB/s across a 512-bit bus, which matters as much as the raw core count.
• Ray tracing and rasterization are not rivals anymore — they are combined: nearly every modern AAA game uses rasterization for the base image and ray tracing for specific effects like reflections and shadows.
• AI upscaling changed what "rendering resolution" even means: DLSS, FSR, and XeSS let a GPU render at a fraction of the output resolution and reconstruct the rest, shifting the performance conversation from raw pixel-pushing to intelligent reconstruction.

What a GPU actually is: architecture built for parallelism

Central Processing Units (CPUs) are engineered for sequential, branching workloads — the unpredictable, logic-heavy computation behind operating systems, spreadsheets, and game AI decision trees. A modern desktop CPU, like AMD's Ryzen 9000 series or Intel's Core Ultra 200 series, has somewhere between 8 and 24 cores, and each core is a small marvel of engineering: out-of-order execution, branch prediction, deep instruction pipelines, and large private caches, all built to push a handful of complex instruction streams through as fast as possible.

Graphics Processing Units solve a completely different problem. NVIDIA's RTX 5090, built on the Blackwell architecture and launched in January 2025, packs 21,760 CUDA cores across 170 streaming multiprocessors (SMs) on its GB202 die, according to NVIDIA's own product specifications. AMD's competing flagship RDNA architecture uses "stream processors" as its equivalent unit. Both are small, simple arithmetic units, stripped of most of the branching and prediction logic a CPU core carries, because they do not need it. They are built to execute the same instruction on thousands of different pieces of data at once — a model computer architects call SIMD (Single Instruction, Multiple Data), or more broadly, data-parallel computing.

Here is the analogy that makes this click: a CPU is a small team of elite chefs, each capable of cooking any dish on the menu from scratch, adapting on the fly if an ingredient is missing. A GPU is a factory floor with 20,000 line cooks, each one trained to do exactly one repetitive task — say, spreading sauce on a pizza — and given an identical pizza to work on at the same instant as everyone else. If you need one complicated dish, hire the chef. If you need 20,000 identical pizzas made in the next second, hire the factory floor.

That factory-floor model matches rendering almost perfectly. Every pixel on your screen runs through the same shader program — the same lighting math, the same texture lookups — just with different input data: a different screen position, different surface normal, different texture coordinate. Rather than computing pixels one at a time on a blazing-fast single core, the GPU computes thousands of pixels simultaneously on thousands of modest cores, and the aggregate throughput dwarfs what any CPU could manage for this specific kind of workload.

The RTX 5090's memory subsystem moves data at up to 1,792 GB/s across a 512-bit bus using 32 GB of GDDR7 — fast enough to transfer the entire contents of a 4K Blu-ray movie in roughly 30 milliseconds, according to [NVIDIA's official specifications](https://www.nvidia.com/en-us/geforce/graphics-cards/50-series/rtx-5090/).

What are CUDA cores, exactly?

CUDA cores (NVIDIA's term) or stream processors (AMD's term) are the basic arithmetic units of a GPU, each capable of executing simple floating-point or integer operations like addition and multiplication. A single core is weak on its own — thousands of them operating in lockstep on parallel data streams is where the power comes from, not the sophistication of any individual core.

GPUs also carry dedicated fixed-function hardware beyond the shader cores, each block specialized for one repetitive task rather than general-purpose computation:

Hardware block	Job	Why it is separate from shader cores
Texture units (TMUs)	Sample and filter textures from VRAM, performing bilinear and anisotropic filtering	Filtering math is repetitive and benefits from dedicated silicon rather than general shader cycles
Render Output units (ROPs)	Write final pixel colors to the framebuffer, handle blending and anti-aliasing	Output writes happen at a different rate than shading and would stall shader cores if shared
RT Cores (NVIDIA) / Ray Accelerators (AMD)	Accelerate bounding-volume-hierarchy traversal and ray-triangle intersection tests	Ray intersection math is geometrically distinct from pixel shading and needs its own pipeline
Tensor Cores (NVIDIA) / AI Accelerators (AMD)	Run matrix multiplications for AI upscaling (DLSS) and denoising	Neural network inference is a fundamentally different math operation (matrix multiply-accumulate) than pixel shading
Video encode/decode blocks	Fixed-function hardware for streaming, capture, and video playback	Encoding/decoding codecs like AV1 and H.265 have dedicated, unchanging algorithms better suited to fixed silicon than programmable shaders

Table: The specialized hardware blocks inside a modern GPU die, beyond the general-purpose shader cores.

This division of labor is why a graphics card is closer to a small factory than a single processor. Every block does one job extremely well, and the GPU's driver and game engine orchestrate how work flows between them, frame after frame.

The rendering pipeline: five stages, one assembly line

Rasterization has been the dominant rendering technique since the 3D graphics revolution of the 1990s, and it still forms the backbone of nearly every real-time game today, even ones that layer ray-traced effects on top. The pipeline runs in five broad stages, each one feeding the next.

Stage 1 — Vertex processing. The GPU receives triangle vertices from the CPU through a graphics API — DirectX 12, Vulkan, or Metal — via what is called a draw call. A vertex shader program transforms each vertex from 3D world space into 2D clip space using matrix multiplication, specifically the Model-View-Projection (MVP) matrix that accounts for the object's position, the camera's viewpoint, and the lens's field of view. This stage also computes per-vertex attributes like surface normals, tangents, and texture coordinates that later stages will need.

Stage 2 — Primitive assembly and rasterization. Transformed vertices are grouped back into triangles, then the GPU's rasterizer hardware determines exactly which screen pixels each triangle covers. For every covered pixel, it generates a "fragment" — a candidate pixel carrying interpolated data from the triangle's three vertices.

Stage 3 — Fragment (pixel) shading. Each fragment runs through a fragment shader, the program that decides its final color. This is usually the most computationally expensive stage. It involves sampling multiple textures (diffuse color, normal maps for surface bumps, roughness and metallic maps), then evaluating a Bidirectional Reflectance Distribution Function (BRDF) — the mathematical model describing how a given surface scatters incoming light. The Physically Based Rendering (PBR) BRDF used in virtually every modern AAA game takes roughness, metallicity, and albedo (base color) as inputs to produce materials that behave consistently under any lighting condition, which is why a PBR-authored gold surface looks correct whether it is under a bright sun or in dim torchlight.

Stage 4 — Depth testing. Every fragment is compared against the value stored in the depth buffer (also called the Z-buffer) at its exact pixel location. If the fragment sits behind something already drawn closer to the camera, it is discarded before its color is written — this is what prevents a wall from rendering in front of the character standing in front of it. Depth testing is cheap and happens constantly, which is why GPUs perform it early whenever possible, a technique called early-Z rejection that avoids wasting shader cycles on fragments that will be thrown away anyway.

Stage 5 — Output merger. Fragments that survive depth testing are written to the framebuffer, the final image buffer that eventually gets displayed on your monitor. Transparent objects, like glass or particle effects, get blended with whatever color is already behind them rather than simply overwriting it.

The fundamental limitation baked into this pipeline is that every triangle gets processed in isolation, with no built-in awareness of anything else in the scene. That makes global illumination — light bouncing realistically between surfaces — and physically accurate reflections genuinely hard to fake convincingly with rasterization alone. Developers have spent three decades compensating: pre-baked lightmaps computed offline, screen-space approximations like SSAO (screen-space ambient occlusion) and SSR (screen-space reflections), and cube-map reflections captured from fixed points in the scene. All of these are clever shortcuts, and all of them break down the moment the scene becomes dynamic — a screen-space reflection cannot show you something that is currently off-screen, no matter how good the algorithm is.

For a deeper look at how engines solve the lighting half of this problem specifically — lightmaps, light probes, and Unreal Engine 5's Lumen system — see how game engines render lighting.

How does a vertex shader differ from a fragment shader?

A vertex shader runs once per vertex and handles geometric transformation — moving points in 3D space to their correct 2D screen position. A fragment shader runs once per pixel-sized fragment and handles color and lighting. A character model might have 50,000 vertices but millions of fragments once rasterized across a 4K screen, which is why fragment shading, not vertex processing, dominates GPU workload in most modern games.

Ray tracing: simulating light instead of faking it

Ray tracing takes a fundamentally different approach: instead of projecting geometry onto a screen and shading it in isolation, it simulates how light actually propagates through a scene. For each pixel, one or more primary rays are cast from the virtual camera into the 3D world. When a ray hits a surface, the renderer can spawn secondary rays: shadow rays traveling toward light sources to test visibility, reflection rays bouncing off in the mirror direction, and refraction rays bending through transparent materials like glass or water.

Each individual ray test boils down to a geometric question: does this ray intersect any triangle in the scene? For a scene containing millions of triangles, testing every ray against every triangle one by one would take far too long for real-time rendering. The practical solution is a Bounding Volume Hierarchy (BVH), a tree data structure that nests geometry inside progressively larger bounding boxes. Ray traversal can eliminate entire branches of that tree in one check, so intersection testing scales roughly logarithmically with scene complexity instead of linearly — the difference between searching a sorted phone book and reading it cover to cover.

NVIDIA's RTX line, introduced with the Turing architecture in 2018, added dedicated RT Core hardware purpose-built to accelerate BVH traversal and ray-triangle intersection math. That dedicated silicon is what made real-time ray tracing viable for consumer hardware in the first place — without it, the same workload run purely on general-purpose shader cores would be dramatically slower. AMD followed with its own Ray Accelerators starting with RDNA 2 in 2020.

Modern AAA games almost universally use hybrid rendering: rasterization still handles primary visibility (deciding which triangle is closest to the camera at every pixel, since it is cheap and fast at that specific job), while ray tracing is reserved for specific, high-value effects where its physical accuracy actually shows up on screen:

• Ray-traced shadows — soft, physically correct penumbras from area lights, rather than the hard-edged or blurry approximations shadow maps produce
• Ray-traced reflections — correct reflections that can show geometry currently off-screen, something screen-space reflection techniques are structurally incapable of doing
• Ray-traced ambient occlusion — accurate contact shadows in corners and crevices where two surfaces meet
• Ray-traced global illumination — indirect light that bounces from a sunlit wall onto a shadowed floor, adding a layer of realism static lightmaps cannot replicate in dynamic scenes

Control (2019) by Remedy Entertainment was among the first shipped games to use real-time ray-traced global illumination as a signature feature. Alan Wake 2 (2023) pushed further still, using full path tracing — a more exhaustive, physically complete form of ray tracing that traces many light bounces per pixel — for its entire lighting model, making it one of the most computationally demanding games ever released at launch.

Why does ray tracing cost so much more performance than rasterization?

Even with dedicated RT Core hardware, every ray requires a BVH traversal followed by a triangle intersection test, and a single frame can require billions of these ray tests across shadows, reflections, and global illumination combined. The shading computation that follows each successful intersection adds further cost on top. Denoising — using relatively few rays per pixel and statistically filtering the noisy result into a clean image — mitigates the raw ray count needed but introduces its own processing overhead, which is part of why ray-traced games lean so heavily on AI upscaling to stay playable.

Inside the memory system: why VRAM bandwidth matters as much as capacity

Shader cores are only half the performance equation. A GPU is useless without a fast supply of data to feed those cores, and that is the job of VRAM — dedicated video memory physically mounted on the graphics card and connected to the GPU die through a wide, high-speed bus.

Modern flagship cards use GDDR7 memory, the current generation succeeding GDDR6X. According to JEDEC's published GDDR7 standard, the specification supports data rates up to 48 Gbps per pin and up to 192 GB/s of bandwidth per memory device at the high end, roughly double what the previous GDDR6 generation offered per module. The RTX 5090 pairs 32 GB of GDDR7 with a 512-bit memory bus, yielding a combined 1,792 GB/s of total memory bandwidth, according to NVIDIA's official specifications.

Why does that number matter so much? Every texture a game samples, every framebuffer write, every geometry buffer read has to move across this bus. Think of VRAM bandwidth as the width of a highway feeding a factory: you can have the fastest factory floor in the world, but if the delivery trucks can only arrive one lane at a time, production stalls regardless of how many workers you hired. A GPU with abundant shader cores but a narrow memory bus will bottleneck on data delivery long before it runs out of raw computational horsepower, particularly at high resolutions where every frame demands far more texture and framebuffer traffic.

Capacity and bandwidth solve different problems. VRAM capacity determines how much data — textures, geometry, shader programs, render targets — can sit resident on the card at once. Running out of capacity forces the system to page data over the much slower PCIe bus connecting the GPU to system RAM, an event that causes severe, often stutter-inducing performance drops rather than a gradual slowdown. Bandwidth, meanwhile, determines how fast that resident data can actually be read and written during a frame. A card can have generous capacity and still bottleneck on bandwidth if the bus is too narrow, which is one reason GPU manufacturers publish both figures separately rather than one composite "memory score."

GPU texture caches and compressed texture formats — BC7 for desktop GPUs, ASTC for mobile — reduce how much raw bandwidth is needed for a given visual quality level, buying headroom without requiring a wider physical bus. This is also why memory bus width (256-bit, 384-bit, 512-bit) has historically correlated closely with a GPU's market tier: wider buses require more physical die area and package pins, making them expensive to include on budget cards.

Triangle counts, draw calls, and the real bottlenecks

A "triangle count" describes how many triangles make up a 3D model — more triangles generally means finer geometric detail, sharper silhouettes, and smoother curves. Modern game character models commonly range from 50,000 to 200,000 triangles, while environment assets span from a few hundred triangles for a simple background rock up to millions for detailed hero assets, particularly in engines using Unreal Engine 5's Nanite virtualized geometry system, which can stream in triangle-dense meshes without the traditional performance penalty of high polygon counts.

Raw triangle count, however, is rarely the primary bottleneck in a modern game. The real performance limiters tend to live elsewhere in the pipeline:

Draw calls. Every distinct mesh rendered requires the CPU to issue a command instructing the GPU what to draw and how. A busy scene with thousands of objects can generate tens of thousands of draw calls per frame, which can saturate the CPU-to-GPU command bus long before the GPU itself is maxed out. Modern low-overhead APIs like Vulkan and DirectX 12, along with techniques such as instanced rendering (drawing many copies of the same mesh in a single call) and bindless textures (letting shaders reference textures without a separate binding command per draw), dramatically reduce this overhead compared to older APIs like DirectX 11.

Texture bandwidth. Sampling high-resolution textures from VRAM is bandwidth-intensive, and a single 4K scene might reference dozens of separate 4K texture maps across all its materials. This is where the texture caches and compressed formats mentioned above earn their keep.

Shader complexity. Fragment shaders performing many texture samples and elaborate lighting calculations can bottleneck the shader cores directly, independent of geometry or memory concerns. Games with layered material systems — cloth that shows both a base fabric texture and a dirt overlay, for instance — require careful shader budget management to avoid tanking frame rate in scenes where many such materials appear on screen simultaneously.

Fill rate. This measures how many pixels the GPU can shade and write per second. High output resolutions combined with expensive fragment shaders can exhaust fill rate even when there is plenty of triangle-processing headroom left over, which is part of why 4K gaming demands so much more GPU horsepower than 1080p even on identical geometry.

Understanding these four separate bottlenecks matters because they respond to completely different fixes. A draw-call-bound game benefits from a faster CPU or better batching in the engine; a fill-rate-bound game benefits from a faster GPU or lower resolution; throwing more VRAM at a shader-complexity problem accomplishes nothing. Diagnosing which bottleneck is actually limiting a given game is the entire premise behind GPU profiling tools like NVIDIA Nsight and AMD's Radeon GPU Profiler.

DLSS, FSR, and XeSS: rendering less and reconstructing more

Perhaps the most consequential graphics technology of the 2020s is not about improving rendering quality directly at all. It is about rendering fewer pixels and using intelligent reconstruction to fill in the rest.

NVIDIA DLSS (Deep Learning Super Sampling) uses a neural network, trained on a large dataset of high-resolution reference frames, to reconstruct a 4K image from a lower-resolution input — often 1080p or even lower. The Tensor Cores present on RTX GPUs run this inference in real time, typically well under a millisecond per frame. Temporal accumulation, which uses per-pixel motion vectors to reproject useful information from previous frames, sharpens edges and recovers fine detail that a single low-resolution frame alone could not provide. DLSS 3 introduced Frame Generation, which synthesizes entirely new intermediate frames using optical flow estimation rather than traditionally rendering them, which can substantially raise the displayed frame rate, though it is important to note that generated frames are interpolated rather than independently rendered, meaning input responsiveness does not scale the same way displayed frame rate does.

AMD FidelityFX Super Resolution (FSR) targets the same broad goal without relying on proprietary machine learning hardware for its earlier versions, using spatial and temporal upscaling algorithms that run on effectively any modern GPU, including competitors' hardware. FSR 4 introduced a machine-learning-based model more directly comparable to DLSS, following the same industry trend toward AI-driven reconstruction.

Intel XeSS applies machine learning on Intel Arc GPUs while falling back to a non-ML algorithmic path when running on other vendors' hardware, giving it the broadest hardware compatibility of the three approaches at the cost of some quality on non-Intel cards.

These technologies have quietly redefined what "native resolution" even means in a marketing and technical sense. Many developers now design their target performance budget around rendering at 60 to 70 percent of the intended output resolution, relying on an upscaler to reconstruct the remainder — a genuine shift in how rendering performance gets budgeted at the engine level, not just a cosmetic feature toggle in the settings menu.

What people get wrong about GPUs

A persistent misconception is that a graphics card's "core count" alone tells you how fast it is. It does not, for the same reason that a factory with 20,000 workers is not automatically twice as productive as one with 10,000 — it depends on how well those workers are fed with material (memory bandwidth), how efficiently they are organized (architecture and clock speed), and what kind of work they are being asked to do (rasterization versus ray tracing versus AI inference draw very differently on the same silicon).

Another common mix-up is treating "GPU" and "graphics card" as interchangeable, when they describe different things. A GPU is the processing die itself, the silicon chip containing the shader cores, texture units, RT cores, and ROPs. A graphics card is the entire assembled product: the GPU die, the VRAM chips, the power delivery circuitry, the cooling solution, and the physical board connecting them all. NVIDIA and AMD design and manufacture GPUs, while board partners like ASUS, MSI, Gigabyte, and Sapphire design and sell the complete graphics cards built around those chips, which is why the same GPU can appear across dozens of differently priced, differently cooled cards from different manufacturers.

A third confusion involves VRAM: more capacity is not automatically better if bandwidth cannot keep pace, and conversely, extreme bandwidth is wasted if a card lacks enough capacity to hold a game's assets in the first place. Both numbers matter together, not independently, and neither one alone predicts real-world performance.

Finally, many players assume ray tracing has simply replaced rasterization outright. It has not, and given the performance cost, it likely will not fully replace it for years. What has actually happened is hybridization: rasterization remains the workhorse for primary visibility because it is fast and mature, while ray tracing gets deployed surgically for the specific effects — reflections, shadows, global illumination — where its physical correctness delivers a visible improvement that screen-space tricks structurally cannot match.

The takeaway

A graphics card renders a game through a strict division of labor: thousands of small parallel cores handle repetitive per-pixel math, dedicated hardware blocks handle specialized tasks like texture filtering and ray intersection, and a wide, fast memory bus keeps all of it fed with data. Rasterization remains the fast, practical backbone of real-time rendering, while ray tracing adds physically accurate light behavior in the specific places where it is worth the cost. The next leap in performance is not coming primarily from adding more cores anymore — it is coming from smarter use of the cores already there, through AI-driven reconstruction techniques that render fewer pixels and intelligently predict the rest.

FAQ

Q: What is the difference between a GPU and a graphics card? A: A GPU is the chip itself — the processing die containing shader cores, texture units, and ROPs. A graphics card is the complete board including the GPU, VRAM, cooling, and power delivery circuitry. NVIDIA and AMD design the GPUs; partners like ASUS, MSI, and Gigabyte manufacture the boards.

Q: Why does ray tracing hurt performance so much? A: Even with RT Core hardware, each ray test requires BVH traversal and triangle intersection math, and a single frame might require billions of ray tests across shadows, reflections, and global illumination. The shading computation that follows each intersection adds further cost, and denoising the resulting noisy image introduces its own overhead on top.

Q: What is VRAM and why does it matter for gaming? A: VRAM (video RAM) is memory physically mounted on the graphics card, connected to the GPU via a high-bandwidth bus, often 256 to 512 bits wide. Games store textures, framebuffers, geometry, and shader code in VRAM. Insufficient capacity forces data to page over the much slower PCIe bus, causing severe stutter, while insufficient bandwidth bottlenecks how fast that data can move even when capacity is plentiful.

Q: How many CUDA cores does a modern flagship GPU have? A: NVIDIA's RTX 5090, launched in January 2025 on the Blackwell architecture, has 21,760 CUDA cores across 170 streaming multiprocessors, according to NVIDIA's official specifications. That is roughly 33 percent more than the previous-generation RTX 4090's 16,384 CUDA cores.

Q: What is a draw call, and why do too many of them slow a game down? A: A draw call is a command the CPU sends instructing the GPU what to render. Each one carries overhead to issue and process, so a scene with thousands of separate objects can generate tens of thousands of draw calls per frame, saturating the CPU-to-GPU command bus even if the GPU itself has spare capacity. Techniques like instanced rendering and bindless textures, available in modern APIs like Vulkan and DirectX 12, reduce this overhead substantially.

Q: What is frame rate and why does it feel different at higher numbers? A: Frame rate (fps) measures how many frames the GPU renders per second. Higher frame rates feel smoother partly because the time between a player's input and the resulting visual feedback shrinks, and partly because motion between consecutive frames becomes less abrupt. For a full breakdown of why this perceptual difference is so pronounced, see why frame rate changes game feel.

Q: What is tessellation, and is it still used? A: Tessellation is a GPU pipeline stage that subdivides triangles into smaller triangles at render time, letting a low-polygon base mesh gain fine geometric detail up close — a flat plane can become bumpy terrain by displacing tessellated vertices with a height map. It balances memory efficiency (a small base mesh) against visual quality (detail near the camera), though many modern engines increasingly rely on Nanite-style virtualized geometry for similar goals.

Q: Does a graphics card handle physics simulation as well as rendering? A: Rendering and physics are generally separate workloads. Physics — collision detection, rigid body motion, cloth simulation — traditionally runs on the CPU, though some engines offload specific physics calculations, like particle systems, to the GPU using compute shaders. For a deeper look at how that separate system works, see how video game physics engines simulate motion.

Q: Why do two graphics cards with the same core count perform differently? A: Core count alone does not determine performance. Clock speed, memory bandwidth, architecture generation (a newer architecture often does more work per core per clock cycle than an older one), and how well a given game's workload matches the card's specific strengths in rasterization, ray tracing, or AI inference all factor in. This is why comparing two GPUs by core count alone, without accounting for architecture and memory bandwidth, is unreliable.

Q: What is the BVH and why does ray tracing depend on it? A: A Bounding Volume Hierarchy is a tree structure that nests scene geometry inside progressively larger bounding boxes, letting a ray traversal eliminate large portions of a scene from consideration with a single check rather than testing every triangle individually. Without it, ray tracing a scene with millions of triangles in real time would not be computationally feasible even with dedicated RT Core hardware.

Q: Do AMD and Intel graphics cards use ray tracing the same way NVIDIA does? A: The underlying principle is the same — casting rays and testing intersections via a BVH — but the dedicated hardware differs by name and generation. AMD calls its equivalent hardware Ray Accelerators, introduced with RDNA 2 in 2020, while Intel's Arc GPUs include their own ray-tracing units. Performance and feature support vary by generation and vendor, but all three approaches rely on the same core geometric technique.

---

Read next:

• How Game Engines Render Lighting
• Why Frame Rate Changes Game Feel
• How Video Game Physics Engines Work: Simulating Motion
• History of Video Game Graphics: From Pong to Photorealism