Clover-35B-A3B VRAM: 16 GB Claim vs 18.24 GiB

DiffuSpace put Clover-35B-A3B-Preview on Hugging Face on 24 October 2026. It's an open diffusion language model, built from Qwen3.6-35B-A3B and released under Apache-2.0. Instead of writing one token at a time, it fills a block of 32 masked positions in parallel and commits the ones it's confident about. The launch blog claims 73.6 on SWE-bench Verified and 515 tokens per second on one H200.

The blog also says Clover runs at INT4 on an RTX 5070 Ti with 16 GB. That's the line most people with a gaming card will care about, and it doesn't match the files DiffuSpace ships. The smallest official GGUF is 18.24 GiB before any context. Below are the real file sizes, what the context costs on top (very little), which cards fit, and how to run it today through the llama.cpp pull request.

Table of contents

• What DiffuSpace released
• How block diffusion decodes
• Memory by quant and context
• The 16 GB claim
• Benchmarks and speed claims
• Running it with llama.cpp today
• FAQ
• Sources

What DiffuSpace released

DiffuSpace's team came out of the HKU NLP group that released Dream 7B in April 2025. Clover is their first model under the new name. A "decision model" built on Clover was announced in the same post but hasn't been released.

How block diffusion decodes

An autoregressive model like Qwen3.6 runs one forward pass per output token. Clover starts each block as 32 mask tokens and resolves them over several passes:

1. Every position in the block gets a prediction.
2. Positions above 0.95 confidence are filled. If none clear the bar, the single most confident one is filled so the loop always makes progress.
3. The pass repeats until the block is full, then the block becomes part of the causal prefix and the next 32 positions start.

On easy text many positions clear the bar at once, which is where the speed comes from. On hard text the loop falls back toward one token per pass.

The llama.cpp port works differently. It uses Clover's diffusion head as its own draft model (draft-self): it proposes up to 15 tokens and the causal path verifies them. You don't download a separate draft model, and the output follows the verified causal path.

Memory by quant and context

The official GGUF repo has three files. Each is a complete model:

Context is cheap. Only the 10 full-attention layers keep a cache that grows per token, and each has just 2 KV heads of 256 dimensions. In BF16 that's 2 (keys and values) x 10 layers x 2 heads x 256 x 2 bytes = 20 KiB per token. The 30 DeltaNet layers hold a fixed recurrent state instead. From the config (32 value heads of 128 by 128, stored in FP32) I get about 60 MiB in total, whatever the context length.

The totals are weights plus KV plus recurrent state. Compute buffers come on top, and the GGUF card says plainly that file size is not total inference memory. Keep about 1 GiB spare.

What that means by card:

• 16 GiB (RTX 5070 Ti, 4080, 5060 Ti 16 GB): no official file fits. Q4_0 is 2.24 GiB over before context.
• 24 GiB (RTX 3090, 4090): Q4_0 at the full 128K leaves about 3 GiB for buffers. Q4_K_M fits at 32K but not at 128K.
• 32 GiB (RTX 5090): Q4_K_M at full context.
• 48 GiB and up: Q8_0 at full context.

You can try other sizes in the AI VRAM calculator, which now has a Clover preset with 10 of 40 layers caching KV. Our local LLM VRAM guide explains each term if the numbers are new to you.

The 16 GB claim

The blog reports 101.8 tokens per second on MATH-500 with an INT4 build on a 16 GB RTX 5070 Ti, against 48.5 for similar MiniCPM and Qwen models. It doesn't say which file or which offload settings it used.

A 35B model at 4 bits can't sit fully in 16 GB. The weights alone are about 17.3 GB at a flat 4 bits, and the official Q4_0 keeps some tensors in floating point. So the 16 GB run almost certainly kept part of the weights in system RAM. With MoE models that's a normal trick: llama.cpp can leave expert tensors on the CPU (--n-cpu-moe or -ot overrides) while attention stays on the GPU, because each token only touches 8 of 256 experts.

Two caveats before you plan around it. First, the PR's documented binary, llama-speculative-simple, is a test program, and I couldn't confirm that the expert offload flags behave the same there as in llama-server. Second, the 101.8 tokens per second figure came from DiffuSpace's own setup and nobody has reproduced it yet. On a 16 GB card, assume system RAM does part of the work and expect lower speeds than the blog's number until someone publishes a reproducible run.

Benchmarks and speed claims

All of these are DiffuSpace's own figures from the launch blog, on the BF16 model. The GGUF card notes they weren't re-measured on the quantized files.

The blog says Clover beats Qwen3.6-35B-A3B, Qwen3.5-35B-A3B and the diffusion models LLaDA2.2 flash and Mercury 2.5 on all six agent benchmarks it reports. It also puts Clover 28.0 points ahead of MiniCPM-V 4.7 on SWE-bench Verified and 15.7 ahead on Terminal-Bench 2.1. The per-model numbers for those rivals are only in chart images, so I haven't copied them here.

The speed figures:

The route-planning demo shows the same 169.9 seconds for 28 steps. Two different tasks with an identical time to a tenth of a second looks like a copy error in the blog, so I'd treat the per-demo timings as illustrations.

Running it with llama.cpp today

Clover support isn't in llama.cpp main. PR #31306 ("feat: add Clover support") was opened on 28 October and was still unmerged on 2 November. The GGUF card builds from that PR:

git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp
git fetch origin pull/31306/head
git checkout --detach FETCH_HEAD

cmake -S . -B build-clover -DGGML_CUDA=ON -DLLAMA_CURL=OFF \
  -DLLAMA_BUILD_TESTS=OFF -DLLAMA_BUILD_SERVER=OFF -DCMAKE_BUILD_TYPE=Release
cmake --build build-clover --config Release --target llama-speculative-simple -j

hf download Diffuspace/Clover-35B-A3B-Preview-GGUF \
  Clover-35B-A3B-Preview-Q4_0.gguf --local-dir models

The program reads a raw prompt, so you write the chat format yourself:

cat > prompt.txt <<'EOF'
<|im_start|>user
Write a Python function that parses ISO 8601 durations.<|im_end|>
<|im_start|>assistant
<think>
EOF

./build-clover/bin/llama-speculative-simple \
  -m models/Clover-35B-A3B-Preview-Q4_0.gguf -f prompt.txt \
  --spec-type draft-self --spec-draft-n-max 15 \
  --spec-accept-ratio 0.9 --spec-accept-delta 0.6 \
  --temp 0 --top-k 1 --seed 42 -ctk bf16 -ctv bf16 \
  -c 8192 -n 4096 -b 256 -ub 256 -ngl 99 -t 8 -tb 8 \
  --flash-attn on --color off

I switched the card's example to Q4_0 so it fits a 24 GiB card. The prompt has to fit inside -b, so raise the batch size for long prompts.

The catch for agent users is that this build has no server. -DLLAMA_BUILD_SERVER=OFF and the single target mean there's no OpenAI-compatible endpoint, so you can't point Hermes Agent, Claude Code or Codex at it yet. For serving, DiffuSpace recommends its SGLang PR #46927, which is also still open. The Transformers path works without either PR, but it needs about 69 GB of GPU memory for BF16 weights.

Thinking is on in the default template. The model's generation config starts nudging it to close </think> after 4,096 thinking tokens and to wrap up the answer after 8,192 response tokens. Those tokens count against your context, so give -n some room.

FAQ

Is Clover the same as Mercury 3? No. Both are diffusion language models, but Mercury 3 is closed and API-only from Inception. Clover's weights are open under Apache-2.0. We costed Mercury 3 as a coding agent in October.

Will it run on a Mac? Community MLX 4-bit and GGUF conversions exist on Hugging Face, but DiffuSpace's own guide covers CUDA and CPU builds only. A 32 GB Mac can hold the Q4_0 file. Speed figures for Apple Silicon haven't been published.

Can I fine-tune it? Not with official tooling yet. The GitHub repo lists supervised fine-tuning code as "coming soon".

Sources

• Hugging Face, Diffuspace/Clover-35B-A3B-Preview model card, config.json, generation_config.json and model API (read 2 November 2026): base model, layer types, experts, KV heads, head dimension, linear-attention head shapes, context, decoding defaults, generation controls, parameter count, BF16 index size, creation date.
• Hugging Face, Diffuspace/Clover-35B-A3B-Preview-GGUF model card and file listing: Q4_0, Q4_K_M and Q8_0 sizes, the memory note, the llama.cpp build and run commands.
• DiffuSpace, "Clover-35B-A3B-Preview: A New Way for Intelligence" (diffuspace.ai/blog/clover-35b): benchmarks, speed figures, the RTX 5070 Ti test, demo timings, decision model announcement.
• GitHub, DiffuSpace/Clover-35B-A3B-Preview README: inference backends, SFT status, license.
• GitHub, llama.cpp PR #31306 and SGLang PR #46927 (status read 2 November 2026 via the GitHub API): both open, not merged.
• KV cache per token, recurrent-state size, memory totals and speed ratios are calculated by ToolMintX from the files above.