Best local AI models for NVIDIA GTX 670

2 GB GDDR5. At a 4k context, 56 of the 233 models in our catalog with verified parameter counts fit fully, up to Allegro at 2.8B parameters.

Check your own machine against every model →

The largest models that fit fully

The 30 largest of the 56 models that fit; every smaller model in the catalog fits too. Best quant means the highest quality compression whose weights and 4k context both sit inside the memory.

ModelParametersBest quant that fitsMemory used at 4k
Allegro2.8BQ4_K_M2 GB
Open-Sora Plan2.7BQ4_K_M2 GB
LFM2 1.2B / 2.6B2.6BQ4_K_M1.9 GB
Playground v2.52.6BQ4_K_M1.9 GB
Stable Diffusion 3.5 Medium2.5BQ4_K_M1.8 GB
Canary 1B / Qwen-2.5B2.5BQ4_K_M1.8 GB
SeamlessM4T v22.3BQ5_K_M2 GB
Parler-TTS2.2BQ5_K_M1.9 GB
Kimi K3 DSpark2.2BQ5_K_M2 GB
SmolVLM 256M / 500M / 2B2BQ6_K2 GB
Stable Diffusion 3 Medium2BQ6_K2 GB
Pyramid Flow2BQ6_K2 GB
Wav2Vec2 / XLS-R2BQ6_K2 GB
Moondream 21.9BQ6_K1.9 GB
Qwen3 1.7B1.7BQ6_K1.7 GB
SmolLM2 135M / 360M / 1.7B1.7BQ6_K1.7 GB
StableLM 2 1.6B1.6BQ8_02 GB
Sana 0.6B / 1.6B1.6BQ8_02 GB
Zonos 0.11.6BQ8_02 GB
Dia 1.6B1.6BQ8_02 GB
Whisper Large v31.55BQ8_02 GB
ControlNet / T2I-Adapter / IP-Adapter1.5BQ8_01.9 GB
Hunyuan-DiT1.5BQ8_01.9 GB
Stable Video Diffusion1.5BQ8_01.9 GB
Whisper Large v2 / turbo1.5BQ8_01.9 GB
AudioGen1.5BQ8_01.9 GB
AudioLDM 21.5BQ8_01.9 GB
Tango 21.4BQ8_01.8 GB
TinyLlama 1.1B1.1BQ8_01.4 GB
SantaCoder 1.1B1.1BQ8_01.4 GB

Close, but only with CPU offload

These need more than the card holds at their smallest practical quant, so part of the model runs from system memory (figures assume 32 GB of it). They work, several times slower.

ModelParametersMemory at Q4_K_MSystem RAM at 4k
SmolLM3 3B3B2.2 GB needed4.2 GB
Replit Code v1.5 3B3B2.2 GB needed4.2 GB
Kandinsky 3.13B2.2 GB needed4.2 GB
Voxtral Mini / Small3B2.2 GB needed4.2 GB
Orpheus TTS3B2.2 GB needed4.2 GB
Higgs Audio v23B2.2 GB needed4.2 GB
MusicGen small/medium/large3.3B2.4 GB needed4.4 GB
Stable Diffusion XL3.417B4.1 GB needed6.1 GB
SDXL Turbo3.5B2.6 GB needed4.6 GB
SDXL Lightning3.5B2.6 GB needed4.6 GB

How to read this

The NVIDIA GTX 670 is a legacy graphics card equipped with 2 GB of GDDR5 video memory. This memory size is the absolute limit for running local AI models entirely on the graphics hardware. To load a model successfully, the model files and the active memory space must fit within this 2 GB boundary. If a model exceeds this limit, the system will fail to run it or experience severe performance drops.

To fit modern AI models into this limited space, you must use quantized models. The quantization level indicates how much the model weights are compressed. For example, a Q4_K_M quantization compresses weights to roughly four bits, which allows larger models like the 2.8B Allegro or the 2.7B Open-Sora Plan to fit into exactly 2 GB of used VRAM. Higher quants like Q6_K or Q8_0 offer better accuracy but require more memory per parameter, limiting you to smaller models.

When using Q6_K quantization, you can run models such as the 2B SmolVLM, 2B Stable Diffusion 3 Medium, or 1.9B Moondream 2. These models use up to 2 GB of VRAM. If you choose Q8_0 quantization, the maximum model size drops further. Under Q8_0, you can run the 1.6B StableLM 2, the 1.55B Whisper Large v3, or the 1.1B TinyLlama, which uses 1.4 GB of VRAM.

You can run larger models by offloading parts of the workload to your system RAM. If you have a 32 GB system RAM setup, you can run models that exceed the 2 GB VRAM limit. For example, the 3.5B SDXL Turbo requires 2.6 GB of VRAM at Q4_K_M and 4.6 GB of system RAM. Similarly, the 3.417B Stable Diffusion XL requires 4.1 GB at FP8 and 6.1 GB of system RAM. Offloading allows these models to run, but it costs significant processing speed because system RAM is much slower than GDDR5 video memory.

When running local text models, you must also consider the context window. The memory figures listed here represent the model at its base state. Generating long responses or inputting large prompts increases memory usage. Running a model near the 2 GB limit means you must keep your context window short, typically around 4k tokens, to prevent out of memory errors during generation.