There’s a piece of computing history that happens to start at Pixar and end at Hashcat, and the story of how it got from one to the other is one of the better technology arcs I know. The graphics card wasn’t supposed to do any of this. The chip that paints pixels on your monitor was supposed to keep painting pixels on your monitor. Then in 2007 NVIDIA shipped a programming model called CUDA, the academic world realized a GPU was effectively a thousand-core math co-processor in a gamer’s box, and within fifteen years the same hardware that rendered the dinosaurs in Jurassic Park was the standard tool for cracking enterprise password hashes and training large language models.
This is how that happened.
Before pixels: vector displays (1960s and 70s)#
The earliest computer graphics weren’t drawn with pixels at all. They were drawn the way you’d draw on an oscilloscope: the electron beam aimed at a point on the phosphor and lit it up, then aimed at another point and drew a line between the two. Vector displays. Sharper than any raster display of the era because there was no grid to constrain you.
Ivan Sutherland’s Sketchpad (1963, his MIT PhD thesis) ran on the TX-2 and is the ancestor of every CAD program, every windowing GUI, and every interactive drawing tool that came after. You could draw a line with a light pen and the system would record it as a geometric object you could move and constrain, which was genuinely new in 1963.
The popular version of the same technology turned up in arcades. Asteroids (Atari, 1979) used Atari’s QuadraScan XY vector monitor. The ships and the rocks were glowing white lines on a black field, and they’re sharper than anything raster-based the same era could produce. If you’ve ever seen an original cabinet, the visual quality is genuinely striking, because the photons are coming straight from where the math says they should be rather than from the nearest pixel.
Vector displays didn’t scale. Once you wanted to fill regions with color and texture, raster won, and the industry moved to bitmapped frame buffers. The pure vector aesthetic survives mostly in retro homages and a few specialty oscilloscope-art demos.
The SGI era (1980s and 90s)#
If you needed serious 3D in the 80s and 90s, you bought a Silicon Graphics workstation. SGI’s machines ran the MIPS architecture under IRIX, their flavor of Unix, and they cost what a small house cost. They were also the only thing that could render the visual-effects work that defined Hollywood’s transition out of practical effects.
The SGI Indigo, Onyx, and Challenge lines did the visual effects for Terminator 2 (the T-1000’s liquid metal, ILM), Jurassic Park (the dinosaurs, also ILM via SGI Challenge-class hardware), Toy Story (Pixar’s RenderMan farm), and most of the show-stopper effects work that came out of the early 90s. They were genuinely beautiful machines too: deep purple cases, custom keyboards, screens that ran at resolutions PCs of the era couldn’t reach.
The Jurassic Park nod that every IT person remembers: when Lex sits down at the computer and says “It’s a UNIX system, I know this!”, the 3D file system view she’s navigating is fsn, the File System Navigator that shipped with IRIX. It was a real piece of SGI software. It existed in 1993, on the workstations the movie’s effects were rendered on, and the producers used it on screen because it looked like the future. To anyone who’d actually used IRIX, the moment was a small inside joke.
SGI’s other lasting contribution was OpenGL, released in 1992 as an open standard 3D graphics API derived from their internal IRIS GL. OpenGL made it possible to write 3D code that ran on machines from different vendors, which mattered because at the time SGI was the only vendor with serious 3D, and they were betting that opening up the API would grow the market rather than hand it to competitors. They bet right on the market and wrong on themselves. Within a decade the competitors had eaten them alive on price, and SGI as a company was effectively gone by 2006.
The ghost of SGI still runs on every machine you own. OpenGL is in your phone, your browser, your laptop, your console. The company shipped one of the great open standards in computing and didn’t survive it.
The 3D accelerator wars (1996 to 2000)#
While SGI ruled the workstation tier, PC gamers in the mid-90s were stuck rendering 3D in software, on a CPU that wasn’t designed for it. Doom and Quake were technical miracles in part because John Carmack figured out how to draw textured 3D scenes on a Pentium. They were also pixelated and slow compared to what an SGI Onyx could do, which everyone playing them was aware of.
Then in 1996, a small company called 3dfx shipped the Voodoo Graphics chip. It was the strangest hardware in PC history: a 3D-only accelerator card with no 2D capability at all. You kept your existing VGA card for Windows and the desktop, ran a short pass-through cable from the VGA card’s output to the Voodoo, and from the Voodoo to the monitor. When you launched a Voodoo-aware game, the card woke up, the VGA signal got switched out, and suddenly GLQuake was running on hardware that had no business existing in a $300 PC card.
The Voodoo’s contribution wasn’t just speed. It was bilinear filtering. Software-rendered textures on the era’s CPUs were blocky and pixelated; the Voodoo smoothed them as it scaled, so the same texture that looked like a chessboard in software rendering looked plausibly like brick in hardware. The visual generation gap between Voodoo and non-Voodoo PCs was the kind of jump that doesn’t usually happen in a single year.
3dfx was riding high through 1997 and 1998. Then NVIDIA, which had been a smaller competitor with the RIVA series, shipped the RIVA TNT (1998) and then the GeForce 256 in October 1999. NVIDIA invented the marketing term “GPU” with the GeForce 256 launch and built it around a technically real claim: the chip handled the full graphics pipeline including transform and lighting (T&L), which had been the CPU’s job up to that point. With T&L on the card, the CPU was freed to do everything else, and the framerate jumped.
3dfx didn’t recover from missing the T&L generation. By the end of 2000, NVIDIA had acquired most of 3dfx’s assets for around $70 million in stock, and the Voodoo brand was finished. The card that defined a generation of PC gaming died in five years.
(The other player worth naming: ATI. ATI’s Radeon line launched in 2000 and held the second-place position behind NVIDIA for the rest of the decade. AMD acquired ATI in 2006, which is why the modern Radeon lineup is an AMD product. The GPU duopoly that lasted into the mid-2020s started with NVIDIA-vs-ATI at the turn of the millennium.)
The pivot: GPGPU and CUDA (2006 to 2010)#
GPUs through the early 2000s were “fixed-function.” They knew how to transform vertices, fill triangles, and apply textures, in roughly that order, and they did all of it incredibly fast in parallel. You couldn’t tell the GPU to do something other than draw graphics, because there wasn’t an API for asking.
The shift started with programmable shaders, introduced in DirectX 8 (2001) and OpenGL extensions of the same era. Suddenly a programmer could write small programs (vertex shaders and pixel shaders) that ran on the GPU’s many cores in parallel. Academics noticed almost immediately that the shader pipeline could be tricked into doing general-purpose math by packing data into “textures” and writing shaders that processed it. The early GPGPU community wrote linear algebra kernels by smuggling matrices through the rendering pipeline. It worked, but it was ugly.
NVIDIA’s GeForce 8800 GTX (November 2006) changed the underlying architecture. The 8800 introduced a unified shader design: instead of separate vertex and pixel shader hardware, all of the chip’s cores could run any kind of shader, and by extension any kind of small parallel program. The hardware was ready for a real GPGPU API. NVIDIA shipped CUDA 1.0 in June 2007.
CUDA mattered because it dropped the rendering pipeline pretense entirely. You wrote C code. The compiler split it into a host-side CPU portion and a device-side GPU portion. The GPU portion ran on the card’s cores in parallel, with no triangle math, no textures, no graphics state to manage. The 8800 GTX had 128 cores; what the academic community had been doing through OpenGL shaders, you could now do directly.
The first practical impacts were where you’d expect them: simulation, scientific computing, video encoding. The unexpected impact was security.
The security punchline#
Calculating an MD5, SHA-1, or NTLM hash is a parallelizable mathematical operation. Every hash you try is independent of every other hash. That’s the textbook case for a parallel processor.
A high-end CPU in 2026 has roughly 24 to 64 cores. It can compute a few dozen NTLM hashes simultaneously. An RTX 4090 has 16,384 CUDA cores. The RTX 5090, which shipped in January 2025 on the Blackwell architecture, has 21,760. On a single 4090, Hashcat computes NTLM at around 168 gigahashes per second on a stock benchmark. Four 4090s in a rig reach roughly 675 GH/s. The 5090 numbers are higher again.
That means an eight-character mixed-case alphanumeric password against NTLM (about $62^8 \approx 2.2 \times 10^{14}$ candidates) is exhaustible in a few hours on a single-card rig. Hashing schemes designed before GPGPU mattered (LM, MD5-based crypt) effectively don’t have unrecoverable passwords on modern hardware. Even the slower modern hashes (bcrypt at high cost factors, Argon2id, scrypt) are slower on a GPU than on a CPU only because they were specifically designed to resist GPU parallelism, which is its own story about how the password-hashing community adjusted to what NVIDIA had quietly shipped.
The other security-relevant pivot: Bitcoin drove GPU mining from roughly 2010 through early 2013. SHA-256 (Bitcoin’s proof-of-work hash) is also parallelizable, and for a few years the most cost-effective Bitcoin miners were rooms full of GPUs computing hashes around the clock. Application-specific chips (ASICs) that did nothing but SHA-256 displaced GPUs for Bitcoin specifically by 2013, but the GPU-mining era pushed CUDA expertise out into the broader developer community in a way that academic publishing never quite achieved.
Then in 2017 NVIDIA shipped the Volta architecture (the V100 datacenter card) with a new feature called Tensor Cores: specialized blocks of silicon optimized for the matrix multiplications at the heart of neural network training. The next decade of deep learning ran on Tensor-Core GPUs. The transformer architecture, the language models that came out of it, the diffusion models behind every image generator: all of them are training workloads that NVIDIA’s hardware was specifically optimized to run, because NVIDIA had been preparing for the AI era since at least the Pascal generation (2016).
And, full circle: the deepfake audio and video that the social engineering side of red team work has to think about in 2026 is generated on consumer-tier GPUs that descend, by an unbroken line of architecture decisions, from the Voodoo Graphics card you plugged into your PC to play Quake in 1996. The graphics card retired from its first career as a polygon-pusher in roughly 2007 and has been working its second career as a general-purpose math engine ever since.
What survives#
The SGI workstations are gone. The Voodoo cards are collectible curiosities. The companies that made graphics hardware in the 90s have mostly merged, bankrupted, or pivoted out of the industry. What survives is the software stack and the architectural ideas.
OpenGL is on every device you own. CUDA is the closest thing computing has to a default parallel programming model. The unified shader architecture that the GeForce 8800 introduced is the template for every NVIDIA, AMD, and Apple GPU since 2006. And the gamer’s purchase of a $1,500 GPU in 2026 ends up funding the same architectural research that drives the data center cards underneath every major AI deployment, which is one of the stranger feedback loops in the history of computing hardware.
The trickster move of the last twenty years in computing hardware is that the most consequential parallel computer ever shipped at consumer scale arrived disguised as something to make video games look better, and most of the people buying one still believe that’s what they bought.
