September 2026

By Davide Ciffa

Vision LLM inference: Lucebox has 3.2x the throughput of NVIDIA DGX Spark

We sent the same charts and diagrams, with the same questions, to a Lucebox and to an NVIDIA DGX Spark running llama.cpp. At the highest load each machine served, the Lucebox answered 58 image questions a minute and the DGX Spark 18: Qwen3.8-27B on the Lucebox's AMD Radeon AI PRO R9700, and at the same time the 284B-parameter DeepSeek V4 Flash Vision on its second chip, the Ryzen AI MAX+ 395 (Strix Halo). With the same Qwen model file and the same eight questions, the R9700 alone finishes 2.4x sooner.

TL;DR

• One Lucebox answers 58 image questions a minute; the DGX Spark 18. Each at the highest load it served: Qwen3.8-27B with 16 users on the R9700 plus DeepSeek V4 Flash Vision with 4 users on the Strix Halo, against Qwen with 8 users on the DGX Spark, which cannot load both. Even counting only Qwen, the Lucebox answers 2.8x more.
• Qwen3.8-27B vision is 2.1x to 2.5x faster than on the DGX Spark. Same GGUF, projector and drafter weights, 12 charts and diagrams, 256-token answers. One user: 3.7 s vs 7.7 s. Four users: 6.0 s vs 15.0 s. Eight users: 10.5 s vs 25.4 s.
• Most of the time goes into writing the answer. Each token of it reads all of the weights, and the R9700 reads them at 640 GB/s against the DGX Spark's 273 GB/s.
• The 284B DeepSeek V4 Flash Vision runs on the Strix Halo at the same time, its images encoded on the R9700. At the highest load each machine served, the whole Lucebox answers 58 image questions a minute (52 from Qwen, 6 from DeepSeek); the DGX Spark answers 18 with Qwen alone and cannot load both. The DGX Spark is still faster at DeepSeek alone: 24.6 s vs 37.9 s for four answers.
• Several people can use DeepSeek at once. A new image question used to stop every other DeepSeek user for its whole prompt, 25 s in our test. The engine now spreads that work over the batch a few layers at a time, and the longest pause is 0.71 s.

Same image, same question, two machines

We sent both machines the same 12 images from two public benchmarks, six ChartQA charts and six AI2D science diagrams, with the question explain what this chart shows or explain this diagram step by step, and let each write a 256-token answer. Both ran Qwen3.8-27B from the same GGUF file (Qwen3.8-27B-IQ4_XS-pure.gguf), the same Q8_0 vision projector and the same DFlash2 speculative drafter weights, greedy, thinking off, the image capped at 1,024 tokens. The DGX Spark ran llama.cpp's llama-server, built for its GB10 on the day, with its DFlash drafter mode; the Lucebox ran luce_server on the R9700.

Every one of the 12 images is faster on the Lucebox, from 1.65x to 2.45x. The answers are the same model's answers: on the 220-question AI2D and ChartQA set the R9700 scores 188 correct with the drafter and 188 without it.

Why the R9700 wins this workload

An image question is short to read and long to answer. The diagram in the video costs 198 prompt tokens including the image; the answer is 256 tokens, and every step of writing it reads the model's 14.5 GB of weights. That makes it a memory-bandwidth problem, and the R9700's GDDR6 moves 640 GB/s against the DGX Spark's 273 GB/s of LPDDR5X. The speculative drafter multiplies whichever bandwidth you have: DFlash2 guesses a block of tokens and the target checks them in one pass. With several users the engine drafts shorter blocks per user, eight tokens instead of sixteen, so the batch stays bandwidth-bound instead of compute-bound.

The second chip: a 284B vision model

The R9700 has 32 GB. DeepSeek V4 Flash Vision does not fit in it; it lives in the Strix Halo's 128 GB of unified memory, as a 100 GB file in our own ROCmFPX MIX format, calibrated with a per-expert importance matrix. Against the original weights it measures a KL divergence of 0.464, lower than the 0.511 of the community Q2_K_S file of the same size, and it lands within a few questions of that file on the image benchmarks (181 against 183 of 220).

The two chips work on the same question. DeepSeek's image encoder runs on the R9700, which is twice as fast at it, and streams each image into the Strix Halo the moment it is encoded, so the Strix Halo reads image one while the R9700 encodes image two. The more images in the question, the more of the encoding disappears behind the reading.

Both at once

Then we ran both models together on one Lucebox: Qwen3.8-27B vision with eight users on the R9700, DeepSeek V4 Flash Vision with four users on the Strix Halo, its images encoded on the R9700 as well. Each kept most of its own speed, because each chip has its own memory and its own compute. The R9700 gives up 12% to the DeepSeek encoder it hosts; the Strix Halo gives up 1%.

Then we pushed both machines to the highest load they would serve. The R9700 takes 16 Qwen users at once (24 do not fit in its 32 GB) and answers 55.6 image questions a minute on its own. The DGX Spark answered 18.3 a minute with 8 users; with 16, llama.cpp stopped processing the image requests in two attempts, so 8 is the highest load we could measure there. With Qwen at 16 users and DeepSeek at 4, both at once, the Lucebox answers 58 image questions a minute: 51.7 from Qwen, 6.4 from DeepSeek. That is 3.2x the DGX Spark's 18.3, and counting only Qwen, 2.8x its answers with the same model file while the Lucebox also serves the 284B model.

At eight users, the load of the chart above, the two models together answer 47 a minute: 41 from Qwen, 6 from DeepSeek. On the DGX Spark each model alone does 19 (Qwen, eight users) and 10 (DeepSeek, four users). We also tried to load both on the DGX Spark: with DeepSeek V4 Flash Vision resident, about 23 GB of its 121 GB remain, and llama.cpp's own memory fitter rejected Qwen at the eight-user settings the Lucebox runs next to it.

Several users on the 284B model

A text request joins the batch a few tokens at a time, so everyone else keeps writing. A DeepSeek image cannot: every row of an image block attends to every other row, so the whole block has to go through each layer at once, and on the Strix Halo that is about 3.5 s per image. The engine used to run the whole prompt in one step, and every other user stopped until it was done. It now splits the work by layer instead of by row: each step runs a few of the model's 43 layers for the waiting image, then everyone decodes. The answer is identical to running the prompt in one go; only the waiting changes.

Where the DGX Spark still wins

DeepSeek V4 Flash Vision on its own, four users at once: the DGX Spark finishes four image answers in 24.6 s, the Lucebox in 37.9 s. Decoding is close, 44 against 38 tok/s for the four users together, because the two machines have similar memory bandwidth. The difference is reading the prompts. Four image prompts take the Strix Halo about 7 s and the DGX Spark's GPU about 2. Letting other users keep writing while those prompts are read also costs a little: before that change, the same four answers took 35.2 s. The next step is to put the R9700's compute into reading DeepSeek's prompts.

Hardware and setup

# Lucebox: Qwen3.8 vision on the R9700, eight users
luce_server Qwen3.8-27B-IQ4_XS-pure.gguf --target-device hip:0 \
  --draft Qwen3.8-27B-DFlash2-Q8_0.gguf --draft-device hip:0 --draft-block-size 8 \
  --cache-type-k q8_0 --cache-type-v q8_0 --mmproj Qwen3.8-27B-mmproj-Q8_0.gguf \
  --paged-attention --max-concurrency 8 --max-ctx 8192

# Lucebox: DeepSeek V4 Flash Vision on the Strix Halo, images encoded on the R9700
luce_server DeepSeek-V4-Flash-Vision-Exp-ROCMFPX-MIX-STRIX.gguf \
  --target-device hip:1 --mmproj-device hip:0 \
  --paged-attention --max-concurrency 4 --kv-pool-tokens 24576 --max-ctx 8192 \
  --ds4-prefill exact --prefix-cache-slots 0 --ds4-expert-top-k 6 \
  --mmproj DeepSeek-V4-Flash-Vision-Exp-mmproj-BF16.gguf

# DGX Spark: llama.cpp, same Qwen files, eight slots
llama-server -m Qwen3.8-27B-IQ4_XS-pure.gguf --mmproj Qwen3.8-27B-mmproj-Q8_0.gguf \
  -ngl 999 -np 8 -c 65536 -fa on -ctk q8_0 -ctv q8_0 --image-max-tokens 1024 --temp 0 \
  --spec-type draft-dflash -md Qwen3.8-27B-DFlash2-Q8_0.gguf -ngld 999 --spec-draft-n-max 7

Bottom line

Most of the time in an image question goes into writing the answer, and that is limited by memory bandwidth. The R9700 has more than twice the DGX Spark's, which is why Qwen3.8-27B answers 2.1x faster for one user and 2.4x faster for eight from the same model file. The Strix Halo next to it holds a 284B vision model at the same time, fed by the R9700's image encoder, and several people can share it without waiting on each other. The DGX Spark still reads DeepSeek's prompts faster, and that is what we are working on next.

All numbers measured by us on September 22 to 25, 2026, on one Lucebox and one DGX Spark, with the same images and questions on both and the same Qwen3.8-27B files; for DeepSeek V4 Flash Vision each machine ran the file listed in the setup table. Times are wall-clock from request to the last streamed token, prompt caching off, one run per configuration after a warm-up request. Qwen single-user times average 12 images; concurrent runs send different ChartQA charts. The DGX Spark drafter setting (7 draft tokens) is llama.cpp's; we did not tune it.

Related

• Qwen3.8-27B on the AMD R9700: up to 227 tok/s
• Lucebox (AMD Radeon AI PRO R9700 + Strix Halo) Beats NVIDIA DGX Spark by 3.63x on DeepSeek V4 Flash Decode Speed
• ROCm beats Vulkan on Strix Halo