A GPU works by splitting graphics and computation across thousands of small cores that run the same instruction on different data at the same time. A GPU, short for graphics processing unit, runs a rendering pipeline that turns 3D geometry into screen pixels, and it keeps its working data in dedicated high-bandwidth video memory. The defining trait is throughput: a GPU finishes a huge volume of identical calculations per second instead of finishing one complex task quickly the way a CPU does.
What Is a GPU?
A GPU is a processor built to execute many calculations in parallel for graphics and general computation:
- Core layout: thousands of arithmetic cores grouped into clusters, each running the same operation on different data at once.
- Vendor names: Nvidia calls them CUDA cores, AMD calls them Stream Processors, Intel calls them Xe vector engines.
- Where it lives: on a graphics card with its own dedicated video memory, or inside a CPU as an integrated graphics unit.
- Defining trait: throughput – a large volume of identical calculations per second, not one complex task finished fast.
The GPU began as a fixed-function chip for drawing 2D and 3D graphics, then became programmable, which let the streaming-multiprocessor architecture run general code as well as shaders.
How Does a GPU Differ From a CPU?
A GPU differs from a CPU in core count, core complexity, and the type of work each handles best – the GPU is throughput-optimized, the CPU is latency-optimized:
- CPU: a few large complex cores (4 to 24 on a desktop), each with high clock speed, big caches, and out-of-order execution to finish one task fast.
- GPU: thousands of small simple cores (about 2,000 to over 21,000) that drop out-of-order logic and large per-core cache to pack in density.
- CPU wins: serial, branch-heavy logic such as operating-system tasks and single-thread apps.
- GPU wins: data-parallel work such as shading millions of pixels with one instruction.
The split means the two cooperate rather than compete. The table below contrasts them across the dimensions that define their roles:
| Attribute | CPU | GPU |
|---|---|---|
| Core count | 4 to 24 desktop cores | 2,000 to 16,000+ shader cores |
| Core design | Large, complex, high clock | Small, simple, throughput-focused |
| Optimized for | Low-latency serial tasks | High-throughput parallel tasks |
| Clock speed | 3.0 to 6.0 GHz | 1.5 to 3.0 GHz |
| Cache per core | Large L1, L2, L3 | Small, shared across clusters |
| Best workloads | Logic, branching, OS, single-thread apps | Graphics, AI, simulation, parallel math |
How Does the Graphics Rendering Pipeline Work?
The rendering pipeline works by converting 3D geometry into 2D pixels through a fixed, ordered sequence of stages. Modern APIs (DirectX 12, Vulkan, OpenGL) define the stages, and the GPU runs each one across thousands of cores at once:
- Vertex shading. A vertex shader transforms every 3D vertex from model space through world, camera, and projection space into screen coordinates, and applies per-vertex lighting.
- Primitive assembly. Transformed vertices are grouped into triangles, the basic primitive every 3D surface is built from.
- Rasterization. Each triangle is converted into the set of covered pixel positions, called fragments, with depth and texture coordinates interpolated across the surface.
- Pixel (fragment) shading. A pixel shader runs once per covered fragment to compute its final color from textures, lighting, and material data, and can discard fragments.
- Output merging. Depth testing and blending resolve which fragment is visible, then the finished pixel is written into the frame buffer for display.
Because each stage runs in parallel, the GPU shades millions of pixels within a single frame and repeats the whole pipeline 60 or more times per second for real-time rendering. Ray-traced lighting and reflections add a separate tracing stage handled by dedicated RT cores on recent cards.
What Are Shader Cores (CUDA Cores and Stream Processors)?
Shader cores are the programmable arithmetic units that execute the shader programs of the rendering pipeline:
- Job: run floating-point and integer math on vertices, pixels, and general data.
- Brands: Nvidia CUDA cores, AMD Stream Processors, Intel Xe vector engines – the same idea under different names.
- Count: a flagship Nvidia RTX 5090 (Blackwell) holds 21,760 CUDA cores; a mid-range card holds roughly 3,000 to 9,000.
- Grouping: cores cluster into streaming multiprocessors (Nvidia) or compute units (AMD) – the RTX 5090 has 170 SMs of 128 cores each, detailed in the architecture explainer.
What Are RT Cores and Tensor Cores?
RT cores and Tensor cores are fixed-function units that accelerate ray tracing and AI math that the general shader cores handle slowly:
RT cores
Tensor cores
DLSS
These specialized cores sit alongside the shader cores on the same die; the GPU architecture explainer shows how they are wired into each streaming multiprocessor.
What Is the Role of VRAM in a GPU?
VRAM is the dedicated high-speed memory that stores the data a GPU needs to render each frame:
- Holds: textures, frame buffers, geometry, and intermediate render targets that the shader cores read and write.
- Standard: modern cards use GDDR7 (the RTX 50 generation), delivering hundreds to over 1,700 gigabytes per second of bandwidth.
- Capacity: from 8 GB on mainstream cards to 32 GB on a flagship RTX 5090 – this caps the resolution and texture detail the card sustains, as the video-memory guide explains.
- When it runs out: the card spills data to slower system memory, which causes stutter and frame-rate drops.
How Does GPU Memory Bandwidth Affect Performance?
GPU memory bandwidth affects performance by setting how fast the shader cores receive the data needed to keep working:
- The formula: bandwidth = memory clock x bus width x data rate, measured in gigabytes per second.
- Why it pairs with cores: thousands of shader cores starve if VRAM cannot supply texture and geometry data fast enough, so bandwidth and core count must scale together.
- Resolution scales it: 4K moves far more pixels per frame than 1080p, so it demands both more video-memory capacity and more bandwidth.
How Do GPUs Compute Beyond Graphics?
GPUs compute beyond graphics by running general-purpose parallel programs on their shader cores through compute APIs:
- GPGPU: general-purpose GPU computing sends non-graphics math to the GPU via Nvidia CUDA, OpenCL, and AMD ROCm.
- AI: the same parallel structure that shades pixels accelerates matrix multiplication, the core operation of deep learning, so GPUs train and run AI models far faster than CPUs.
- Other workloads: scientific simulation, video encoding, and physics all map onto the parallel cores.
- Data center: racks of GPUs train large language models and run inference, with Tensor cores handling the low-precision matrix math.
How Do GPUs Connect to the Rest of the System?
GPUs connect to the rest of the system through the PCI Express interface and a dedicated power feed:
- Slot: a discrete card plugs into a PCIe x16 slot; PCIe 5.0 carries up to about 64 gigabytes per second of bidirectional bandwidth.
- Data path: the CPU sends draw calls and game logic across the link, the GPU returns finished frames – so the CPU cores and the card cooperate each frame.
- Power: the slot supplies 75 watts; a power-hungry card draws the rest through 8-pin or 12VHPWR connectors.
- Bottleneck: a CPU too slow to issue draw calls caps the frame rate no matter how powerful the GPU is.
Last Thoughts on How GPUs Work
How GPUs work comes down to parallelism: the graphics processing unit runs thousands of simple shader cores at once to convert 3D geometry into pixels through the rendering pipeline, while dedicated VRAM and its bandwidth keep those cores supplied with textures and geometry. The GPU trades the few fast cores of the CPU for many slower cores, which is why the graphics card renders frames and trains neural networks far faster than a processor built for serial work. Readers can continue with the GPU architecture explainer, the guide to video memory, or the Nvidia versus AMD comparison to choose a graphics card, and the computer hardware guide covers how the GPU fits with the rest of the system.
Key Takeaways:
- A GPU runs thousands of simple cores in parallel, which suits the repetitive math of rendering and machine learning.
- The GPU differs from the CPU by trading a few fast complex cores for many simple throughput-focused cores.
- The rendering pipeline converts 3D vertices into screen pixels through vertex processing, rasterization, and pixel shading.
- Shader cores, branded CUDA cores or Stream Processors, execute the shader programs that compute vertex and pixel data.
- VRAM stores textures, frame buffers, and geometry, and its bandwidth keeps the shader cores supplied with data.
- GPUs compute beyond graphics through CUDA and OpenCL, accelerating AI training, simulation, and video encoding.
Frequently Asked Questions (FAQs)
How does a GPU work in simple terms?
A GPU works by splitting a large task into thousands of small calculations and running them at the same time across thousands of cores, which suits rendering graphics and machine learning.
What is the difference between a GPU and a CPU?
A CPU has a few fast complex cores for serial tasks, while a GPU has thousands of simple cores for parallel tasks. The CPU handles logic, and the GPU handles rendering.
What are CUDA cores?
CUDA cores are Nvidia’s shader cores, the programmable arithmetic units that execute the vertex and pixel shader programs in the rendering pipeline. AMD calls its equivalent Stream Processors.
Why do GPUs need VRAM?
GPUs need VRAM because rendering requires very high memory bandwidth to feed thousands of cores. VRAM stores textures, frame buffers, and geometry at far higher bandwidth than system RAM.
Can a GPU do more than graphics?
Yes. Through compute APIs such as CUDA and OpenCL, a GPU runs general parallel math, accelerating AI training, scientific simulation, video encoding, and physics far faster than a CPU.
What is the graphics rendering pipeline?
The graphics rendering pipeline is the ordered sequence that converts 3D geometry into screen pixels, passing through vertex processing, rasterization, pixel shading, and output merging.
