The checkpoint · Speed · Quality · What it fits on · Use it · The base model · Bench card

Swift1.5-Qwen3.8-Flash-Next-W4A16-Merlin

A 4-bit build of UkisAI's Swift 1.5, their reasoning-efficient post-train of Qwen3.8-Flash-Next (125B mixture-of-experts, 6B active per token, with vision), made to run at its full 262,144-token context on four 24 GB GPUs. It is the Flash-Next checkpoint with the 300 dense tensors Swift 1.5 changed swapped in and the FP8 KV scales recalibrated: 115 GiB, routed experts INT4, the n-gram table FP8, attention and the vision tower BF16. It is served by the Merlin engine, a vLLM 0.33.0 fork tuned for Ampere and Ada that keeps the n-gram table in host RAM and the whole KV cache in VRAM. Measured on four RTX 3090s; the engine also ships Swift profiles for other Ampere and Ada cards (see What it fits on). An independent derivative: not made, reviewed or endorsed by UkisAI or Qwen.

_{numbers: Merlin 3.0.2 (vLLM 0.33.0) on 4× RTX 3090 w/o NVLINK @ 220W, P2P on, with the gpu-unlock host upgrade, 2026-11-05 bench card. KV pool: FP8, all in VRAM; three 262K sessions held at once (3.0.0 run). Agents: eight 16K conversations, then eight simultaneous 512-token follow-ups, thinking on (effort medium). Decode: one stream, thinking on (effort medium, the server default), exactly 261,888 prompt tokens + 128 out, median of 3. Prefill: one cold 101,845-token prompt. Each figure is also in a table below.}

The checkpoint

Component	Format
Routed experts (512 per layer)	INT4 g128, from Intel's AutoRound release via the Flash-Next checkpoint (Swift 1.5 left them unchanged)
MTP draft-head experts	INT4 g128, packed in place (Flash-Next checkpoint)
Gated DeltaNet QKV/Z and output projections (36 layers)	INT8 per channel, Swift 1.5's weights
Attention q/k/v/o (12 layers), shared experts (48 layers)	BF16, Swift 1.5's weights
N-gram (PLE) embedding table, 51B parameters	FP8, kept in host RAM at serve time (RadixArk)
Norms, embeddings, lm_head, routers, QSA indexer, gated-residual weights, DeltaNet a/b and conv, MTP non-expert layers, vision tower	BF16, unchanged
KV cache	FP8 E4M3 with static scales recalibrated on Swift 1.5 (qsa_kv_scales_swift.json)

_{We compared Swift 1.5 (revision 0bd4fe2) with Qwen3.8-Flash-Next (revision de4b8e4) tensor by tensor: only the attention q/k/v/o_proj (12 layers), the Gated DeltaNet in_proj_qkv / in_proj_z / out_proj (36 layers) and the shared experts (48 layers) changed, 300 tensors, so those are taken from Swift 1.5 and everything else from the Flash-Next checkpoint. The MTP head was checked with a full SHA-256 of every tensor, the other unchanged groups with whole-shard or sampled hashes. The KV scales were recalibrated because Swift 1.5 changed k_proj / v_proj.}

Files in this repository

Files	What they hold	Size
model-000NN-of-00017.safetensors (15)	Routed experts, DeltaNet projections, attention, norms, embeddings, shared expert, vision tower	66.2 GiB
model-plefp8-0000N.safetensors (10)	The n-gram embedding table, FP8; loaded into host RAM at serve time	47.7 GiB
mtp-routed-experts-int4.safetensors	MTP draft-head experts, INT4	1.2 GiB
model_extra_tensors.safetensors	Further tensors listed in the index	0.2 GiB
qsa_kv_scales_swift.json	Static scales for the FP8 KV cache, recalibrated on Swift 1.5	1.4 KiB
model.safetensors.index.json	Which file holds each tensor	24.3 MiB
chat_template.jinja	Qwen's own chat template, unchanged (byte-identical to the upstream file). Merlin serves Froggeric's fixed Qwen3.8 template (v22.5) by default; see Use it	8.7 KiB
config.json, quantization_config.json, tokenizer, processor configs	Model, quantisation, tokenizer and processor settings	12.3 MiB
LICENSE, LICENSE-QWEN, NOTICE	Swift Open License v1.0, Qwen Community License 1.0, UkisAI's notice and every change made here	21.6 KiB
SHA256SUMS	SHA-256 of the checkpoint files: sha256sum -c SHA256SUMS in the download folder	3.7 KiB

_{115.3 GiB in total. There are no shards 00002 and 00016: model.safetensors.index.json maps no tensor to them, so nothing is missing.}

Speed

Prompt	Decode, one stream	Time to first token
4K	181 tok/s	0.67 s
32K	181 tok/s	4.65 s
131K	187 tok/s	18.9 s
262K	186 tok/s	38.7 s

_{4× RTX 3090, thinking on at reasoning effort medium (the server default). The needle-prompt ladder (4,046 / 32,566 / 130,386 prompt tokens, every send a cold prefill) and the exact 261,888-token prompt (send 1 cold; in this run send 2 was served cold too and send 3 reused 135,168 tokens). Decode: ≤ 256 tokens out (128 at 262K), median of 3. Time to first token: the median of 3 cold sends below 262K, the cold send 1 at 262K. A separate 259,557-token ladder row decodes at 192 tok/s. The 262K needle was found in 3 of 3 thinking-off sends (3.0.0 run).}

_{Thinking off at exactly 262K decodes at 144 tok/s, the median of three sends that ran 139.3–160.7 tok/s (3.0.1: 145.4). The 259K thinking-off ladder row decodes at 130 tok/s.}

Cold prefill, one send	Prefill	Time to first token
10,157 tokens	6,569 tok/s	1.55 s
101,845 tokens	6,932 tok/s	14.7 s
261,888 tokens	6,762 tok/s	38.7 s

_{One cold request per prompt, 8 tokens out at 10K and 100K. The 261,888-token row is the cold first send of the exact-262K run with thinking on, the same send as the 262K row above. The 101,845-token figure is the hero's prefill number.}

Agents at once	Total tok/s
2 (3.0.0 run)	224
4 (3.0.0 run)	387
8, thinking off (3.0.1 run)	650
8, thinking on (effort medium)	659

_{N 16K conversations, then N simultaneous 512-token follow-ups, total tok/s while all N decode; thinking off unless stated. With thinking on a 512-token follow-up may end inside the reasoning and reasoning tokens count, so that total measures decoded tokens, not finished answers. Overlap windows: 4.53 and 5.14 s for the 3.0.0 rows, 5.90 s for the thinking-off row (3.0.1 run) and 5.59 s for thinking on (3.0.2): a few seconds each, so read these rows loosely.}

Sessions held at once	Needles found	Re-sent from cache, lowest
3 × 262K	3 / 3	99.95 %
6 × 131K	6 / 6	99.91 %

_{N needle prompts (thinking off, greedy) sent at once, then re-sent one by one: every re-send served from the prefix cache means the pool held all N. Peak pool use 100 %, 0 preemptions. 3.0.0 run, 2026-10-20; the KV pool (924,993 tokens) and the sessions it holds are unchanged in 3.0.1 and 3.0.2.}

Against the previous release (3.0.1)

Measure	3.0.1	3.0.2	Change
Decode, 4K prompt, thinking on	175.9	180.8	+2.8 %
Decode, 32K prompt, thinking on	176.2	181.0	+2.7 %
Decode, 131K prompt, thinking on	186.1	186.9	+0.4 %
Decode, 259K prompt, thinking on	184.4	191.8	+4.0 %
Decode, exactly 261,888 tokens, thinking on	185.6	186.1	+0.3 %
Decode, exactly 261,888 tokens, thinking off	145.4	143.8	−1.1 %
Prefill, 10K prompt	6,623	6,569	−0.8 %
Prefill, 100K prompt	7,043	6,932	−1.6 %
Prefill, 261,888-token prompt	6,783	6,762	−0.3 %
8 agents, thinking on (effort medium)	673	659	−2.1 %

_{tok/s. Both releases on the same host and settings (gpu-unlock on, thinking effort medium). MTP acceptance moves decode by several percent between sends and between runs: the three 3.0.2 sends at exactly 262K with thinking on ran 169.1–191.8 tok/s, so a difference smaller than that spread is not resolved by these runs. The 3.0.2 prefill prompts are 42 tokens shorter at 10K and 100K (10,157 against 10,199). The thinking-off 8-agent run was not re-run for 3.0.2; the bench card sets the rest side by side.}

How it was measured

• Host: 4× RTX 3090 (24 GB, sm_86) at 220 W, PCIe Gen4 with P2P, no NVLink, driver 610.43.02, with the Zagitta's gpu-unlock host upgrade on (as for the 3.0.1 runs; the 3.0.0 runs did not have it).
• Engine: Merlin 3.0.2 on vLLM 0.33.0 (the 3.0.2 release tree), served by merlin serve with the shipped defaults, one fresh boot; runs of 2026-11-05 (UTC).
• Layout: TP2 × PP2 + EP on four cards, MTP K=3, FP8 KV, BF16 draft lm_head, thinking effort medium, the server default.
• Decode: T=0, a needle prompt at depth, every send a cold prefill, 3 sends per cell, median. At exactly 262K the three sends share one cache salt (send 1 cold; in this run send 2 was served cold too and send 3 reused 135,168 tokens). tok/s = tokens after the first streamed event / time from first to last event.
• Streams are client-timed. Full tables, thinking-off rows and ITL: the bench card.

Quality

This checkpoint, measured on the Merlin engine:

Check	Result	Setting
GSM8K-200	197 / 200	5-shot, thinking off
GSM8K-200, thinking on	199 / 200 on four cards	5-shot, effort medium, none cut at the 8,192-token cap
Needles at 131K	10 / 10	single-occurrence needles, an image in the prompt, thinking off, greedy, cold cache
Needles at 262K	23 / 23	as above
Needle at exactly 261,888 tokens	3 / 3	thinking off
Image, 4096 × 2048 (8,388,608 px)	1 / 1 · 2 / 2 at once	thinking off; names both colours of a two-colour image

_{Thinking-on GSM8K-200: Merlin 3.0.2, four cards, the same 200 problems and scorer as the thinking-off row, temperature 0 (3.0.1 also scored 199 / 200). Every other row is a 3.0.0 run, not re-run for 3.0.1 or 3.0.2. GSM8K and images: the Merlin 3.0.0 release wheel, 2026-10-20. Needle panel: a pre-release engine build, 2026-10-17. The four-images-in-one-prompt check ran on the Flash-Next checkpoint only. These are checks of this checkpoint, not a matched BF16 comparison.}

Swift 1.5, as reported by UkisAI for the BF16 weights against the Qwen3.8-Flash-Next base:

Benchmark	Base	Swift 1.5	Thinking tokens, mean
GPQA-Diamond	89.80	89.60	17,683 → 7,823 (−55.8 %)
MMLU-Pro	87.75	87.20	3,528 → 1,519 (−57.0 %)
C-Eval	93.27	93.60	1,048 → 586 (−44.1 %)
IFBench	73.20	70.13	8,310 → 4,411 (−46.9 %)
AIME 2026	98.67	96.67	23,015 → 15,806 (−31.3 %)
HMMT (Nov 2025)	98.00	97.33	25,487 → 16,530 (−35.1 %)
ERQA (multimodal)	70.80	69.30	4,036 → 1,788 (−55.7 %)
LiveCodeBench v6	88.40	90.39	17,833 → 9,849 (−44.8 %)
Terminal-Bench 2.1	67.64	69.66	40,591 → 45,428 (+11.9 %, all output)

_{Reported by UkisAI on their card: BF16 weights, effort xhigh, MTP off. Question benchmarks: 262,144 context, five seeds, temperature 1.0 / top_p 0.95 / top_k 20. Terminal-Bench 2.1: five attempts per task, temperature 1 / top_p 1, 131,072-token server context. Tokens are mean thinking tokens per answer (Terminal-Bench: all generated tokens); UkisAI note that their Terminal-Bench run used default task timeouts. At medium and low Swift 1.5 scored 2.62 and 2.42 points below the base on GPQA-Diamond. None of this was re-run on this 4-bit build.}

What it fits on

Measured on	Context per request	KV pool	Held at once	Images
4× RTX 3090, 24 GB (🟢 Tested)	262,144 tokens	924,993 tokens, FP8, all in VRAM	3 × 262K or 6 × 131K	8 MP

_{Measured on the reference host (3.0.0 run, 2026-10-20 bench card): three 262K and six 131K sessions held at once with every re-send served from cache; a 4096 × 2048 image (8,388,608 px) with at least 1,158 MiB free on every card.}

Other GPUs. The engine also ships profiles for these; the Status column says how far each has been run:

GPUs	Arch	Profile	Context fit	Status
4× RTX 3090 Ti, RTX A5000 (24 GB)	Ampere, sm_86	fn-swift1.5-quad-3090	~3 × 262K (as the 3090)	⚫ Untested
4× RTX 3090 without P2P	Ampere, sm_86	fn-swift1.5-quad-3090-nop2p	~3 × 262K	⚫ Untested
4× RTX 4090 (24 GB)	Ada, sm_89	fn-swift1.5-quad-24g-sm89	~3 × 262K	🟡 Testing
4× RTX 4080 Super 32 GB (modified)	Ada, sm_89	fn-swift1.5-quad-32g-sm89	~10 × 262K	⚫ Untested
2 / 4× 48 GB: RTX A6000, A40	Ampere, sm_86	fn-swift1.5-2x48g-pp2-sm86, fn-swift1.5-4x48g-tp2pp2-sm86	~5 / ~25 × 262K	⚫ Untested
2 / 4× 48 GB: RTX 6000 Ada, L40S, RTX 4090 48 GB	Ada, sm_89	fn-swift1.5-2x48g-pp2-sm89, fn-swift1.5-4x48g-tp2pp2-sm89	~5 / ~25 × 262K	⚫ Untested
1 / 2 / 4× A100 80 GB	Ampere, sm_80	fn-swift1.5-sm80-80g-x1, -x2-tp2, -x4-tp2pp2	~1 / ~11 / ~28 × 262K	⚫ Untested
4× A100 40 GB, CMP 170HX 40 GB	Ampere, sm_80	fn-swift1.5-sm80-40g-x4-pp4	~7 × 262K	⚫ Untested
3 / 4× CMP 170HX 32 GB	Ampere, sm_80	fn-swift1.5-sm80-32g-x3-pp3, -x4-pp4	~1 / ~4 × 262K	⚫ Untested
4× A30 (24 GB)	Ampere, sm_80	fn-swift1.5-quad-24g-sm80	~1 × 262K	⚫ Untested
2× CMP 170HX 64 GB	Ampere, sm_80	fn-swift1.5-sm80-64g-x2-pp2	~6 × 262K	🟡 Testing

_{merlin serve and ./setup.sh pick the profile from the GPUs they find. A ~ is the engine's estimate, not a measurement. There is no 8-card or 4× CMP 170HX 64 GB profile for this checkpoint yet. On sm_80 cards (A100, A30, CMP 170HX) it defaults to a BF16 KV cache, so fewer sessions fit; KV_DTYPE=fp8 opts into FP8 (untested ⚫). 🟢 measured by us · ⚫ a profile ships, not yet run by us (expected to work). Every profile: the engine's hardware matrix. 🟡 Testing: full-model runs passed on cloud-hosted cards; not yet qualified against the reference host.}

Need	Details
Host RAM	72 GiB tested minimum on four cards (startup is refused below about 69 GiB, plus the KV RAM cache size when it's on; with --ple int6 about 60 GiB (estimated, not boot-tested)). 96 GiB is the reference allocation; the FP8 n-gram table alone takes about 47.7 GiB, which --ple-store disk (experimental, untested on this checkpoint ⚫) reads from NVMe instead.
Disk	About 115 GiB for the checkpoint, plus the engine environment and caches
Engine host	Linux x86-64 (glibc 2.38 or newer), NVIDIA driver R580 or later (CUDA 13), Python 3.13, GCC/G++ 13 or newer, /dev/shm of at least 1 GB; GPUs headless with no other CUDA process. merlin doctor checks the host.

Use it

git clone https://github.com/halt95/merlin-engine.git && cd merlin-engine
./setup.sh --model swift1.5

One command does the rest: after a small uv and Python bootstrap it checks the GPUs, driver, RAM and disk, shows the engine, package and checkpoint downloads with their sizes before fetching them, installs the prebuilt engine, downloads and verifies this checkpoint, and starts an OpenAI-compatible server on 127.0.0.1:8000; requests name the model flash-next-v2 (also flash-next, flash-mtp, flash-next-mtp). Enter takes the recommended answer at each question; --yes takes them all, --dry-run shows the plan. Run ./setup.sh again to start the server, and git pull && ./setup.sh to update the engine without downloading the model again.

This checkpoint needs the Merlin engine; stock vLLM was not tested with it.

Manual install

git clone https://github.com/halt95/merlin-engine.git && cd merlin-engine
curl -LO https://github.com/halt95/merlin-engine/releases/download/merlin-v3.0.2/vllm-0.33.0+merlin.665f43d2cf-cp313-cp313-linux_x86_64.whl
MERLIN_WHEEL="$PWD/vllm-0.33.0+merlin.665f43d2cf-cp313-cp313-linux_x86_64.whl" bash release/install-env.sh ./venv

venv/bin/hf download halt95/Swift1.5-Qwen3.8-Flash-Next-W4A16-Merlin --revision 4d4c7d3b0bb86c76838457e48c823061a3d2f8f6 \
  --local-dir ~/models/swift1.5
(cd ~/models/swift1.5 && sha256sum -c "$OLDPWD/models/swift1.5/checkpoint.sha256")
venv/bin/merlin serve ~/models/swift1.5

MERLIN_WHEEL installs the prebuilt engine (sm_80, sm_86, sm_89; Merlin 3.0.2 on vLLM 0.33.0, a new wheel that needs a new venv), checked against release/merlin-wheel.sha256; without it the installer compiles the engine instead, about 1.5 hours on 8 cores. merlin serve recognises the checkpoint, picks the largest tested layout for the GPUs it finds (or, with none, the largest untested one that fits, labelled as such) and serves on 127.0.0.1:8000. Add --dry-run to print the resolved command without starting anything. The first start compiles kernels; the server is ready when merlin: Ready: ... prints.

Recommended settings (UkisAI's evaluation settings; Qwen's for non-thinking):

Mode	temperature	top_p	top_k	presence_penalty
Thinking (default)	1.0	0.95	20	0.0
Non-thinking	0.7	0.80	20	1.5

_{Thinking: the sampling UkisAI evaluated Swift 1.5 with; non-thinking: Qwen's recommendation for the base model. Both with min_p=0.0 and repetition_penalty=1.0.}

• Turn thinking off for a request with "chat_template_kwargs": {"enable_thinking": false}. With thinking on, a short max_tokens can end inside the reasoning with empty content.
• Reasoning effort: Merlin serves medium by default; UkisAI evaluated Swift 1.5 at xhigh, where it keeps the base model's GPQA-Diamond score within 0.2 points (at medium it is 2.62 points lower). Pick it per request with "chat_template_kwargs": {"reasoning_effort": "xhigh"} (low / medium / xhigh).
• Chat template: Merlin serves Froggeric's fixed Qwen3.8 template (v22.5) by default, not the file in this repository. It accepts system messages after the first turn, so coding agents' per-turn notes stay in place and the prefix cache keeps hitting. CHAT_TEMPLATE=<path> serves another template; CHAT_TEMPLATE= (empty) serves this repository's own.
• With Qwen's own template (CHAT_TEMPLATE=), earlier turns' reasoning is kept by default and "chat_template_kwargs": {"preserve_thinking": false} keeps only the latest.
• Images: up to 42 per request (the launcher's cap), 8 MP each; four 8 MP images in one prompt were checked on the Flash-Next checkpoint.
• Tool calls use the standard tools field, parsed with the Qwen3 coder tool parser.
• To reach it from other machines, answer network at setup's Access question (it generates an API key), or start merlin serve with HOST=0.0.0.0 and VLLM_API_KEY set; put a TLS reverse proxy in front before opening it beyond your own network.

Optional Merlin 3.0.2 features, all off by default (flags and limits):

• KV RAM cache (experimental). --kv-ram-cache 24g keeps conversation prefixes the GPU evicts in host RAM and restores them instead of recomputing them, with exactly the same output as a GPU cache hit. On Flash-Next a 262K restore took 1.2–1.4 s instead of about 45 s to recompute (measured on the Flash-Next checkpoint, Merlin 3.0.1). It works with the MTP drafter only (not with --spec dflash2) and adds no context or sessions.
• More sessions with --swarm (experimental). Raises the session cap on four RTX 3090s from 8 to 24, with a 48 GB KV RAM cache. ⚫ Untested on this checkpoint (expected to work); it was tested on Flash-Next with P2P.
• DFlash2 drafter. --spec dflash2 on four RTX 3090s with P2P decoded 5–18 % faster than the default MTP drafter across the Flash-Next family (measured on Merlin 3.0.1); the server then holds three 262K sessions instead of six 131K ones. ./setup.sh --spec dflash2 downloads the 1.2 GB drafter.
• INT6 n-gram table. --ple int6 loads a smaller INT6 copy of the n-gram table and saves about 9 GiB of host RAM per server, with quality checks passed on this checkpoint and on Flash-Next. It is one shared pack laid over the FP8 files you downloaded, which stay untouched; FP8 stays the default.
• PLE table on NVMe (experimental). --ple-store disk reads the n-gram table from the checkpoint's files on local NVMe instead of holding it in host RAM, which frees about 47.7 GiB. On Flash-Next output matched ram token for token, and decode was about 2 % slower once the table was cached and 9–11 % slower on text whose rows were not cached yet. ⚫ Untested on this checkpoint (expected to work); ram stays the default. Costs and limits.

The base model

Swift 1.5 is UkisAI's post-train of Qwen3.8-Flash-Next for shorter reasoning. UkisAI penalised the tokens they linked to overthinking, without targeting reasoning length directly, then recovered accuracy with RL and on-policy distillation, with post-training aimed at coding and long-horizon agent work. They report 63.4 % fewer median thinking tokens on GPQA-Diamond at xhigh for 0.2 points of score (table under Quality). The architecture is Qwen3.8-Flash-Next's, Qwen's preview of the architecture behind Qwen4:

• Hybrid attention. Three Gated DeltaNet (linear-attention) layers for every Qwen Sparse Attention layer. QSA attends over micro-blocks instead of single tokens, which keeps long-context latency down.
• Sparse experts. 512 experts per layer with 10 routed and 1 shared active per token: 6B of the 125B parameters do the work for each token.
• N-gram embedding. A 51B-parameter bigram/trigram table at layer 2 adds parameter capacity with less computation than adding experts would. Merlin keeps it in host RAM, so the VRAM goes to KV cache.
• Gated residual. Widened residual streams with a data-dependent read gate and a per-branch write gate.
• Multi-token prediction. One MTP layer, trained over several steps; Merlin uses it for speculative decoding.
• Thinking by default, with a non-thinking mode per request; Qwen's template keeps earlier turns' reasoning by default (preserved thinking).

Property	Qwen3.8-Flash-Next
Type	Causal language model with a vision encoder (images and video)
Parameters	125B total, 6B active, plus 51B n-gram embedding and 4B MTP
Layers	48: 12 × (3 × Gated DeltaNet → MoE, then 1 × Qwen Sparse Attention → MoE)
Experts	512 per layer; 10 routed + 1 shared active; expert width 640
Attention	QSA: 24 query / 2 KV heads, head dim 256, budget 512 blocks or 2,048 tokens · Gated DeltaNet: 48 V / 16 QK heads, head dim 128
Context	262,144 tokens native (Qwen: extensible to 1M with YaRN; this build serves 262,144)

_{Architecture as reported by Qwen on the upstream card; Swift 1.5 keeps it.}

Other builds

Checkpoint	Base	GPUs	Decode at 262K
Flash-Next	Qwen3.8-Flash-Next, 125B MoE	4× 3090	207 tok/s
Swift1.5 (this card)	Flash-Next fine-tune	4× 3090	186 tok/s
Swift1.5-Huihui	Swift1.5, abliterated	4× 3090	193 tok/s
Qwen3.8-27B	Qwen3.8-27B, dense	1×, 2× or 4× 3090	77 / 146 / 250 tok/s
ThinkingCap	Qwen3.8-27B fine-tune	2× or 4× 3090	160 / 223 tok/s
Nemotron 3.5 Super VL	Nemotron 3.5 Super VL, 120B-A12B MoE	4× 3090	106 tok/s
Ornith 1.5	Qwen3.5-122B-A10B fine-tune (ornith-ai), 122B MoE	4× 3090	111 tok/s

_{One stream, thinking on, 261,888 prompt tokens + 128 out, median of 3; Merlin 3.0.2, 2026-11-04 and 2026-11-05 bench cards. Thinking on at reasoning effort medium, the server default, wherever the checkpoint has effort levels; the Nemotron and Ornith 1.5 templates have none, so those two ran at full thinking.}

Good to know

• Licence: the Swift weights are not Apache-2.0. UkisAI's contribution is under the Swift Open License v1.0 (LICENSE): commercial use by an organisation with US$1,000,000 or more in gross annual revenue (with its affiliates) is not licensed under it and needs a separate Swift Enterprise License from UkisAI; a qualified non-profit's non-commercial or research use is exempt from that threshold (§§1 and 5). The base-model portions stay under the Qwen Community License 1.0 (LICENSE-QWEN): products above 100 million monthly active users or US$20 million monthly revenue must show the model name prominently, and if the licensee or an affiliate runs a Model-as-a-Service or AI Work Assistant business, commercial use needs a separate licence from Qwen, except internal use that makes neither the software, its outputs nor its model capabilities available to third parties (§§1–2). NOTICE lists every change made here. This is a summary, not legal advice; the licence texts govern.
• Every figure we measured for this checkpoint comes from one setup: 4× RTX 3090 at 220 W, PCIe Gen4 x16 with P2P (the 3.0.1 and 3.0.2 figures also with the gpu-unlock host upgrade on); upstream results and the Other builds rows use their stated setups.
• Only if you shrink the KV pool yourself: keep it larger than --max-model-len plus a few blocks. With the shipped settings this cannot occur.
• Coming from the Swift1.5-qwen38-flash-next-3090s engine (v2.x or earlier)? It is replaced by the Merlin engine; this checkpoint's files are unchanged.

Changes

Date	Change to this repository
2026-11-05	Card updated for Merlin 3.0.2 (speed figures, options and install lines). The weights are unchanged.
2026-11-02	Card updated for Merlin 3.0.1 (speed figures and options). The weights are unchanged.
2026-10-06	tokenizer.json replaced with the upstream Qwen file (NOTICE and SHA256SUMS updated to match); re-fetch them if you downloaded earlier
2026-09-28	Weights published; unchanged since

_{Other card-only edits are not listed. Engine releases and their speed changes: the engine's CHANGELOG.}

Credits and licence

Qwen (model; Qwen Community License 1.0, see LICENSE-QWEN), UkisAI (Swift 1.5; Swift Open License v1.0, see LICENSE), Intel (AutoRound experts), RadixArk (FP8 PLE table), DominikBucko (MTP packing recipe), froggeric (the fixed Qwen3.8 chat template the engine serves), the vLLM community PLE-offload work, aikitoria (peer-to-peer on consumer Ampere), Neiko2002, and CoolShades (the idle-power report behind the v2.5.2 engine fix). Upstream fixes are credited in the engine repository.