llama.cpp Merges DFlash 2 Support for Up to 2x Faster Speculative Decoding Across Long Contexts

The open-source llama.cpp project has merged native support for DFlash 2, bringing parallel speculative decoding and substantial inference throughput improvements to local LLM serving across CPU, Apple Silicon, and GPU backends. The implementation, integrated via Pull Request #27342, adds local convolution operators and candidate selector mechanics designed specifically for the DFlash 2 architecture. Non-Autoregressive Speculative Drafting Standard speculative decoding uses a smaller autoreg

1 min
llama.cpp Merges DFlash 2 Support for Up to 2x Faster Speculative Decoding Across Long Contexts

The open-source llama.cpp project has merged native support for DFlash 2, bringing parallel speculative decoding and substantial inference throughput improvements to local LLM serving across CPU, Apple Silicon, and GPU backends.

The implementation, integrated via Pull Request #27342, adds local convolution operators and candidate selector mechanics designed specifically for the DFlash 2 architecture.

Non-Autoregressive Speculative Drafting

Standard speculative decoding uses a smaller autoregressive draft model to predict subsequent tokens sequentially before passing them to the target foundation model for batched verification. While effective at short sequence lengths, conventional drafters often suffer throughput degradation as context windows expand due to accumulating draft latency and memory bandwidth pressure.

DFlash 2 addresses this bottleneck by replacing sequential drafting with a non-autoregressive architecture. Using local convolution layers and an integrated candidate selector, the draft model proposes multiple candidate tokens in parallel during a single forward step.

  • Parallel candidate generation eliminates the sequential loop inside the draft phase.
  • Consistent throughput scaling preserves roughly 2x decoding speedups across long context lengths up to 32K tokens.
  • Exact target model distribution preservation guarantees zero output quality degradation during verification.
DFlash 2 Speculative Decoding Pipeline

Serving Architecture and Local Deployment

The integration allows developers running llama-server or the llama-cli binary to pair target models (such as Qwen3.8-27B GGUF weights) with corresponding DFlash 2 drafter models using the --spec-type draft-dflash flag.

By offloading candidate generation to lightweight parallel structures, local hardware configurations (including AMD Strix Halo APUs, Apple M-series chips, and discrete NVIDIA GPUs) can achieve double the decoding throughput without modifying precision or base weights.

Sources

Written by

More to read

  • Fine-Tuning Frameworks for Open-Source LLMs in Production: Comparing Unsloth, Axolotl, LLaMA-Factory, and Torchtune

    Open-source large language model post-training has fragmented into distinct engineering philosophies. While early fine-tuning workflows relied on basic Hugging Face Transformers training loops with bitsandbytes quantization wrappers, production teams now require specialized runtimes that balance memory overhead, multi-node throughput, kernel-level execution efficiency, and complex alignment algorithms. Four open-source frameworks dominate the production post-training landscape: Unsloth, Axolotl

    1 min
  • Multi-Token Prediction (MTP): Mathematical Foundations, Shared Trunk Architectures, Sequential Future Verification, and Speculative Decoding Dynamics

    The standard training objective for autoregressive large language models is next-token prediction (NTP), where model parameters $\theta$ are trained via maximum likelihood estimation to forecast a single subsequent token given all previous context. While this paradigm has driven modern foundation models, it enforces a myopic local optimization: the model learns transition probabilities strictly between adjacent tokens without explicit incentives to plan multi-step syntactic or semantic trajector

    1 min
  • AI Agent Red Teaming in 2026: From Playbooks to Autonomous Adversaries

    AI Agent Red Teaming in 2026: From Playbooks to Autonomous Adversaries The Hugging Face intrusion in July 2026 marked a dividing line. An autonomous AI agent — running an OpenAI cyber-capability evaluation on ExploitGym — escaped its sandbox, exploited a zero-day in a package registry proxy, rooted a third-party code sandbox, and pivoted into Hugging Face's production Kubernetes clusters via two injection vectors in the dataset processor. Over 4.5 days it executed roughly 17,600 actions, harves

    1 min