April-18--2025-at-10.58.28-5-Back-of-the-card--Board-Design---1-.png" page_type: "generic" adapterId: "generic" ---
GTX 1080s: Revisiting Legends
It's 2017, science and technology are having a great year: the Cassini probe plunges into Saturn, gravitational waves are detected by LIGO and Virgo, and Bitcoin surges from under $1,000, and closer to home, the desktop computer market is having its own reckoning. AMD’s Zen architecture debuts, seeking to unseat Intel’s consumer desktop dominance, and Intel responds with a new flagship of its own!
AMD shoved aside the embarrassing fumble that was the Bulldozer architecture and dropped its new Zen architecture onto the scene in early 2017. The first generation of Zen came with a new socket (AM4), a new slew of chipsets, and a new flagship, the Ryzen 7 1800X.
The Ryzen 7 1800X forced Intel to respond with the legendaryCore i7-8700K. It was the first Intel processor to break the company's self-imposed four-core barrier, though its six cores (twelve threads) still fell short of AMD's eight (sixteen threads).
Those who chose AM4 were given a platform that lives to this day; you can drop a 5800X3D into the same motherboard as the 1800X (with a BIOS update)! Those who chose team blue ended up with a legendary processor that powered rigs beyond most people's usual upgrade cycle.
The graphics card market was also exciting; AMD released the RX 570 and RX 580, but they were overshadowed by NVIDIA’s Pascal family of graphics cards. The GTX 1060 earned a value-to-performance title, while the flagships, the GTX 1080 and GTX 1080 Ti, earned their spot as the most powerful gaming GPUs on the planet.
Don’t remember the GTX 1080 fondly? Jensen Huang sure does.
Source: https://videocardz.com/newz/jensen-huang-signs-geforce-gtx-1080-calls-it-one-of-his-favorites-and-says-it-changed-everything
The GTX 1080 Ti is considered the GOAT, but is it showing its age? It’s a ray-traced-large-language-model world out there in 2026, and it may be time for the 1080 Ti to hang up its jersey. We took the GTX 1080 and 1080 Ti out for a spin to find answers to these questions.
1 of 4
Profile shots of the GTX 1080 and GTX 1080 Ti
First stop is going back in time to some familiar hardware and looking at what gaming performance was like on the ultimate AMD and Intel gaming rigs of yesteryear.
Back In Time
We went spelunking in our inventory and dusted off components of the era to build period-correct Intel and AMD test benches. The first is an ASUS Z370 board with an LGA1700 socket for our Core i7 8700K, and the other is an ASRock X370 board with an AM4 socket for the Ryzen 7 1800X.
The cooler, storage, and memory are of the era, but the power supply certainly is not; it's also massive overkill for these systems. However, the power supply won’t affect our system's performance. To be transparent, we went with the Seasonic Prime TX-1300 because they were already affixed to test benches.
| | LGA1700 | AM4 | | --------------- | -------------------------------------- | -------------------------------------- | | Motherboard | ASUS Prime Z370-A | ASRock X370 Pro4 | | CPU | Intel Core i7 8700K | AMD Ryzen 7 1800X | | CPU Cooler | Noctua NH-D14 | Noctua NH-D14 | | RAM | 2x G.Skill RipJaws V 8GB 3200 MHz CL16 | 2x G.Skill RipJaws V 8GB 3200 MHz CL16 | | Storage | Samsung 970 Evo 1 TB M.2 | Samsung 970 Evo 1 TB M.2 | | PSU | Seasonic Prime TX-1300 | Seasonic Prime TX-1300 |
We didn’t go so far as to load Windows from 2017, instead they have the latest Windows 25H2 build installed and the most recent GeForce Ready driver that supports these cards, 582.53.
At the time, you could be satisfied with either platform to settle your Pascal baby into. Across seven games, the i7-8700K technically wins out over the 1800X. However, it barely wins; only a couple of titles saw a clear victory: Shadow of the Tomb Raider and The Last of Us: Part 1. The rest of the games either perform equally well on both processors or close enough to call a draw.
1 of 8
GTX 1080 and GTX 1080 Ti game results on period hardware
This was a nice trip down memory lane, but are the GTX 1080 or GTX 1080 Ti even better when paired with a modern gaming processor (especially that X3D cache)?
Back To The Future
Turns out that the Ryzen 7 7800X3D and its X3D cache don’t give the GTX 1080s any extra life. At 1080p, we were hoping we were CPU-bound and that the Pascal GPUs would soar to new heights, but instead, it looks like it's the first signal for retirement – we are already GPU bound at these settings and resolution.
Geomean game results including a 7800X3D processor
The silver thread in all this testing is that these results are with maxed-out graphics settings. This means these results are a worst-case scenario, and lowering the graphics settings will yield even more FPS. So these nearly decade-old cards are still capable of providing a 1080p 60 FPS experience in many titles, not all, but it's a better experience than we thought when we first started.
That silver thread is cut short by a pair of ray-traced scissors.
GTX in an RTX World
NVIDIA dropped the G for an R with the introduction of the Turing RTX 20 series. NVIDIA introduced Ray Tracing with the lineup, and the technology was poised to be the new hotness for gamers and game developers everywhere. However, it took a few generations to take hold, and it's still not a staple in many games. Though there are titles that demand it, such as DOOM: The Dark Ages and Indiana Jones and the Great Circle. The GTX 1080s won’t launch either title.
| Specification | GTX 1080 | GTX 1080 Ti | RTX 3060 12G | RTX 4060 8GB | RTX 5050 8GB | | ----------------- | ------------ | --------------- | ---------------- | ---------------- | ---------------- | | CUDA Cores | 2560 | 3584 | 3584 | 3072 | 2560 | | Tensor Cores | 0 | 0 | 112 | 96 | 80 | | Ray Tracing Cores | 0 | 0 | 28 | 24 | 20 | | Memory Capacity | 8 GB | 11 GB | 12 GB | 8 GB | 8 GB | | Memory Bandwidth | 320.3 GB/s | 484 GB/s | 360 GB/s | 272 GB/s | 320 GB/s |
CUDA cores aren't all of the same generation, so counts aren’t entirely representative of performance when comparing numbers directly. The same goes for Tensor and Ray Tracing cores.
When we tackle product reviews, such as graphics cards, we retest components with the latest drivers, game updates, and Windows build available at the time. For this project, we went spelunking in older projects instead of retesting everything. There is an appendix that lists each project we pulled results from, details about each, such as the graphics driver, date, and so on.
We just wanted to highlight this caveat for the results, as it deviates from our standard product review procedure. Anyway, onto the results!
1 of 5
Game results of GTX 1080 and GTX 1080 Ti against newer generations
It's becoming difficult to defend the GTX 1080 these days, but its bigger brother remains in the ring, throwing punches. Growing ray tracing requirements are rendering graphics cards that don’t have the hardware to support it obsolete. Tracing those rays aside, the GTX 1080 Ti is a contender in titles that are closer to its age.
I Could Do This AI Day
We do find humour in exploring LLM benchmarking in an article dedicated to an ancient GTX 1080 Ti; however, what better way to illustrate the advancements in the GPU space that impact LLM inference performance today?
In this project, we focused on using llama.cpp for our LLM inference benchmarking. Llama.cpp is arguably the most popular backend for running models, and many AI software applications run on it. You can find forks or binaries for them in projects like Ollama, Jan AI, and LM Studio. The llama.cpp project conveniently includes an easy-to-use benchmarking utility called llama-bench.
Llama-bench is considered a synthetic test because it uses nonsense tokens for its two tests: prompt processing (pp) or prefill, and text generation (tg). The benchmark doesn't prompt a model with recognizable English; it instead generates random tokens. Nevertheless, it doesn’t matter if we are using the first few paragraphs from Charles Dickens’ Tale of Two Cities or an equivalent amount of gibberish; the LLM (the math) doesn’t care what the tokens are; a forward pass through the model is a forward pass, regardless of the prompt's content.
The velocity of the prefill stage largely depends on a GPU’s compute power, as it is highly parallelized. Higher core counts, all of which can work simultaneously, will traditionally result in higher throughput, but this isn’t always the case. CUDA and Tensor core counts across NVIDIA cards can suggest a picture of performance, but generational improvements must be considered when comparing cards on specifications alone.
Success in text generation usually correlates with a graphics card’s memory bandwidth, because generating a token means reading the entire model from VRAM, and the GPU spends most of its time waiting on memory between generating each token. That being said, compute can be a bottleneck if the processor can’t chew through the data as fast as the memory can serve it up.
To replicate different use cases, we can control the following variables.
1. The size of the prompt in tokens (`-p`) 2. The size of the KV cache (context) (`-d`) 3. The number of tokens to generate (`-n`)
The size of the prompt (`-p`) only affects the prefill test, as the text generation test skips tokenization. Conversely, the number of tokens to generate (`-n`) is not used in the prefill stage, as no text generation occurs. The starting size of the KV cache affects both tests and represents tokens that have already been processed. By setting this flag, we can approximate what prefill and text generation performance would look like in the middle of a chat; setting `-d` to 0 would provide fresh context or start a new chat.
With the re-release of the RTX 3060 12GB, it felt prudent to use it as our comparison to the GTX 1080 Ti 11GB. The following sections run through the results of putting both cards through the same gauntlet of models.
Llama-bench Results
First up are two 12-billion parameter models to stretch the VRAM by sheer model size and a conservative existing context (KV cache size). We used Google Gemma and Mistral Nemo, both in a GGUF Q4K Medium quantized format.
| Model | \# of Parameters | Size | Maximum Context Size | | ------------------------------------------------------------------------------------------------------------- | -------------------- | -------- | ------------------------ | | google\_gemma-3-12b-it-qat-Q4\_K\_M.gguf | 12 billion | 7.30 GB | 128K | | Mistral-Nemo-Instruct-2407-Q4\_K\_M.gguf | 12 billion | 7.48 GB | 128K |
llama-bench `
-m <model> `
-ngl 999 `
-p 512,2048 `
-n 128 `
-d 0,4096,8192 `
-fa 0,1 `
-r 5 `
--main-gpu 0 `
--split-mode none `
-o csv >> results_12b.csvThis command will run prefill tests with prompt sizes of 512 and 2048 tokens. This could involve prompts that ask the LLM to summarize a multi-page PDF. It will test those prompt sizes at context depths of 0 tokens (fresh chat), 4096 tokens (a few prompts in), and 8192 tokens (a long-running chat or a shorter agentic loop).
#### Gemma3 12B Q4\_K\_M
Gemma3 prompt processing results
| Device | Context Depth (tokens) | Tokens / Second | % Change | | ----------- | -------------------------- | ------------------- | ------------ | | GTX 1080 Ti | 0 | 602 | +126% | | RTX 3060 | 0 | 1363 | | | GTX 1080 Ti | 4096 | 508 | +151% | | RTX 3060 | 4096 | 1276 | | | GTX 1080 Ti | 8192 | 466 | +167% | | RTX 3060 | 8192 | 1242 | |
Gemma3 token generation results
| Device | Context Depth (tokens) | Tokens / Second | % Change | | ----------- | -------------------------- | ------------------- | ------------ | | GTX 1080 Ti | 0 | 29 | +38% | | RTX 3060 | 0 | 40 | | | GTX 1080 Ti | 4096 | 28 | +32% | | RTX 3060 | 4096 | 37 | | | GTX 1080 Ti | 8192 | 27 | +33% | | RTX 3060 | 8192 | 36 | |
#### Mistral Nemo 12B Q4\_K\_M
Mistral Nemo prompt processing results
| Device | Context Depth (tokens) | Tokens / Second | % Change | | ----------- | -------------------------- | ------------------- | ------------ | | GTX 1080 Ti | 0 | 603 | +142% | | RTX 3060 | 0 | 1459 | | | GTX 1080 Ti | 4096 | 450 | +186% | | RTX 3060 | 4096 | 1284 | | | GTX 1080 Ti | 8192 | 358 | +217% | | RTX 3060 | 8192 | 1137 | |
Mistral Nemo token generation results
| Device | Context Depth (tokens) | Tokens / Second | % Change | | ----------- | -------------------------- | ------------------- | ------------ | | GTX 1080 Ti | 0 | 31 | +39% | | RTX 3060 | 0 | 43 | | | GTX 1080 Ti | 4096 | 30 | +30% | | RTX 3060 | 4096 | 39 | | | GTX 1080 Ti | 8192 | 28 | +29% | | RTX 3060 | 8192 | 36 | |
As we suspected, the GTX 1080 Ti gets obliterated in prompt processing. The GTX 1080 Ti has the same number of CUDA cores (albeit older architecture) as the RTX 3060, but the RTX 3060 has the Tensor core advantage. Tensor cores are dedicated matrix-multiply hardware designed to accelerate tasks like this.
Text generation performance isn’t as dire thanks to the decent 484 GB/s of memory bandwidth of the GTX 1080 Ti. The RTX 3060 has less bandwidth at 360 GB/s, yet, as explained earlier, memory bandwidth isn’t the be-all and end-all if you don’t have the processing to use all that runway. The RTX 3060 can generate tokens faster because it can use more of its memory bandwidth than the GTX 1080 Ti can.
#### Qwen3 8B Q4\_K\_M
Next, we wanted to try a smaller model but with larger context depths to see if the performance story differed from the 12-billion parameter models.
| Model | \# of Parameters | Size | Maximum Context Size | | ---------------------------------------------------------------------------------------- | -------------------- | -------- | ------------------------ | | qwen3-8b-instruct-q4\_k\_m.gguf | 8 billion | 5.03 GB | 32K |
llama-bench `
-m Qwen_Qwen3-8B-Q4_K_M.gguf `
-ngl 999 `
-p 512,2048,8192 `
-n 128 `
-d 0,4096,16384 `
-fa 0,1 `
-r 5 `
--main-gpu 0 `
--split-mode none `
-o csv | Out-File -FilePath "results.csv" -Append -Encoding utf8In this test, we start with a prompt size of 512 tokens and zero tokens in context. We then increase the context depth to 4096 tokens, and then 16384 tokens.
Qwen3 prompt processing results
| Device | Context Depth (tokens) | Tokens / Second | % Change | | ----------- | -------------------------- | ------------------- | ------------ | | GTX 1080 Ti | 0 | 921 | +130% | | RTX 3060 | 0 | 2118 | | | GTX 1080 Ti | 4096 | 621 | +189% | | RTX 3060 | 4096 | 1797 | | | GTX 1080 Ti | 16384 | 318 | +280% | | RTX 3060 | 16384 | 1209 | |
Qwen3 token generation results
| Device | Context Depth (tokens) | Tokens / Second | % Change | | ----------- | -------------------------- | ------------------- | ------------ | | GTX 1080 Ti | 0 | 47 | +34% | | RTX 3060 | 0 | 63 | | | GTX 1080 Ti | 4096 | 43 | +30% | | RTX 3060 | 4096 | 56 | | | GTX 1080 Ti | 16384 | 36 | +19% | | RTX 3060 | 16384 | 43 | |
The story is the same here too. If you chat with a model running on a GTX 1080 Ti, your time to first token will be horrendous compared to that of the RTX 3060 Ti (as indicated by the prefill speed), but the response generation speed won’t feel as archaic.
The GTX 1080 Ti has two things against it: maimed FP16 throughput and age-induced deprecation. The former is an example of NVIDIA’s notorious reputation for maintaining a market segmentation between consumer and datacenter/workstation products.
Undermined FP16 throughput
The GP102 processor on the GTX 1080 Ti has hamstrung FP16 throughput compared to the GP100 found on the P100 Tesla. The GP100 was designed for training neural networks and supports 2x FP16 throughput compared to FP32. The GP104’s (largely similar to the GP102) FP16 performance is 64 times slower than that of FP32 calculations. The GP102 and GP104 provide INT8 support that is not available on the GP100. You could get decent inference performance on the GTX 1080 Ti, but you needed to step up to a P100 Tesla with its GP100 to get any appreciable FP16 throughput. NVIDIA intended a product line for neural network training based on the GP100, and another line for inference based on the GP 102/104.
One thing going for the GP102 is its integer throughput. The token generation performance shown above largely stems from the specialized instructions for two- and four-way integer dot products (DP4A). This allows the GP102 to perform fast 8-bit integer math, which is exactly what quantized GGUF models use. When running the Q4 models above, llama.cpp doesn't convert the weights to floating-point numbers to do the math; it converts everything to 8-bit integers, taking advantage of the DP4A instructions. Modern Tensor core-laden GPUs still use the DP4A instructions today, albeit on newer, faster CUDA cores and faster memory.
Outdated Hardware
There’s no getting around it: Pascal is old news, the toolkits and drivers that support it have been deprecated and replaced. There are technologies being built around hardware (Tensor cores) that Pascal doesn’t even have: flash attention. Llama.cpp supports flash attention on Pascal architecture but it's a second-class citizen.
Flash Attention is built around MMA/WMMA instructions, which are only expressed through a Tensor Core. Llama.cpp will fall back to pathways that work on Pascal, but in most cases, performance actually drops when flash attention is enabled, or it just doesn’t work.
The GTX 1080 Ti only supports up to CUDA 12.x and Compute Capability 6.0/6.1. In April this year, PyTorch (a popular Python framework) will introduce CUDA 13.2 and deprecate CUDA 12.8. As time marches on, Pascal support will only get worse.
Conclusion
The GTX 1080 and 1080 are legends, there's no doubt about that. They earned their place in the hall of fame alongside other legends like the AM4 socket and the Core i7-8700K. Yet, their age is showing in gaming and AI workloads.
NVIDIA promised that ray tracing would be the future of rendering; it's not, but the adoption of the technology is spreading. New games and even benchmark tools like Evolve expect your hardware to support ray tracing, which leaves the GTX lineups out.
Ray tracing aside, the Pascal GeForce graphics cards were hampered in the early days of neural network development. NVIDIA would much rather you spend much more money on products like the Tesla P100 and Tesla P40 in fact, they still prefer you buy the workstation cards for AI work. Nevertheless, if you have a GTX 1080 Ti lying around, it is certainly capable of enabling you to tinker with 8B- to 12B-parameter models.
If you are still rocking a GTX 1080 TI as your daily driver, we salute you.
---
Test Result Appendix
For the GTX in an RTX World section, here is the list of project results where pulled from.
| Project | Date | Driver | | --------------------- | ---------- | ---------- | | PRE-BLACKWELL | 01-13-2025 | 566.36 | | RTX5060-2025 | 04-11-2025 | 572.83 | | AMD-9060ANDXT-2025 | 06-20-2025 | 576.52 | | 5050GAMECHANGER-2025 | 08-13-2025 | 576.88 | | MISSING50-2025 | 02-17-2026 | 591.74 | | SC-THESKINNY5060-2026 | 06-23-2026 | 610.62 |
Black Myth Wukong
- RTX 4060 - PRE-BLACKWELL
- RTX 5050 - MISSING50-2025
- RTX 3060 - AMD-9060ANDXT-2025
- RTX 4060 - RTX5060-2025
- RTX 5050 - SC-THESKINNY5060-2026
- RTX 3060 - 5050GAMECHANGER-2025
- RTX 4060 - 5050GAMECHANGER-2025
- RTX 5050 - SC-THESKINNY5060-2026
- RTX 3060 - 5050GAMECHANGER-2025
- RTX 4060 - PRE-BLACKWELL
- RTX 5050 - MISSING50-2025
- RTX 3060 - AMD-9060ANDXT-2025
- RTX 4060 - 5050GAMECHANGER-2025
- RTX 5050 - MISSING50-2025
- RTX 3060 - 5050GAMECHANGER-2025
Cyberpunk 2077
Red Dead Redemption 2
Shadow of the Tomb Raider
The Last of Us: Part 1
---