Which LLM on GTX 1080 Ti (11 GB) ?

#The GTX 1080 Ti in 2026: what it has and what it doesn't

The GTX 1080 Ti is a Pascal card (GP102 chip) with 3,584 CUDA cores, 11 GB of GDDR5X, and 484 GB/s of bandwidth, with a 250 W power envelope. On the public llama.cpp benchmark, it produces 62.49 tokens/s during generation and 1,084.41 tokens/s during prompt processing on a Q4_0 Llama 2 7B. These results put it on par with a RTX 2060 Super for generation, with 3 GB more: it is this capacity, more than speed, that still makes it worth considering.

The table already contains the most important information: FP16 is worth about 1/64 of FP32 on this card. The next paragraph explains why this does not hurt performance as much as you might think.

#Pascal's limitations: what matters and what doesn't

Three limitations are real. The first is the lack of Tensor Cores, the matrix-computation units introduced with Volta and Turing: they accelerate prompt processing and training, not generation, which depends on memory. The second is FP16, with its ridiculously low throughput on consumer Pascal (about 166 GFLOPS versus 10,609 in FP32): engines such as llama.cpp work around the problem by computing quantized models with integers. The third is the end of software support, discussed below.

Two frequently repeated claims are false. FP16 isn't simply twice as slow; it's sixty times slower. And Flash Attention isn't limited to Tensor Cores: the llama.cpp benchmark runs the 1080 Ti with Flash Attention enabled, at 1,138.14 tokens/s for prompt processing and 61.38 tokens/s for generation, versus 1,084.41 and 62.49 without it. The gain is small for throughput, but the feature is available and reduces context memory usage.

#What 11 GB enables: the decision table

The site's reference point puts an 8B in Q4 at around 5 GB and a 14B at around 9 GB, excluding the KV cache. With 11 GB, a 12B leaves 4 GB of headroom and a 14B only 2 GB. The table applies the performance observed on the benchmark (49% of the theoretical 484 GB/s ceiling, or 62.49 tokens/s for 3.82 GB of weights) to common models: these are projections, not measurements.

The most interesting range is 12B: it is the largest model that remains comfortable, with a context of several thousand tokens. On an 8 GB card, this same model leaves barely 1 GB and forces you to reduce the context drastically. Beyond that, a 14B model in Q4 fits but leaves no headroom, and a 30-billion-parameter model does not fit.

#What public benchmarks say

QuelLLM does not test this card. The benchmark in the “Performance of llama.cpp on Nvidia CUDA” discussion compares all cards using the same model, making it possible to place the 1080 Ti relative to its peers.

Three patterns emerge. In generation, the 1080 Ti matches RTX 2060 Super and remains 17% behind a 12 GB RTX 3060. In prompt processing, the gap widens: RTX 3060 nearly doubles its speed, while RTX 2080 Ti, with the same capacity, is 2.7 times faster. Finally, the Tesla P40, a 24 GB Pascal card, reaches 54.74 tokens/s, showing that 24 GB is achievable on this architecture, albeit at a lower throughput than the 1080 Ti.

#Make the Most of 11 GB: Use a Lower Quantization

An advantage specific to 11 GB is that you can increase quality rather than size. The QuelLLM catalog lists, for a Granite 4.2 8B: 4.6 GB in Q4, 6 GB in Q5, and 9 GB in Q8. On 8 GB, only Q4 leaves room to spare. On 11 GB, Q5 (6 GB) remains very comfortable, while Q8 (9 GB) works with a short context.

The trade-off is clear: each quantization level reduces model errors but slows generation, since more weights are reread for each token. For everyday chat, Q5 is a good balance; Q8 makes sense when precision matters (extraction, code) and throughput matters less. The quantization guide details the quality difference.

• Choose your quantization (Q4, Q5, Q8, FP16)

#Two cards for 22 GB: possible, but verify first

The llama.cpp benchmark notes in its instructions that contributors with multiple GPUs must force a single GPU with -sm none -mg, unless the model is too large for VRAM: the engine therefore does distribute a model across multiple cards. Two GTX 1080 Ti would provide 22 GB for the weights, enough to host a 32-billion-parameter model in Q4 (19 to 20 GB according to the site's benchmark), with no context headroom.

The split does not add the speeds together: layers are divided among cards and transferred over the PCIe bus, which limits the gain. This setup also requires a suitable case, power supply, and motherboard, and doubles your exposure to Pascal’s end of support. For a 24 GB project, first compare the cost of a single newer card.

#Install and verify in four steps

1. 01
   Check the driver

   Run nvidia-smi. For compute capability 5.0 to 6.2 cards, including GTX 1080 Ti, Ollama's documentation requires driver 570 or newer.
2. 02
   Install Ollama

   Follow your system's installation guide. Ollama recognizes the card as GTX 1080 Ti (compute capability 6.1) in its official list.
3. 03
   Choose a suitable model

   Start with an 8B in Q4 to validate the pipeline, then test a 12B with a 4,096-token context.
4. 04
   Check placement

   Run ollama ps: the PROCESSOR column should show 100% GPU. If not, reduce the context or the model.

If loading fails, do not look for an exotic workaround variable: Ollama enables Flash Attention automatically when the engine and card support it, and the documented variable is OLLAMA_FLASH_ATTENTION (1 to force it, 0 to disable it). The troubleshooting guide details common errors.

• Install Ollama step by step
• Troubleshoot Ollama: GPU not detected, slow performance

#Pascal end of life: what to plan for

The CUDA 13 release notes indicate that Maxwell, Pascal, and Volta are no longer supported. Wikipedia reports that NVIDIA ended Game Ready support for these architectures in December 2025, with security updates through October 2028. Today, the GTX 1080 Ti works with Ollama and driver 570 or later; the risk is that future inference engines will target only CUDA 13. Record your driver and Ollama versions before any update.

#Verdict: keep it, yes; buy it, provided that

To compare current options without listing prices that change every week, the site's pages show the models suited to each memory capacity and link to the graphics card pricing page.

• Which LLM on RTX 3060 12 GB
• Which LLM on RTX 2080 Ti (11 GB)
• Which models for 12 GB of VRAM, all cards
• Compare GPU prices for AI

• Source: public llama.cpp benchmark on CUDA
• Source: Ollama documentation, supported NVIDIA hardware
• Source: GeForce 10 series, specs
• Source: CUDA Toolkit release notes