a graphics processing unit (GPU)
Imagine you need to grade one fiendishly hard exam versus ten thousand simple ones. For the single hard exam you want one brilliant professor who can follow a long, twisty line of reasoning fast — that is a CPU. For the ten thousand simple exams you want a stadium full of helpers who each grade a handful in parallel; none is a genius, but together they finish in a flash — that is a GPU. A graphics processing unit is a chip with hundreds or thousands of simple cores built to do a lot of straightforward work at once, rather than a little hard work quickly.
GPUs were born to draw graphics, and that workload is the perfect picture of data-level parallelism: a screen has millions of pixels, and you do roughly the same shading math on each, independently. So the hardware was shaped to match — many small arithmetic units, grouped so that a single instruction drives a whole bundle of them over different data (the SIMT model), backed by very high memory bandwidth to keep all those units fed. Around 2007 people realized this same machine could accelerate any massively parallel computation, not just pixels — physics simulation, scientific computing, and above all the matrix multiplications at the heart of deep learning. That repurposing is called GPGPU, general-purpose computing on GPUs.
The crucial, honest framing: a GPU is not just a faster CPU, and treating it like one leads to crushing disappointment. A GPU wins enormously on regular, parallel, arithmetic-heavy work with thousands of independent elements; it is poor at serial, branchy, latency-sensitive code — a single dependent chain of decisions runs slowly on a GPU because its strength is width, not the speed of any one thread. A CPU is latency-optimized (finish one task as soon as possible); a GPU is throughput-optimized (finish the most total work per second). They are partners, not rivals: the CPU runs the program's logic and hands the GPU the big parallel number-crunching, and a real cost is just moving the data back and forth across the connection between them.
Multiplying two 4096x4096 matrices is about 137 billion multiply-adds, all independent. A CPU with a handful of cores grinds through them; a GPU with thousands of cores spreads them across all its lanes and finishes far sooner — but only after the matrices are copied into GPU memory, and that copy is itself a cost worth measuring.
A GPU trades single-thread speed for sheer width: thousands of simple cores excel at regular parallel work and stumble on serial, branchy code.
The biggest misconception is that a GPU is simply a faster CPU. It is not — it is a throughput engine. Serial, branchy, or latency-sensitive code can run slower on a GPU than a CPU, and the data transfer to and from the device can erase the speedup entirely on small problems.