LFM2.5-VL-3B-DSpark Draft Model for Vision-Language Models: 4GB+ VRAM

September 25, 2026November 11, 2026

At a Glance

Values determined by this site’s code when the information was collected. Dates are JST.

What we checked ourselves

• It needs about 7% fewer tokens than the Qwen3 tokenizer for the same Japanese text, so about 1.07× as much Japanese fits in the same context length, and generation is faster per character.

Details and conditions are in “Our Own Measurements” below.

Overview

LiquidAI has released an experimental DSpark draft model named “LFM2.5-VL-DSpark" (repository name: LFM2.5-VL-3B-DSpark) for their vision-language model (VLM) “LFM2.5-VL-3B" on the Hugging Face Blog. This model is designed as a draft model to apply Speculative Decoding to the target model. It was developed aiming to significantly improve inference speed while minimizing memory usage increases and without compromising output quality at all. Decoding speed is reported to improve by up to 3.13x on devices and up to 2.66x on H100, while end-to-end latency achieves speedups of up to 2.62x and 2.27x respectively.

Specifications

The specifications and configuration of the released draft model are as follows. The number of parameters for each configuration component listed in the documentation is also provided.

• Total Parameters: Approx. 280M (279.5M, equivalent to approximately 8.9% of the 3B target model)
• Architecture: Lightweight attention-only draft model with 4 layers (attention-only drafter)
• Block Size: 9 (8 or 9 recommended during inference depending on hardware)
• Component Breakdown:
• Decoder Stack (4 layers): 193.0M – Hidden-state projection: 21.0M – Markov head: 65.5M – LayerNorms + Confidence head: 6.4k

This model adopts an architecture similar to the LFM2.5-DSpark draft model for text. It captures hidden states from specific layers of the target model and uses them as a condition to draft $k$ candidate tokens. Image patches and text tokens are projected into a shared representation prior to these layers, allowing them to be processed as hidden state vectors of the same dimension regardless of the input modality.

Performance

According to measurement results published directly by LiquidAI, applying this draft model confirms notable speedups in both CPU and GPU environments.

Evaluations were conducted using the “MMSpec" benchmark, which includes six diverse vision tasks: general VQA, text VQA, image captioning, chart VQA, complex reasoning, and multi-turn conversation. The measurement results are as follows:

On-Device Inference (Apple Silicon)

• M5 Max (using MLX-VLM, block size 8):
• Decoding speed: 2.30x to 3.13x faster per task – End-to-end latency: 1.56x to 2.62x improvement
• M3 Ultra (using llama.cpp, block size 8):
• Decoding speed: 1.57x to 2.14x faster per task – End-to-end latency: 1.30x to 1.77x improvement

GPU Inference

• NVIDIA H100 (using SGLang, block size 8):
• Decoding speed: 20.4x to 2.66x faster (based on the notation “20.4x to 2.66x" in the original text) – End-to-end latency: 1.64x to 2.27x improvement

Performance Evaluation and Limitations

These measurement results indicate that this model can significantly accelerate decoding processing, particularly on edge devices equipped with Apple Silicon (such as M5 Max and M3 Ultra) and high-end GPU environments like the H100.

On the other hand, limitations specific to vision-language models (VLMs) are also reported. Speculative decoding is a technology that accelerates only the “decoding (generation) stage" and cannot speed up processing by the image encoder or the prefill stage. In VLMs, after images pass through the vision encoder, the language backbone processes hundreds of visual tokens and text prompts, meaning the prefill accounts for a large portion of end-to-end latency. As Amdahl’s Law shows, because the unaccelerated prefill portion becomes a bottleneck, it is important to note that even if decoding speed improves by 3x or more, the overall end-to-end improvement remains modest (around 1.30x to 2.62x).

Strengths and Use Cases

“LFM2.5-VL-DSpark" is a draft model developed to accelerate the decoding (text generation) stage of its target vision-language model, “LFM2.5-VL-3B".

Specifically, it improves inference speed while maintaining output quality across diverse vision tasks combining images and text, such as image captioning, general VQA (Visual Question Answering), text VQA, chart interpretation (chart VQA), advanced multi-step reasoning, and multi-turn dialogue.

This model is released as open weights, allowing for unrestricted downloading, fine-tuning, and deployment. It is particularly suited for use cases where users want to run vision-language models faster across a wide range of environments, from edge devices like Macs (Apple Silicon environments) to data center-grade H100 GPUs.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch) — 279M parameters

Inference engine support (architecture name matched against each project’s own model registry in its source code, checked 2026-11-11): llama.cpp: registered, vLLM: not registered, MLX (mlx-lm): registered. “Not registered" means the name is absent from that registry today, not that the model cannot run.

Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. File sizes are measured from the converted build LiquidAI/LFM2.5-VL-3B-DSpark-GGUF. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.

Our Own Measurements

Values we measured ourselves on our server (no GPU) by actually reading and running this model’s files — not figures copied from the model card. How we measure, and the results for every model: Our Measurements.

Japanese Token Efficiency

It needs about 7% fewer tokens than the Qwen3 tokenizer for the same Japanese text, so about 1.07× as much Japanese fits in the same context length, and generation is faster per character.

Counted with the tokenizer.json of LiquidAI/LFM2.5-VL-3B on a fixed text we wrote ourselves (876 Japanese characters across news, conversation, technical docs, a formal email, travel writing and a recipe) and its English translation. Fewer tokens mean more Japanese fits in the context window.

Inside the GGUF File

File: LFM2.5-VL-3B-DSpark-F16.gguf (0.53GB, F16). We read only the header (metadata) of the file, not the weights.

The quant name in the file name describes the file as a whole; in practice layers mix several types. The average bits per weight is the measured file data divided by the number of weights.

How to Get It

This model is distributed on Hugging Face in both Safetensors and GGUF formats. It is supported out-of-the-box (day-one) across SGLang, llama.cpp, and MLX-VLM inference engines.

Execution steps and command examples for each engine are as follows:

Running with SGLang

Use a build of SGLang that includes DSpark support and launch the server with the following command:

python -m sglang.launch_server \
--model-path LiquidAI/LFM2.5-VL-3B \
--speculative-algorithm DSPARK \
--speculative-draft-model-path LiquidAI/LFM2.5-VL-3B-DSpark \
--speculative-draft-attention-backend flashinfer \
--speculative-dspark-block-size 9 \
--disable-radix-cache

Once launched, you can send queries via the OpenAI-compatible endpoint at http://localhost:30000/v1.

Running with llama.cpp

Using a build of llama.cpp that supports DSpark, load the target model and draft model (-md) with the llama-server command:

llama-server -m models/LFM2.5-VL-3B-F16.gguf \
--mmproj models/mmproj-LFM2.5-VL-3B-F16.gguf \
-md LFM2.5-2.6B-DSpark-F16.gguf \
--spec-type draft-dspark --spec-draft-n-max 8 --spec-draft-n-min 0 \
-fa on -ngl 99 -c 8192

Running with MLX-VLM

In a build environment supporting MLX-VLM, run the mlx_vlm.server command specifying the target model and draft model:

mlx_vlm.server --model LiquidAI/LFM2.5-VL-3B --draft-model LiquidAI/LFM2.5-VL-3B-DSpark

Note that since speculative decoding using this draft model verifies all proposed tokens on the target model side, the output quality is completely identical to running the target model standalone.

Quantized and Converted Variants

File sizes of each build:

• Available builds in LiquidAI/LFM2.5-VL-3B-DSpark-GGUF: F16 0.5GB

In addition, 2 converted build(s) from other uploaders exist on Hugging Face; this site lists only builds from the model’s publisher or established quantization maintainers.

This section is appended automatically by Local Model Watch when a converted build of this model appears after publication. Memory figures are estimated from the size of the distributed files. What the quantization names mean: glossary.

Related Articles

• Run GGUF Models Directly in Transformers with llama.cpp Support

What to Read Next

• Find models by VRAM (This model runs from the 4GB tier) → Other models that run on a 8GB GPU
• Explore the same model family → LFM2.5-VL family overview (1 articles, 1 converted builds)
• Formats this model is available in → GGUF format guide and models
• Learn about the publisher → Liquid AI: models, licenses and articles
• Other models for the same task → Other vision-language models

Sources

• https://huggingface.co/blog/LiquidAI/lfm2-5-vl-dspark

Update History

• 2026-09-25: Added converted builds to “Quantized and Converted Variants”: LiquidAI/LFM2.5-VL-3B-DSpark-GGUF
• 2026-09-25: Updated the hardware requirements table with the actual file sizes of LiquidAI/LFM2.5-VL-3B-DSpark-GGUF.
• 2026-09-25: Changed the title to show what the article covers (VRAM requirements, file list, etc.).
• 2026-09-27: Updated the hardware requirements table with the actual file sizes of LiquidAI/LFM2.5-VL-3B-DSpark-GGUF.
• 2026-09-28: Added our own measurements: Japanese token efficiency.
• 2026-09-29: Updated the hardware requirements table with the actual file sizes of LiquidAI/LFM2.5-VL-3B-DSpark-GGUF.
• 2026-10-01: Updated the hardware requirements table with the actual file sizes of LiquidAI/LFM2.5-VL-3B-DSpark-GGUF.
• 2026-10-03: Updated the hardware requirements table with the actual file sizes of LiquidAI/LFM2.5-VL-3B-DSpark-GGUF.
• 2026-10-05: Updated the hardware requirements table with the actual file sizes of LiquidAI/LFM2.5-VL-3B-DSpark-GGUF.
• 2026-10-06: Added our own measurements: what is inside the GGUF file.
• 2026-10-07: Updated the hardware requirements table with the actual file sizes of LiquidAI/LFM2.5-VL-3B-DSpark-GGUF.
• 2026-10-09: Updated the hardware requirements table with the actual file sizes of LiquidAI/LFM2.5-VL-3B-DSpark-GGUF.