Can You Run DeepSeek V4 Flash Vision Exp Locally?
Published August 27, 2026. Model facts are from DeepSeek's API documentation; hardware specifications come from our GPU database.
Short answer: not officially — yet. DeepSeek V4 Flash Vision Exp is the experimental model that adds image input to V4 Flash, and as of August 27, 2026 DeepSeek offers it only through the API. No official weights have been published on Hugging Face. The practical local route today is the community vision stack bolted onto the MIT-licensed DeepSeek-V4-Flash-0731 base — same idea, not same weights — and that base runs on more hardware than you might expect: 256 GB Mac Studios outright, 128 GB unified-memory boxes on the smallest quants, and 24–32 GB GPUs with 128 GB of system RAM via expert offloading. This guide covers what the model is, what a local build requires, expected speeds, and when the API is simply the better answer.
On this page
What is DeepSeek V4 Flash Vision Exp?
DeepSeek V4 Flash Vision Exp (API model name deepseek-v4-flash-vision-exp) is DeepSeek's experimental vision variant of V4 Flash. It accepts images alongside text — describe pictures, read text from screenshots, analyze charts — using the standard OpenAI-compatible chat format, the Anthropic-compatible endpoint, or the Responses API. Supported formats are JPEG, PNG, GIF, and WebP.
The mechanics that matter for cost and hardware:
- Images become tokens. Every image is resized to roughly an 800×800 pixel budget before inference, which caps the cost at an upper bound of 384 tokens per image — a 2000×2000 and a 5000×5000 image bill the same. Images are billed as input tokens.
- Generous limits. Up to 600 images per request, 32 MiB per image (64 MiB via the Files API), up to 8192 px per side. A
detail: lowoption downscales to 512×512 for cheaper processing. - Same engine as V4 Flash. Context is 1M tokens with up to 384K output, thinking mode on by default, and pricing identical to
deepseek-v4-flash. FIM completion is not supported.
The base model underneath is DeepSeek-V4-Flash-0731 — the 284B total / 13B active Mixture-of-Experts we covered in our V4-Flash-0731 hardware guide: 43 layers, 256 experts with 6 activated per token, a single shared KV head, and native FP8 weights.
Specifications at a glance
Local tokens-per-second figures have not been published for either the API model or community builds; the 13B active-parameter count is what keeps CPU-offloaded inference viable at all.
The weights problem: API-only today
DeepSeek's Hugging Face organization has not published a Vision Exp checkpoint — its newest release remains DeepSeek-V4-Pro-0813 (August 13, 2026). The API docs describe the vision model as experimental, which usually precedes an open-weights drop but guarantees nothing.
What exists locally is community work, not the official model. Projects such as FlyCockpit's DeepSeek-V4-Flash-0731-vision publish a "tower + projector" vision stack — a DeepEncoderV2 image tower (~865 MB) plus a projector (~40 MB), about 900 MB total — that splices visual tokens into the upstream 0731 checkpoint. It is Apache-2.0 licensed, explicitly unofficial, and its quality is not DeepSeek's. Treat any local "V4 Flash Vision" as the community's approximation until DeepSeek publishes weights.
Memory requirements for a local build
Because the vision stack rides on the 0731 base, local memory math is the base model's plus ~0.9 GB. The 0731 checkpoint ships natively quantized to FP8 (~167 GB); community GGUF quants (measured file sizes from the Unsloth builds):
| Format | Size on disk | Realistic minimum memory | Notes |
|---|---|---|---|
| UD-IQ1_S (Unsloth) | ~83 GB | ~95 GB incl. overhead + KV | Heavy compression; testing only |
| UD-IQ1_M (Unsloth) | ~87 GB | ~99 GB | Heavy compression |
| UD-Q2_K_XL (Unsloth) | ~97 GB | ~111 GB | Fits 128 GB unified-memory machines |
| UD-Q3_K_M / UD-Q3_K_XL | ~128 GB | ~145 GB | Needs 160 GB-class memory |
| UD-Q4_K_XL | ~155 GB | ~176 GB | Recommended baseline quality |
| UD-Q8_K_XL | ~162 GB | ~184 GB | Near-lossless |
| FP8 (official 0731 checkpoint) | ~167 GB | ~190 GB | Reference quality, vLLM/SGLang |
Add the ~0.9 GB community vision stack for image input, plus KV cache — cheap per token here, since the base model's single-KV-head attention keeps the cache small. The DSpark speculative-decoding draft (~11 GB) speeds up generation on top of any of these.
The 284B-parameter base stores every expert but reads only 13B per token, which splits hardware into three tiers. Tier 1 — fits entirely in VRAM or unified memory: fastest and simplest. Tier 2 — expert offload: a 24–32 GB GPU plus a desktop with enough system RAM; the GPU holds the always-active layers, active experts, and KV cache while inactive experts wait in system memory. Tier 3 — not enough total memory (VRAM + RAM combined): the only hard wall. Best for most self-hosters today: the API. Best local approximation: a 256 GB Mac Studio running the FP8 base plus the community vision stack — or a Tier 2 offload box on a budget.
| Hardware we track | Memory | Verdict for a local vision build |
|---|---|---|
| Mac Studio, M3 Ultra (512 GB) | 512 GB unified | Tier 1 — Comfortable — FP8 base + vision stack + long context |
| Mac Studio, M3 Ultra (256 GB) | 256 GB unified | Tier 1 — Good — FP8 (~167 GB) or UD-Q4_K_XL (~155 GB) with the vision stack |
| MacBook Pro 16″, M5 Max (128 GB) | 128 GB unified (614 GB/s) | Tier 1, tight — UD-Q2_K_XL (~111 GB with overhead) fits; smallest quant only |
| Strix Halo mini-PC (128 GB, e.g. Ryzen AI Max+ 395) | 128 GB unified (~115 GB allocatable) | Tier 1, tight — UD-Q2_K_XL fits; community recipes split 64 GB VRAM / 64 GB RAM in BIOS |
| RTX 5090 (32 GB) + 128 GB system RAM | 160 GB total | Tier 2 — expert offload runs UD-Q2_K_XL and UD-Q3_K_M; ~20–30 tok/s estimated |
| RTX 4090 / RTX 3090 (24 GB) + 128 GB system RAM | 152 GB total | Tier 2 — UD-Q2_K_XL fits; ~27 tok/s estimated; 2× RTX 3090 mixed GPU/CPU is community-verified with -fit |
| 2× RTX 6000 Ada (96 GB) + 64 GB RAM | 160 GB total | Tier 2 — 96 GB of VRAM alone cannot hold any full quant; with system RAM it reaches Q3-class |
| H100 / H200 node | 80-141 GB HBM per card | Production — FP8 base via vLLM/SGLang, multi-GPU |
Tier 2 in practice — the consumer-GPU path: llama.cpp's --n-cpu-moe / -ot "exps=CPU" tensor overrides, KTransformers, or the -fit flag keep inactive experts in system RAM while the GPU processes active experts and the KV cache. For this base model the community has verified the pattern: a 2× RTX 3090 mixed GPU/CPU setup runs the GGUF builds with -fit (HF discussion, August 2026), and Strix Halo 128 GB boxes run a UD-IQ3_S build with a 64 GB VRAM / 64 GB RAM BIOS split (HF discussion, August 2026).
Actually cannot run it: any machine whose total memory (VRAM + RAM combined) is under ~111 GB — a 64 GB Mac, a gaming rig with 32 GB of RAM, a 16 GB laptop. The GPU badge is irrelevant: a 24 GB RTX 4090 with 128 GB of RAM runs the base model, while a 32 GB RTX 5090 in a 32 GB-RAM box does not. For cards working on smaller models, see our best GPU for local LLMs guide.
Expected speed: estimates and community reports
No tokens-per-second benchmark has been published yet for either the 0731 GGUF builds or the community vision stack (checked the Unsloth GGUF discussions and community channels, August 27, 2026). The figures below are therefore calculated estimates, not measurements: memory bandwidth ÷ bytes read per token, where bytes/token = GGUF file size × 13/284 (the active-parameter share). Treat them as ceilings; expert-offload configs are bounded by system-RAM bandwidth (~90 GB/s effective for dual-channel DDR5), and the DSpark speculative-decoding draft (~11 GB) can raise effective speed substantially once supported in your build.
| Configuration | Quant | Est. tok/s (ceiling) | Community reports |
|---|---|---|---|
| Mac Studio M3 Ultra (819 GB/s) | UD-Q4_K_XL | ~115 = 819 ÷ 7.1 GB/token | None published yet |
| RTX 5090 + 128 GB DDR5 (expert offload) | UD-Q2_K_XL | ~30 = ~3 of each token's 4.4 GB active reads from RAM at ~90 GB/s | Feasibility confirmed (2× 3090 -fit); no tok/s published |
| RTX 4090 / RTX 3090 + 128 GB DDR5 (offload) | UD-Q2_K_XL | ~27 (RAM-bound) | Feasibility confirmed; no tok/s published |
| Strix Halo 128 GB (256 GB/s) | UD-Q2_K_XL | ~58 = 256 ÷ 4.4 GB/token | UD-IQ3_S recipe published; no tok/s published |
Buy hardware that runs it
Every pick below was verified live and purchasable on Amazon on August 27, 2026, and maps to a tier from the table above for the 0731 base + community vision stack — including the Tier 2 offload path, where the RAM kit is the enabling component. Links are affiliate links; we may earn a commission at no extra cost to you.
| Pick | Why it runs the 0731 base + vision stack | Expected speed (estimate) | Price check |
|---|---|---|---|
| ASUS ProArt RTX 5090 32 GB | Tier 2 anchor: 32 GB VRAM + 128 GB system RAM = 160 GB total, enough for UD-Q2_K_XL (~111 GB) and UD-Q3_K_M (~145 GB) with the vision stack | ~20–30 tok/s at Q2_K_XL–Q3_K_M (estimate) | Check price at Amazon |
| MSI GeForce RTX 4090 Gaming X Trio 24 GB | Tier 2: 24 GB VRAM + 128 GB system RAM = 152 GB total; UD-Q2_K_XL fits with offload | ~27 tok/s at UD-Q2_K_XL (estimate) | Check price at Amazon |
| NVIDIA RTX 3090 24 GB (renewed) | Budget Tier 2 — and the exact card in the community-verified 2× 3090 -fit report; add the second one later | ~27 tok/s at UD-Q2_K_XL (estimate) | Check price at Amazon |
| Apple MacBook Pro 16″ M5 Max, 128 GB (Early 2026) | Tier 1 laptop: 128 GB unified memory holds UD-Q2_K_XL (~111 GB with overhead); 614 GB/s per Apple's spec page | ~139 tok/s ceiling at UD-Q2_K_XL (614 ÷ 4.4); expect less in practice | Check price at Amazon |
| GMKtec mini PC, Ryzen AI Max+ 395, 128 GB (Strix Halo) | Tier 1 desk box: 128 GB unified holds UD-Q2_K_XL; the community Strix Halo recipe (64 GB VRAM / 64 GB RAM split) targets this platform | ~58 tok/s ceiling at UD-Q2_K_XL (256 ÷ 4.4); expect well under | Check price at Amazon |
| TEAMGROUP T-Create Expert 128 GB (2×64 GB) DDR5-6400 | The Tier 2 enabler: turns an RTX 5090/4090/3090 desktop into an offload box (~102 GB/s dual-channel) | Enables the ~27–30 tok/s offload estimates above | Check price at Amazon |
| NEMIX RAM 256 GB (4×64 GB) DDR5-5600 ECC RDIMM | Climbs Tier 2 to UD-Q4_K_XL / UD-Q8_K_XL (~176–184 GB with overhead) — needs a workstation platform (Threadripper/Xeon/W790) plus a 32 GB GPU | ~15–16 tok/s at Q4_K_XL–Q8_K_XL with a 32 GB GPU (estimate) | Check price at Amazon |
Want the maximum-quality single-box route? A Mac Studio M3 Ultra (256–512 GB) runs the FP8 base plus the vision stack without offload — but no Mac Studio configuration was listed on Amazon when we last checked (August 27, 2026), so we link nothing rather than guess. See our Mac Studio vs PC for AI comparison for the trade-offs.
With no official weights, "running it locally" means serving the 0731 base with the community vision stack. The base model's card lists vLLM, SGLang, and Transformers; GGUF builds run on llama.cpp.
Option 1 — community vision stack + Transformers/vLLM (closest to the API model)
# Fetch the vision stack (~900 MB) and the FP8 base (~167 GB)
hf download FlyCockpit/DeepSeek-V4-Flash-0731-vision --local-dir $HOME/dsv4-vision-assets
hf download deepseek-ai/DeepSeek-V4-Flash-0731 --local-dir $HOME/dsv4-0731
# Serve the base with vLLM, then load the tower + projector per the
# community repo's serving guide (2x DGX Spark recipe published)
vllm serve $HOME/dsv4-0731 --tensor-parallel-size 2 --max-model-len 131072Follow the community repository's own serving instructions for splicing the encoder — the projector expects the 0731 tokenizer's image-placeholder position. This is unofficial tooling: pin versions and verify outputs.
Option 2 — llama.cpp (GGUF base, text-only today)
# 128 GB unified-memory machine; text-only until a vision mmproj lands
llama-server -hf unsloth/DeepSeek-V4-Flash-0731-GGUF:UD-Q2_K_XL \
--ctx-size 16384 --threads -1 --flash-attnA GGUF vision projector (mmproj) for this base has not been published as of August 27, 2026, so llama.cpp builds are text-only for now. Ollama support is likewise not listed on the base model's card — check its library before assuming availability.
API alternative
The API is the only way to use the actual Vision Exp model today, and DeepSeek prices it identically to deepseek-v4-flash: $0.22 per million input tokens off-peak ($0.44 peak), $0.66 per million output tokens off-peak ($1.32 peak), and $0.007-$0.014 per million cached-input tokens, with images billed as input tokens at ≤384 tokens per image. At those prices, a 256 GB Mac Studio pays for itself only through heavy sustained use, privacy requirements, or offline needs — for everyone else the API is the rational default until official weights ship.
Frequently Asked Questions
Can you run DeepSeek V4 Flash Vision Exp locally?
Not officially yet. As of August 27, 2026 DeepSeek offers it only through its API (model name deepseek-v4-flash-vision-exp) and has not published the weights. The practical local route is the community vision stack for the DeepSeek-V4-Flash-0731 base model, which adds a roughly 900 MB vision tower and projector to the existing 0731 checkpoints.
How much memory would a local build need?
The 0731 base model it is built on needs about 167 GB as the official FP8 checkpoint, or 83-162 GB as community GGUF quants, plus roughly 0.9 GB for the community vision stack and KV-cache headroom.
What is DeepSeek V4 Flash Vision Exp?
An experimental DeepSeek API model that adds image input to V4 Flash: it accepts JPEG, PNG, GIF, and WebP images alongside text, converts them to tokens (upper bound 384 tokens per image after resizing), and bills them as input tokens. Context is 1M tokens with up to 384K output.
How much does the DeepSeek V4 Flash Vision Exp API cost?
The same as deepseek-v4-flash: $0.22-$0.44 per million input tokens depending on cache and peak hours, $0.66-$1.32 per million output tokens, and $0.007-$0.014 per million cached-input tokens. Images are billed as input tokens.
What hardware runs the 0731 base locally?
A 256 GB Mac Studio holds the FP8 checkpoint plus the vision stack; 128 GB unified-memory machines run the smaller GGUF quants; and a 24–32 GB GPU with 128 GB or more of system RAM runs the ~111 GB UD-Q2_K_XL build via expert offloading. No configuration needs a datacenter GPU.
Can an RTX 4090 or RTX 5090 run the 0731 base with vision?
Yes, with expert offloading. The GPU holds the always-active layers, active experts, and KV cache; inactive experts sit in system RAM. An RTX 5090 (32 GB) with 128 GB of RAM runs UD-Q2_K_XL and UD-Q3_K_M at an estimated 20–30 tokens per second; an RTX 4090/3090 (24 GB) with 128 GB of RAM runs UD-Q2_K_XL. Community reports confirm 2× RTX 3090 mixed GPU/CPU inference works with llama.cpp's -fit flag.
Sources
Model facts are from DeepSeek's API documentation; base-model configuration is from the official Hugging Face model card; quantization sizes are measured file sizes from the published GGUF repositories; hardware figures come from our GPU specification database. Checked August 27, 2026.
- DeepSeek API docs — Models & Pricing (deepseek-v4-flash-vision-exp row) and Vision guide (formats, limits, 384-token image bound)
- Base model card deepseek-ai/DeepSeek-V4-Flash-0731 — MIT license, FP8 checkpoint, config (43 layers, 256 experts/6 active)
- GGUF repository: Unsloth DeepSeek-V4-Flash-0731-GGUF (UD quant file sizes)
- Community feasibility reports: 2× RTX 3090 mixed GPU/CPU with -fit and Strix Halo 128 GB UD-IQ3_S recipe (August 2026); no tokens-per-second benchmarks published as of August 27, 2026
- Amazon product availability and affiliate links — checked live August 27, 2026 via our affiliate proxy (api.petergedeon.com)
- Community vision stack: FlyCockpit/DeepSeek-V4-Flash-0731-vision — unofficial tower + projector (~900 MB)
- Our GPU database — Mac Studio M3 Ultra, Strix Halo, RTX PRO 6000 Blackwell, RTX 6000 Ada, H100/H200 records
Affiliate Disclosure: CompareAIHardware.com earns commissions from purchases made through links on this page. This does not affect our editorial content or recommendations.