Best Local LLMs With Vision and Video Understanding for Consumer GPUs (November 2026)

Local AI is no longer text only. In 2026 you can run models on a gaming PC that read screenshots, charts, receipts and handwriting, compare several photos, and even watch a video clip and tell you what happens and when, all without sending a single file to the cloud. The hard part is choosing: some “vision” models only see still images, some handle real video, and the sizes range from 2 GB to more than 20 GB. This guide ranks the best local LLMs with vision and video understanding for consumer GPUs as of November 2026, shows which one fits 8, 12, 16, 24 and 32 GB cards, which GGUF quant to download, and exactly how to run them for images and video with Ollama and llama.cpp.

Quick Picks by GPU

Rule of thumb: the model file should be 1.5 to 3 GB smaller than your VRAM, because the vision projector and the extra tokens from images and video need room too.

All Models Compared

“Native video” means the model was trained on video and its runtime samples frames with timestamps. “Frames” means it sees video only as a set of still images you supply.

Sizes are the default 4-bit downloads from Ollama, LM Studio or the official GGUF repos. The Qwen3-Omni figure is calculated from its parameter count (30.5B x about 4.85 bits / 8), not a listed file size.

Image Vision vs Real Video Understanding

Almost every model here can describe a photo. Video is where they differ:

• Native video models (Qwen3.8, Qwen3.6, Qwen3-VL, MiniCPM-V 4.7, LFM3-VL, Qwen3-Omni) were trained on clips. They take frames sampled at a fixed rate with timestamps, so they can answer “when does the dog jump?” with a time, follow actions across frames, and summarise long clips. Qwen’s model pages talk about hour-long and two-hour videos, though on a consumer GPU you will process much shorter clips.
• Image-only models (Gemma 4, Muse Glimmer) can still look at a set of frames you pull from a video, and often do a reasonable job of describing what changes, but they have no built-in sense of time.
• Omni models (Qwen3-Omni, LFM3-Omni) also hear the soundtrack, so they can tell you what was said as well as what was shown.

The runtime matters as much as the model. llama.cpp now accepts a video file directly: it uses ffmpeg to sample frames (4 fps by default, adjustable with --video-fps), adds timestamps, and for Qwen-VL style models merges neighbouring frames to save tokens. Ollama‘s API takes still images only; its embedding docs even state that video is not accepted. With Ollama you extract frames yourself and send them as several images, which works but loses the timing.

The Best Models in Detail

1. Qwen3.8 27B: best all-rounder for 24 GB

Released on August 14, 2026, Qwen3.8 27B is the open-weight member of Alibaba’s Qwen3.8 family (the other is a 2.4T-parameter giant). It has native image and video understanding, a 256K context, thinking mode that you can turn off, and an Apache 2.0 licence. It is strong at documents, charts, STEM diagrams, screenshots and multi-image comparison.

• Ollama: ollama run qwen3.8:27b (18 GB). A Q8_0 build (qwen3.8:27b-q8_0, 30 GB) suits a 32 GB card.
• Fits: 24 GB cards comfortably; 16 GB only with heavy offloading, which is slow because it is a dense model.
• Best for: the highest local quality for images and video if you own a 24 GB card.

2. MiniCPM-V 4.7 35B-A3B: best for 16 GB

OpenBMB’s October 2026 release is a 35B mixture-of-experts model with only about 3B parameters active per token, so it is fast for its size. It reads single images, multiple images, documents and video, and it uses mostly linear attention, which keeps the memory used by long contexts small. Official GGUFs work in Ollama and llama.cpp.

• 16 GB: IQ3_XS (14.5 GB) or IQ3_M (15.4 GB), or Q4_K_M with some experts in system RAM.
• 24 GB: Q4_K_M (21.2 GB).
• Run: ollama run hf.co/openbmb/MiniCPM-V-4.7-35B-A3B-gguf:IQ3_XS

Full details and settings are in our MiniCPM-V 4.7 local guide.

3. Qwen3.6 35B-A3B and 27B: strong video, great with offload

Released in April 2026, Qwen3.6 brought native image and video input to Qwen’s main line. The 35B-A3B MoE (23 GB at 4-bit) is the one to pick on a 16 GB card with 32 GB or more of system RAM, because llama.cpp can keep its experts in RAM and the rest on the GPU. The dense 27B (18 to 19 GB) is simpler on 24 GB, though Qwen3.8 27B has now replaced it as the first choice.

• Ollama: ollama run qwen3.6:35b or qwen3.6:27b
• llama.cpp: Unsloth GGUFs (unsloth/Qwen3.6-35B-A3B-GGUF) with the mmproj-F16.gguf vision file.
• Recommended sampling (non-thinking): temperature 0.7, top_p 0.8, top_k 20, presence penalty 1.5.

4. Gemma 4: best image model family, every size

Google’s Gemma 4 covers every GPU: E2B and E4B for laptops (they also take audio), a 12B for mid-range cards, a 26B-A4B MoE and a 31B dense model for big cards. All are Apache 2.0 and very good at describing photos, reading text in images and answering questions about charts. Gemma 4 does not list video as an input; you give it frames.

• Ollama: gemma4:e4b, gemma4:12b, gemma4:26b, gemma4:31b
• llama.cpp: ggml-org/gemma-4-E4B-it-GGUF, ggml-org/gemma-4-26B-A4B-it-GGUF, ggml-org/gemma-4-31B-it-GGUF
• Tip: QAT (quantization-aware training) versions keep more quality at 4-bit; pick them when offered.

5. Qwen3-VL: the dependable small and mid-size choice

Qwen3-VL (late 2025) is still one of the best-supported vision families in Ollama, with sizes for almost any GPU: 2B (1.9 GB), 4B (3.3 GB), 8B (6.2 GB), 30B-A3B (20 GB) and 32B (21 GB). Its model page describes long-video understanding with answers down to the second, so it is the natural pick for video on 8 to 12 GB cards.

• Run: ollama run qwen3-vl:8b
• Newer alternative: the small Qwen3.5 models (qwen3.5:9b 6.6 GB, qwen3.5:4b, qwen3.5:2b, qwen3.5:0.8b) are newer and strong on images. Ollama lists only text and image input for them, so for video Qwen3-VL is still the safer small choice.

6. LFM3-VL-2B and LFM3-Omni-2B: best for laptops

Liquid AI’s October 27, 2026 models are tiny but surprisingly capable, especially for documents and screens (96.7 on DocVQA and 94.6 on ScreenSpot-v2 Desktop according to Liquid AI). LFM3-VL samples video at 2 fps (4 to 768 frames), and LFM3-Omni also listens to the audio track, which llama.cpp supports directly. They run well on CPUs. The licence is free for commercial use only for organisations under $10 million a year in revenue.

• Run: llama-server -hf LiquidAI/LFM3-VL-2B-GGUF:Q4_0 --temp 0.1

See our LFM3 guide for all six models.

7. Muse Glimmer 30B: Meta’s image model for agents

Meta’s August 2026 release is a 30B dense model with a 1.8B vision encoder, a 128K context and an Apache 2.0 licence. It is built for on-device agents rather than video, and takes images but not video. At about 18 GB in 4-bit (ollama run muse-glimmer:30b) it fits a 24 GB card. Independent testing by Artificial Analysis found a high hallucination rate on knowledge questions, so check its answers on facts.

8. Qwen3-Omni 30B-A3B: video with sound

If you want a model that watches and listens, Qwen3-Omni takes text, images, audio and video. llama.cpp lists ready GGUFs (ggml-org/Qwen3-Omni-30B-A3B-Instruct-GGUF) in its multimodal docs, where it is grouped with the audio-capable models; check that your build handles its video input before relying on it, or use LFM3-Omni for sound-plus-video on small machines. As a 3B-active MoE it is fast, and on 16 GB cards it works with expert offload.

9. Qwen3.8-Flash-Next: the most capable, if you have 96 GB or more of memory

Released on August 26, 2026, Qwen3.8-Flash-Next is Alibaba’s preview of the Qwen4 architecture. It is a multimodal mixture-of-experts model with 125B parameters (plus 51B n-gram embedding parameters), but only about 6B are active per token. On Alibaba’s own benchmarks it beats much larger models at coding and reasoning (GPQA Diamond 91.7, LiveCodeBench v6 91.9). Qwen’s README lists llama.cpp support for text and vision, and Ollama’s model page describes native video understanding. Qwen has not yet published vision or video benchmarks for it, so treat its visual skills as promising rather than proven.

It is not a single-GPU model. Even the 1-bit GGUF is 72.5 GB, and Unsloth recommends about 96 to 114 GB of combined RAM and VRAM for 4-bit. Because only 6B parameters are active, it still runs on a gaming PC with a lot of system RAM: keep the attention layers on the GPU and the experts in RAM.

• Quants (Unsloth): UD-Q2_K_XL 78.9 GB, UD-Q3_K_XL 90 GB, UD-IQ4_XS 93.7 GB, UD-Q4_K_XL 111.3 GB.
• Fits: a 16 to 32 GB GPU with 96 to 128 GB of system RAM, a 128 GB Mac (Ollama has an MLX build, ollama run qwen3.8-flash-next:125b-mlx, 105 GB), or a DGX Spark.
• llama.cpp: llama-server -hf unsloth/Qwen3.8-Flash-Next-GGUF:UD-Q3_K_XL -c 32768 -ngl 99 --n-cpu-moe 99, then lower --n-cpu-moe until your VRAM is nearly full. If images are ignored, download the repo’s mmproj file and add --mmproj.
• Sampling: thinking mode temperature 1.0, top_p 0.95, top_k 20; non-thinking temperature 0.7, top_p 0.8, presence penalty 1.5.
• License: Qwen Community License 1.0, not Apache 2.0, so read the terms before commercial use.

Estimate for an RTX 5080 (16 GB) with 128 GB of DDR5: UD-Q3_K_XL with the experts in RAM should give a few tokens per second, fine for batches of image questions but slow for video. This is an estimate, not a measured result.

10. NVIDIA Nemotron 3 Nano Omni 30B-A3B: images, video and audio in one model

NVIDIA released Nemotron 3 Nano Omni on April 28, 2026. It is a 30B mixture-of-experts model with 3B active parameters and a 256K context, and it takes text, images, documents, audio and video, with text output. It is built for multimodal agents, and it has a thinking mode (temperature 0.6, top_p 0.95) and an instruct mode (temperature 0.2).

• Memory: about 25 GB for 4-bit and 36 GB for 8-bit, according to Unsloth. That is a tight fit on a 24 GB card, or works on 16 GB with expert offload.
• Images in llama.cpp: llama-server -hf unsloth/NVIDIA-Nemotron-3-Nano-Omni-30B-A3B-Reasoning-GGUF:UD-Q4_K_XL --temp 0.6 --top-p 0.95
• Video and audio: mainline llama.cpp currently documents image input only for this model. Community GGUFs with working audio and video run on a llama.cpp fork (engram-ae/llama.cpp-omni).
• Ollama: Unsloth notes that its vision GGUFs do not work in Ollama because of the separate mmproj file, so use llama.cpp or LM Studio.
• License: NVIDIA Open Model License.
• Tip: Unsloth warns against CUDA 13.2, which can produce gibberish output with this model.

How Much VRAM Vision Really Needs

A vision model needs more memory than a text model of the same size, for three reasons:

• The vision projector (mmproj). A separate file, usually a few hundred MB to about 1 GB, that turns pixels into tokens. It is loaded on the GPU by default.
• Image tokens. Each image becomes hundreds to a few thousand tokens depending on resolution, and those tokens fill the KV cache like text does.
• Video tokens. A clip is many images. Estimate for a native video model: a 30-second clip at 2 fps is 60 frames, and at roughly 100 to 300 tokens per frame after merging that is about 6,000 to 18,000 tokens. This is an estimate, not a measured result; real numbers depend on the model and resolution.

So set a context of at least 16K for multi-image work and 32K or more for video, and budget the memory for it. Our KV cache table shows how fast context memory grows, and quantizing the cache to q8_0 halves it.

Estimate for a 16 GB card like the RTX 5080: MiniCPM-V 4.7 at IQ3_XS (14.5 GB) plus its projector leaves room for roughly a 16K context, enough for several images or a short clip at 1 fps. Gemma 4 12B (7.4 GB) leaves plenty of room for 32K or more. This is an estimate, not a measured result.

Which Quant to Download

• Q4_K_M is the default and the right choice for most models.
• Q5_K_M, Q6_K or Q8_0 are worth it for small models (under about 8B), where every bit counts for reading small text in images.
• IQ3_XS / IQ3_M are the way to fit a big MoE model such as MiniCPM-V 4.7 into 16 GB.
• Keep the mmproj file at F16 or BF16. Quantizing the vision projector saves little memory and can hurt OCR and fine detail.
• MoE models (MiniCPM-V 4.7 35B-A3B, Qwen3.6 35B-A3B, Gemma 4 26B-A4B, Qwen3-Omni) can exceed your VRAM: keep experts in system RAM with llama.cpp’s --n-cpu-moe.

For a full explanation of quant names and sizes, see GGUF quantization explained.

Run Vision Models With Ollama

Update Ollama first, since new vision architectures need recent builds. Then:

ollama run qwen3.8:27b
>>> What does this chart show? ./chart.png

Put the image path inside your message, and you can include several paths for multi-image questions. For a one-shot answer:

ollama run gemma4:12b "Read the total on this receipt ./receipt.jpg"

From the API, send base64 images in the images array:

IMG=$(base64 < photo.jpg | tr -d '\n')
curl http://localhost:11434/api/chat -d '{
  "model": "qwen3-vl:8b",
  "messages": [{"role": "user", "content": "Describe this photo", "images": ["'"$IMG"'"]}],
  "stream": false,
  "options": {"num_ctx": 16384}
}'

Raise num_ctx, because Ollama’s default is only 4,096 tokens on GPUs under 24 GB, which a couple of high-resolution images can fill. Models from Hugging Face run the same way, for example ollama run hf.co/openbmb/MiniCPM-V-4.7-35B-A3B-gguf:Q4_K_M. More commands are in our Ollama cheat sheet.

Run Vision Models With llama.cpp

llama.cpp gives you the most control and the best video support. With -hf, the model and its vision projector download automatically:

# Server with a web UI at http://localhost:8080 (drag images or videos into the chat)
llama-server -hf ggml-org/gemma-4-26B-A4B-it-GGUF -c 16384 -ngl 99 --port 8080

# One question about an image
llama-cli -hf LiquidAI/LFM3-VL-2B-GGUF:Q4_0 --image receipt.png -p "Extract the line items as JSON"

For a local GGUF, pass the model and projector separately:

llama-server -m Qwen3.6-35B-A3B-UD-Q4_K_XL.gguf --mmproj mmproj-F16.gguf -c 32768 -ngl 99 --n-cpu-moe 10

• --n-cpu-moe 10 keeps the experts of 10 layers in system RAM for MoE models; raise it until the model fits.
• --no-mmproj-offload keeps the projector on the CPU if you are a few hundred MB short.
• -fa on -ctk q8_0 -ctv q8_0 halves context memory.

How to Analyse Video Locally (Step by Step)

Option A: llama.cpp with a video file (recommended)

1. Install ffmpeg and make sure ffmpeg and ffprobe are on your PATH (or point to them with --video-ffmpeg-dir).
2. Use a recent llama.cpp build and a native video model (Qwen3-VL, Qwen3.6, MiniCPM-V 4.7 or LFM3-VL).
3. Ask a question about the clip:

llama-cli -hf ggml-org/Qwen3.6-35B-A3B-GGUF --video clip.mp4 --video-fps 2 -c 32768 -ngl 99 --n-cpu-moe 10 -p "Summarise this video and list key events with timestamps"

--video-fps sets how many frames per second are sampled (default 4). Use 1 to 2 for long clips to save tokens, and 4 or more for fast action. --video-timestamp-interval controls how often time markers are added (default every 5 seconds). Some models fix their own rate; LFM3-VL always samples at 2 fps.

To send video to llama-server from code, use the OpenAI-style chat endpoint with an input_video part:

import base64, requests
data = base64.b64encode(open("clip.mp4", "rb").read()).decode()
r = requests.post("http://localhost:8080/v1/chat/completions", json={
    "messages": [{"role": "user", "content": [
        {"type": "input_video", "input_video": {"data": data}},
        {"type": "text", "text": "What happens in this clip? Give timestamps."}
    ]}]
})
print(r.json()["choices"][0]["message"]["content"])

For local file paths instead of base64, start the server with --media-path and prefix the path with file://, as the llama.cpp server docs describe.

Option B: Ollama with extracted frames

Ollama does not take video, so pull still frames with ffmpeg and send them as images:

mkdir frames
ffmpeg -i clip.mp4 -vf "fps=1,scale=768:-2" frames/f_%03d.jpg

import glob, ollama
frames = sorted(glob.glob("frames/*.jpg"))[:16]
r = ollama.chat(model="qwen3-vl:8b", messages=[{
    "role": "user",
    "content": f"These are {len(frames)} frames taken 1 second apart from one video. Describe what happens, in order.",
    "images": frames
}], options={"num_ctx": 32768})
print(r.message.content)

Keep it to about 8 to 16 frames on 8 to 16 GB cards, and tell the model how far apart the frames are, because it has no other way to know.

Estimate for a 16 GB card like the RTX 5080: a 30-second clip at 1 fps with Qwen3-VL 8B should take on the order of 10 to 30 seconds to process before the answer starts, mostly encoding the frames. This is an estimate, not a measured result.

Best Model for Each Job

Tips for Better Results

• Ask specific questions. “List every product and price on this receipt as JSON” works far better than “What is this?”.
• Use a lower temperature for reading tasks (0.1 to 0.3) and the model card’s settings for chat.
• Turn thinking off for simple image questions on Qwen models; it is faster and rarely changes the answer. Leave it on for charts and maths.
• Crop before you ask. A cropped table or paragraph gives the model more pixels per character than a full-page photo.
• For video, lower the frame rate before the resolution. 1 to 2 fps is plenty for talking-head or tutorial clips.
• Split long videos into 30 to 60 second parts on consumer GPUs, then ask the model to combine the summaries.
• Check facts. Vision models still invent details, especially small text and numbers. Verify anything important.

Troubleshooting

FAQ

What is the best local vision model in 2026?

For a 24 GB GPU, Qwen3.8 27B is the best all-round choice for images and video. On 16 GB, MiniCPM-V 4.7 35B-A3B is the strongest that fits, and Gemma 4 12B is the best balance for 12 GB.

Can a local LLM watch videos?

Yes. Native video models such as Qwen3.8, Qwen3.6, Qwen3-VL, MiniCPM-V 4.7 and LFM3-VL can analyse video clips. llama.cpp accepts video files directly; with Ollama you send extracted frames.

Does Ollama support video input?

Not directly. Its API accepts still images. Extract frames with ffmpeg and send them as several images, or use llama.cpp for real video input.

What is the best vision model for 8 GB VRAM?

Qwen3-VL 8B at Q4 (6.2 GB) with a modest context, or Gemma 4 E4B. For very small machines, LFM3-VL-2B.

Can I run these on a Mac?

Yes. Ollama, LM Studio and llama.cpp run them on Apple Silicon, and the larger unified memory means a 32 GB Mac can run models that need a 24 GB GPU on a PC. Ollama also offers MLX builds for some models, such as qwen3.8:27b-mlx.

Are these models free for commercial use?

Qwen, Gemma 4, MiniCPM-V 4.7 and Muse Glimmer are Apache 2.0. LFM3 uses Liquid AI’s own licence, which is free commercially only for organisations under $10 million in annual revenue.

Final Thoughts

Local vision AI has reached the point where a single gaming GPU can read documents, understand charts and summarise video clips privately. Pick by VRAM: Qwen3.8 27B on 24 GB, MiniCPM-V 4.7 on 16 GB, Gemma 4 12B or Qwen3-VL 8B on 8 to 12 GB, and LFM3-VL on laptops. For video, use llama.cpp with a native video model and keep the frame rate low; for quick image questions, Ollama is the easiest way in.

Related guides:

• How to Run MiniCPM-V 4.7 Locally
• Liquid AI LFM3: Run It Locally
• GGUF Quantization Explained
• Ollama Commands Cheat Sheet
• Can You Run Muse Spark Open Locally?
• Best Local AI Video Generation Models

Sources

• Ollama: qwen3.8, qwen3.6, qwen3-vl and gemma4 model pages
• GitHub: QwenLM/Qwen3.8 and Qwen3.6-27B model card
• Unsloth: Qwen3.6 local guide
• LM Studio: Gemma 4
• Artificial Analysis: Muse Glimmer
• llama.cpp multimodal docs and server README (video input options)
• Ollama API reference
• GitHub: QwenLM/Qwen3.8-Flash-Next, Unsloth: Qwen3.8-Flash-Next guide and Ollama: qwen3.8-flash-next
• Unsloth: Nemotron 3 Nano Omni guide and Ollama: qwen3.5