AuthonAuthon Blog
tutorial8 min read

How to Run DaisyRose-27B Locally on 24 GB VRAM (Only One Benchmark Doubled)

The 17.33 GB Q4_K_M GGUF fits 24 GB with 32K-64K context. Terminal Bench went 5.6 to 12.0; on one private bench it used nearly 2x the tokens.

AW
Alan West
Authon Team
How to Run DaisyRose-27B Locally on 24 GB VRAM (Only One Benchmark Doubled)

Yes, you can run DaisyRose-27B locally on a single 24 GB GPU: the Q4_K_M GGUF is 17.33 GB and leaves room for 32K to 64K of context. Whether you should is a different question. In RadixArk's table, DaisyRose more than doubles its base model on Terminal Bench 4.1, from 5.6 to 12.0, and on every other benchmark it moves between 0.4 and 4 points. I'd look hard at that gap before downloading 17 GB of weights.

The release hit the Hacker News front page this week (223 points when I read the thread), and the top argument there was whether it's benchmaxxed. Below is the VRAM math per quant, the commands for llama.cpp, Ollama and LM Studio, and what the benchmarks do and don't show. I haven't run it myself. Every number here comes from the model card, the GGUF repo, the config file or people in the thread who did.

What DaisyRose-27B actually is

It's Qwen3.8-27B with a lot of reinforcement learning on top. RadixArk trained it with their Miles framework on 1,200 curated agentic tasks, over 18 days on 144 H200s (about 63,000 GPU-hours). One HN commenter put that at roughly $331,000 at vast.ai prices.

From the model card and config.json:

  • Dense model, 27.8B params total, which includes a 0.46B vision encoder and a 0.42B multi-token-prediction head
  • 64 layers: three Gated DeltaNet (linear attention) layers, then one full-attention layer, repeated
  • 262,144-token context
  • Text and image input, text output. It's a thinking model.
  • Apache-2.0, same as the Qwen base

RadixArk ships BF16 (~52 GB), FP8 (~29 GB) and NVFP4 (~23 GB, Blackwell only). They don't ship a GGUF. The community did that within a day.

DaisyRose-27B benchmarks vs Qwen3.8-27B and Gemma 4

These are vendor-reported. Gemma 4 isn't in RadixArk's table, so I took the 31B numbers from Google's model card as mirrored by NVIDIA. Different labs run different harnesses, so read that column as a rough guide only.

| Benchmark | DaisyRose-27B | Qwen3.8-27B | Gemma 4 31B |
|---|---|---|---|
| Terminal Bench 4.1 | 12.0 | 5.6 (TB 4.0) | not reported |
| Terminal Bench 2.1 | 75.5 | 73.0 | not reported |
| DeepSWE v1.1 | 46.2 | 42.2 | not reported |
| SWE Bench Pro v2 | 94.7 | 91.3 | not reported |
| HLE (text only) | 34.3 | 33.9 | 19.5 (no tools) |
| IFBench | 82.4 | 79.5 | not reported |
| GPQA Diamond | 90.7 | 89.2 | 84.3 |

Read the footnotes before you get excited about the top row. Qwen3.8-27B has no Terminal Bench 4.1 entry, so the 5.6 is its Terminal Bench 4.0 score from Artificial Analysis, while DaisyRose's 12.0 comes from RadixArk's internal mini-swe-agent harness averaged over 8 runs. The doubling is the headline, and it compares two different benchmark versions.

My read is that Qwen3.8-27B did most of the work in this table. The RL added a jump on the agentic terminal benchmark it was aimed at, a few points on SWE-style tasks, and roughly nothing on HLE. To RadixArk's credit, nothing went down. nblintao, who answered the training questions in the HN thread, said none of the benchmark tasks were used in training, though the training data was "designed to improve capabilities on tasks like TB4.1." For scale, the model card's own comparison lists GPT-6 Luna at 15.2 on Terminal Bench 4.1, so even the headline number still trails a closed model.

Not everyone in the thread bought it. jacquesm wrote: "I find it hard to believe that you can just do some RL and then end up with a model that is better across the board." The most useful comment came from robertkarl, who ran it against a private 86-task bench:

  • DaisyRose (NVFP4, SGLang, 48 GB A6000, 256k context at FP8 KV, medium reasoning): score 0.898, 7.8 hours, ~1.92M tokens emitted
  • Qwen 3.8 Swift 1.5, another Qwen finetune (IQ3_S, llama.cpp, 24 GB 4090, 128k context, medium reasoning): score 0.87, 5.5 hours, ~1.04M tokens

Their verdict was "benchmaxxing imo". Those two setups aren't a fair fight, since DaisyRose had the bigger card and the better quant. I'd pay more attention to the token count. DaisyRose emitted nearly twice as many tokens for under 3 points of score, and that was at medium reasoning. The card's default reasoning effort is xhigh, and it tells you to leave max_tokens unset on hard problems. On a local GPU, every one of those thinking tokens comes out of your own wall-clock time.

VRAM: which DaisyRose-27B GGUF fits a 24 GB card

File sizes from bartowski's GGUF repo (made with llama.cpp b12412):

| Quant | File size | 24 GB card? |
|---|---|---|
| Q8_0 | 29.05 GB | No |
| Q6_K | 23.78 GB | No, no room for context |
| Q5_K_M | 20.79 GB | Tight, short context only |
| Q4_K_M | 17.33 GB | Yes, the sweet spot |
| IQ4_XS | 15.37 GB | Yes, more context headroom |
| IQ3_M | 14.78 GB | Yes, quality starts to slip |
| Q2_K | 10.82 GB | 12 to 16 GB cards, if you must |

The weights are only half the budget, and the KV cache is where the hybrid architecture helps: only 16 of the 64 layers use full attention, with 4 KV heads and a head dim of 256. My arithmetic from the config:

text
16 layers × 4 KV heads × 256 dim × 2 (K+V) × 2 bytes (f16) = 64 KiB per token

  32K context  →  ~2 GiB
 128K context  →  ~8 GiB
 256K context  → ~16 GiB

The DeltaNet layers keep a fixed-size state that doesn't grow with context. Quantizing the KV cache to q8_0 roughly halves those numbers.

On a 24 GB card, Q4_K_M plus 32K to 64K of f16 cache fits comfortably. Push to 128K and you'll want q8_0 KV, IQ4_XS, or both. Q5_K_M is possible at short context, but you'll be fighting the compute buffers for the last gigabyte. Leave the vision projector unloaded if you don't need images.

On a Mac, mlx-community and netprojects have already posted MLX builds from 2.5-bit to bf16.

Run DaisyRose-27B with llama.cpp, Ollama or LM Studio

All three can load it today. The architecture is the same as Qwen3.8-27B, and the GGUF repo has instructions for all three.

llama.cpp

You need b12412 or newer:

bash
llama-server -hf bartowski/RadixArk_DaisyRose-27B-GGUF:Q4_K_M \
  -c 65536 -ngl 99 \
  --temp 1.0 --top-p 0.95 --top-k 20 --min-p 0

The sampling values are the card's thinking-mode settings. The repo also documents --spec-type draft-mtp to use the built-in MTP head for speculative decoding, which is worth trying on a model this wordy. Add --cache-type-k q8_0 --cache-type-v q8_0 if you push context past 64K. -hf pulls the mmproj file for vision automatically. If you download files by hand, pass --mmproj yourself.

Ollama

bash
ollama run hf.co/bartowski/RadixArk_DaisyRose-27B-GGUF:Q4_K_M

Ollama sets the default context from your VRAM: 4K under 24 GiB, 32K on a 24 to 48 GiB card. Agent loops chew through 32K fast, so raise num_ctx to 65536 to match the llama.cpp setup above.

LM Studio

The GGUF repo lists LM Studio as a supported app and links straight to it from the Hugging Face page. Because the quants need llama.cpp b12412 or newer, update LM Studio's llama.cpp runtime before you blame the model.

Serving with SGLang or vLLM

RadixArk recommends SGLang with their RadixArk/Qwen3.8-27B-DSpark draft model, --kv-cache-dtype fp8_e4m3, and the qwen3 reasoning and qwen3_coder tool parsers. vllm serve "RadixArk/DaisyRose-27B" also works, but the BF16 weights won't fit on one consumer card. Use the FP8 or NVFP4 repos.

Should DaisyRose replace Qwen3.8-27B as your local model?

If most of your local LLM time goes to agent loops (a terminal, a repo, tool calls), give DaisyRose a weekend. The targeted gain looks big on paper, the license is still Apache-2.0, and trying it costs you one -hf string.

If you mostly chat, write, or ask quick questions, I'd stay on Qwen3.8-27B. The general benchmarks barely moved. In the thread, mik1998 said heavy post-training makes a model better at coding but worse at things like prose, and jacquesm said they keep older models around because the coding-strong ones "fare less well at other stuff." On a single GPU, nearly double the thinking tokens is a cost you pay every day.

Which 27B would you trust as your daily local model right now, and why? Tell me if DaisyRose's Terminal Bench jump holds up on your own tasks, or if robertkarl's "benchmaxxing" call matches what you've seen.

Sources

How to Run DaisyRose-27B Locally on 24 GB VRAM (Only One Benchmark Doubled) | Authon Blog