Instructions to use Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked")
model = AutoModelForMultimodalLM.from_pretrained("Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked

SGLang

How to use Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked with Docker Model Runner:
```
docker model run hf.co/Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked
```

Qwopus3.8-27B-Coder-Flash, GPTQ INT4 baked (v1.0.1)

Jackrong/Qwopus3.8-27B-Coder-Flash quantized from BF16 to INT4 by Launch80. The lm_head and the MTP draft head are INT4 on disk too, so a single Intel Arc Pro B65 32 GB serves it at the full 262,144-token context, and stock vLLM loads it with no weight patches.

This model is a work in progress, and the full story is public:

The study, with every number, the bug we found and how we fixed it: https://launch80.com/blog/qwopus-coder-int4-bake-study
Follow along and ask questions in the Launch80 Discord: https://discord.gg/launch80

version	what changed	status
v1.0 (tag `v1.0`)	GPTQ INT4 body calibrated with tool-call data, baked INT4 head and MTP	released 2 Nov 2026
v1.0.1 (this revision, tag `v1.0.1`)	card only, weights unchanged: all seven tasks measured on this exact checkpoint, served as shipped (MTP k=6)	released 2 Nov 2026
next	a faster drafter adapted to Qwopus (target: 115 tok/s on the B65)	in progress

What's in it

tensor	source (BF16)	this repo
400 body linears	BF16	GPTQ INT4 sym g128 (GPTQModel 7.3.2)
`lm_head` (248,320 × 5,120)	BF16, 2.54 GB	GPTQ INT4 sym g128, Hessian-calibrated
`mtp.*` draft: `fc`, q/k/v/o, gate/up/down	BF16	GPTQ INT4 sym g128, Hessian-calibrated
embeddings, norms, vision tower, GDN `in_proj_a`/`in_proj_b`	BF16	unchanged (byte-identical)

17.0 GB on disk. The tokenizer, chat template and processor files are the source repo's, unchanged.

Body. GPTQModel 7.3.2 ran on the Arc Pro B65 itself with these settings:

4-bit, symmetric, group 128
desc_act off, act_group_aware on
damping 0.05, seed 608
512 × 2048-token calibration samples: 153 C4, 204 code, 53 chat and 102 tool-call conversations. The tool-call samples are from NousResearch/hermes-function-calling-v1 @dae3e1d, rendered through the model's own chat template with tools=, half of them parallel calls.

The calibration sha256 is in quant-meta.json.

Head and MTP bake. These steps follow the layout of our earlier bakes:

Forward hooks inside vLLM captured Hessians on wikitext, chat and code slices.
Each of the nine linears was GPTQ-quantized under a grid of dampings and slice mixes.
The setting with the lowest output error on held-out rows was kept.

Every baked linear beats round-to-nearest (RTN):

linear	baked	RTN
`lm_head`	4.68%	8.18%
`mtp.fc`	6.98%	11.47%
`mtp…q_proj`	2.68%	4.44%
`mtp…k_proj`	6.05%	10.08%
`mtp…v_proj`	5.11%	8.28%
`mtp…o_proj`	6.67%	13.04%
`mtp…gate_proj`	3.67%	6.35%
`mtp…up_proj`	5.70%	9.56%
`mtp…down_proj`	7.57%	11.96%

Quality vs BF16 (pre-registered)

We wrote the thresholds down and hashed them before any quantized model was evaluated. The BF16 reference ran on a rented RTX PRO 6000 (vLLM 0.30, CUDA); this checkpoint ran on the Arc Pro B65 (vLLM 0.30, XPU), served exactly as shipped, with MTP k=6 on for every task and for the logprobs. Full study: https://launch80.com/a/84829a3a-a0b2-407f-ab38-59cd2d5006fa

#	measure	bar	this checkpoint
T1	wikitext-2 perplexity	≤ +3%	+1.72%	pass
T2	code-corpus perplexity	≤ +3%	+1.83%	pass
T3	mean next-token KL divergence (1.05M tokens, top-64)	≤ 0.05	0.0412	pass
T4	top-1 next-token agreement	≥ 93%	92.84%	fail (by 0.16 pt)
T5	seven tasks, paired pass@1, greedy	Δ ≥ −2 pts or CI includes 0	7/7 tasks (table below)	pass
T6	KLD vs Jackrong's Q4_K_M GGUF	ours ≤ theirs	not measured yet	pending
T7	greedy, spec decoding on = off	identical	26/32; all 6 differences are at a tie (3 exact, 3 a 0.0156 FP16 step)	fail as written

task	BF16	this checkpoint	Δ pts [95% CI]
GSM8K	86.96	86.66	−0.30 [−1.21, +0.61]
IFEval	80.22	80.78	+0.55 [−2.22, +3.14]
MMLU-Pro subset	71.80	70.90	−0.90 [−2.70, +0.90]
HumanEval+	90.24	88.41	−1.83 [−5.49, +1.83]
MBPP+	76.98	75.66	−1.32 [−3.17, +0.53]
BFCL subset (400)	89.00	88.25	−0.75 [−3.00, +1.50]
LiveCodeBench v6 slice	41.14	40.57	−0.57 [−5.14, +4.00]

Needle retrieval: 100% at 32k and at 128k. MTP draft acceptance over the whole suite: 46.8% of drafted tokens (80.2 / 62.2 / 48.0 / 37.4 / 29.5 / 23.3% by draft position), about 3.8 tokens per verify step under greedy decoding.

Disclosure: the tool-call calibration is a post-hoc fix. The first bake, with no tool calls in its calibration set, passed six of the seven tasks but lost 7.75 points on BFCL. It ended its turn after the first of several parallel calls. We traced that to the calibration data, recalibrated the body, and rebaked the head and MTP. This checkpoint is that rebake, and the table above measures it on all seven tasks. The change was made after seeing results, so treat it as post hoc. The blog post has the whole investigation.

Speed (Arc Pro B65 32 GB, vLLM 0.30.0 XPU, fp8 KV, single stream)

Quick BetterBench run (1 warmup + 5 passes per category), MTP k=6, 262k context: 75.8 tok/s weighted decode, 216 ms TTFT p50, prefill 1,283 tok/s at 2K and 856 tok/s at 64K, 210.9 tok/s aggregate at 8 concurrent. Page: https://launch80.com/a/30aa8ae2-f00c-409a-a4a9-2e298fc81f67

Decode is held back by the draft head, not the INT4 body. Jackrong's fine-tune left the MTP head byte-identical to base Qwen3.8-27B, so it drafts the base model's style and gets about 3 tokens per step in the BetterBench run (sampled), 3.8 under greedy decoding. A drafter adapted to Qwopus is the next version. Follow it on the blog and in Discord.

Serving

vllm serve Launch80/Qwopus3.8-27B-Coder-Flash-Int4-baked \
  --quantization gptq --dtype float16 --kv-cache-dtype fp8 --max-model-len 262144 \
  --speculative-config '{"method":"mtp","num_speculative_tokens":6}' \
  --enable-auto-tool-choice --tool-call-parser qwen3_xml --reasoning-parser qwen3

Every number above was measured with this configuration (vLLM 0.30.0 XPU image), plus three vLLM-XPU correctness patches for speculative decoding (MTP nightly, MTP boundary, GDN mixed-split) from the launch80/B65 repository. Tool calling needs qwen3_xml, not hermes. Pin a revision (--revision v1.0.1) if you want this exact build; main moves as new versions ship.

License

Apache-2.0, as the source model and the Qwen3.8-27B base are.

Credits

Qwen (Qwen3.8-27B) · Unsloth (the base Jackrong built on) · Jackrong (Qwopus3.8-27B-Coder-Flash) · NousResearch (hermes-function-calling-v1, used for calibration) · GPTQModel · Wrapzii (asked for this bake, and the on-disk bake layout it follows).