What Is a GPU Actually Doing That a CPU Can't?

Or: Why Doesn't Your Expensive CPU Just Draw the Game?

Your computer has a CPU and a GPU. Both are processors. Both perform calculations. Both contain billions of transistors. So why do we need two of them?

A CPU can perform many of the calculations a GPU performs. A GPU can perform plenty of calculations that have nothing to do with graphics. The difference isn't that one understands math the other doesn't. It's how they're built to perform that math — and for what kind of work each architecture was optimized.

The Fundamental Difference: Versatility vs. Volume

A CPU is designed to be extremely good at handling a relatively small number of complicated, varied tasks with low latency. It needs to be flexible because it runs the operating system, executes browser code, manages memory, handles input, coordinates background services, and switches rapidly between completely different workloads. CPU cores are sophisticated: they predict which code branch a program will take, execute instructions out of order to stay busy, maintain large caches to reduce waiting, and adapt to nearly anything thrown at them. A modern desktop CPU might have 8 to 16 such cores, each capable of handling complicated and unpredictable work.

A GPU takes a completely different approach. Instead of a small number of highly capable workers, it contains a large number of simpler execution units organized around the assumption that enormous amounts of similar work need to happen simultaneously. A modern GPU can have thousands of these units. No individual one is as broadly capable as a CPU core — but when thousands of them execute the same calculation on different pieces of data at the same time, the total throughput is extraordinary.

CPU: a few master craftspeople who can handle anything. GPU: a massive workforce that excels when everyone gets the same kind of job.

Why Graphics Needs This

Consider a 4K display: 3840 × 2160 = over 8 million pixels. Render a game at 60 frames per second and you need to determine the correct color for each of those pixels 60 times every second — nearly 500 million pixel calculations per second, and that's before accounting for the fact that each pixel may require multiple calculations involving geometry, textures, lighting, shadows, reflections, transparency, and materials.

The key observation is that most of those pixels can be calculated independently of each other. Pixel A doesn't need to wait for Pixel B to finish before it can start. That means the work can be distributed across thousands of execution units running simultaneously. A GPU is built precisely for this — to throw enormous parallel computing power at problems where the same operation needs to be applied across huge amounts of data at once.

What the GPU Is Actually Computing

A 3D game doesn't start as a flat picture. The world contains mathematical descriptions of objects — characters, buildings, terrain, weapons — represented largely using triangles. Three points always define a plane, which makes triangles mathematically convenient building blocks for 3D surfaces. A modern game scene can involve millions of triangles.

The GPU works through a pipeline to turn that 3D geometry into the 2D image you see. Vertex shaders transform the corner points of triangles based on camera position and object movement. Rasterization determines which screen pixels each triangle covers. Fragment or pixel shaders calculate the final color of each covered pixel, considering light, shadow, texture, and material properties. Modern GPUs also include dedicated hardware for ray tracing — a more physically accurate lighting approach that traces simulated light rays through a scene.

These shader programs run on GPU hardware. Thousands of instances can execute simultaneously on different vertices, triangles, or pixels. That's the architecture working as intended.

Why the CPU Can't Just Do This Instead

A CPU can calculate pixels. It can perform every piece of math the GPU performs. The question is speed.

At 60 FPS, you have about 16 milliseconds to produce each frame. Calculating color for 8 million pixels, with all the geometry, lighting, and material calculations involved, sequentially on a handful of CPU cores simply takes too long. The math isn't different; the scale is.

GPU execution units spend their transistor budget on arithmetic throughput rather than the sophisticated control logic that makes CPU cores flexible. That tradeoff means a GPU core isn't great at the complicated, branchy, unpredictable work the OS and applications constantly generate — but it can perform the same floating-point calculation on thousands of different inputs simultaneously. For graphics, that's exactly what's needed.

CPU and GPU Bottlenecks

In a game, the CPU handles the simulation: AI behavior, physics, game rules, networking, input handling, scene management, and preparing draw calls that tell the GPU what to render. The GPU handles the rendering: taking that scene description and turning it into pixels.

If the CPU can't prepare work fast enough, the GPU sits waiting — a CPU bottleneck. The GPU utilization drops even though the GPU itself is fast; it just doesn't have anything to do. Buying a faster GPU in this situation helps very little.

If the GPU can't finish rendering quickly enough — because the resolution is high, ray tracing is enabled, or effects are demanding — the CPU sits ready while the GPU is still working — a GPU bottleneck. Lowering graphical settings, resolution, or disabling expensive effects reduces the GPU's workload and typically increases frame rate in this scenario.

Increasing resolution usually hits the GPU hard. Going from 1080p to 4K quadruples the pixel count. The CPU's game simulation hasn't necessarily become four times more complicated — the same physics runs, the same AI operates — but the GPU has four times as many pixels to produce.

Then AI Arrived

GPUs were created for graphics. So why is nearly every conversation about AI filled with GPU, VRAM, and NVIDIA?

Because the mathematical operations behind modern machine learning — enormous amounts of matrix and tensor arithmetic — are also highly parallel. Neural networks perform billions of multiplications and additions across large grids of numbers. A CPU can perform those calculations. But this is precisely the kind of workload where a GPU's parallel architecture excels: the same operation applied across huge amounts of data, simultaneously.

The GPU doesn't know or care whether its arithmetic ultimately produces a pixel or part of a neural network calculation. It's executing numerical operations. When a language model generates text, the GPU isn't understanding language — it's executing sequences of mathematical operations defined by the model, very quickly. The intelligence-like behavior emerges from the trained model and software. The GPU is the machinery doing the arithmetic.

Modern GPUs include specialized Tensor Cores optimized for the specific kinds of matrix operations machine learning uses. Phones have Neural Processing Units (NPUs). Google built Tensor Processing Units (TPUs). The pattern repeats: when a workload becomes important enough, hardware gets built specifically for it.

GPU Memory (VRAM)

Discrete graphics cards have their own dedicated memory called VRAM (video memory). The GPU needs extremely fast access to huge amounts of data — textures, geometry, frame buffers, shader data, and more. Routing everything through the CPU to ordinary system RAM would create severe bottlenecks, so VRAM sits close to the GPU with extremely high bandwidth.

VRAM capacity matters because graphics workloads need to fit their working data in fast memory. If a scene's textures, geometry, and render targets exceed available VRAM, data may have to move through slower parts of the memory system and performance can suffer significantly. But more VRAM doesn't automatically make a GPU faster — capacity and bandwidth are different measurements, and you only benefit from capacity when you're actually using it.

The Bard's Take

A GPU isn't powerful because it knows special mathematics a CPU can't perform. A CPU can calculate pixels, run matrix operations, do ray tracing. The difference is scale and speed.

A CPU is built around a small number of extremely capable workers that can rapidly handle complicated and unpredictable tasks. A GPU is built around an enormous parallel workforce that excels when the same general kind of mathematical work needs to be performed across huge amounts of data. Rendering millions of pixels? Perfect. Transforming millions of geometry vertices? Perfect. Running the matrix arithmetic behind AI models? Also perfect. Following complicated OS logic with constant branches and interruptions? Give that to the CPU.

That's why your computer has both, and why they cooperate rather than compete. The CPU runs the world. The GPU turns much of it into pictures. Neither could deliver the same experience nearly as effectively working alone.

Sources

• What's the Difference Between a CPU and a GPU? — NVIDIA
• GPU — Wikipedia — Wikipedia
• What Is a Graphics Card? — How-To Geek
• GPU Acceleration for Compute Workloads — AMD