0xWhiteMage's ThinkingCap recipe: Qwen3.8-27B Kearuga, EXL3 4.00 bpw

What it builds as an agent

Task: Voxel world (3D scene, one HTML file). One attempt, no help. Counted: the final file counts.

Design and create the most impressive, creative, elaborate and detailed
voxel art world you are capable of. The theme and style are ENTIRELY your
choice — pick whatever world you can execute best and push it as far as
you can: scale, variety, detail, color, animation, atmosphere, life.
Surprise me.

Hard requirements:
- Everything ends up in ONE single self-contained HTML file (game.html in
  the current working directory) that opens and runs directly in Chrome.
  Use WebGL and whatever libraries you like, but embed everything —
  no internet access at view time, no external files.
- The scene must present itself: include an automatic slow cinematic
  camera tour (orbiting the world, occasionally zooming in on highlights)
  that starts on load, plus mouse controls (orbit/zoom) for manual viewing.
- All user-facing text (UI, HUD, titles, descriptions, hints) must be in
  ENGLISH, regardless of the language of any project files you encounter.

When finished, verify your HTML actually loads and renders without
console errors, then state DONE with the absolute path of game.html.
Do not ask questions.

How you work (same for every model):
- You work alone in the folder /work (this is the current working directory). Nobody will answer questions. Aim to finish in about 60 minutes. After 90 minutes you will get a message to finish; then you have at most 30 more minutes. Hard stop after 120 minutes.
- Tools on this machine: shell, files, python3 with numpy and Pillow, ffmpeg, node, and `shot.sh game.html` (opens the page in a headless browser, saves a screenshot and prints console errors). There is no internet and no access to other machines.
- Keep a working /work/game.html at all times. If you are stopped, the last version that loaded without errors counts.
- JavaScript libraries available offline in the test browser, through an import map with these exact URLs: "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js", "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/", "simplex-noise": "https://cdn.jsdelivr.net/npm/simplex-noise@4.0.3/dist/esm/simplex-noise.js", "@tweenjs/tween.js": "https://cdn.jsdelivr.net/npm/@tweenjs/tween.js@25.0.0/dist/tween.esm.js", "cannon-es": "https://cdn.jsdelivr.net/npm/cannon-es@0.20.0/dist/cannon-es.js". No other external resources.
- After the scene is built, set `window.scene` to the Three.js scene (if you use Three.js) and `window.ready = true`.

The browser check

• page loads without page error1 / 1
• window.ready === true within 30 s1 / 1
• no console errors (whole session)1 / 1
• frame is not blank1 / 1
• frame rate in software GL (rAF over 5 s)0 / 1
• world: scene size 0.5 (parts >= 80 or >= 20000 triangles; canvas fallback), visible text English if any 0.51 / 1
• automatic camera tour: the view changes on its own in two successive ~5 s windows (1 each)2 / 2
• animation in the world (nodes / instances / particles moving besides the camera)1 / 1
• OrbitControls: drag and wheel change the picture beyond the animation baseline0 / 1

Measured 2026-10-22. Raw files: check · run info · command · final choice · contract · sampling · gate stats · screenshot · clip.mp4 · web.mp4 · web-poster.jpg.

This is the rebuild of the showcase (22 Oct 2026). The first run of this setup (20 Oct) used a launcher that set OpenCode's answer limit to 253,952 tokens without an input limit. OpenCode 1.19.3 then summarised the conversation as soon as it passed 8,192 tokens (262,144 minus 253,952), and in that first run it did so 24 times. The rebuild uses the corrected launcher (opencode-limit-input), which also gives OpenCode the real input limit of 262,144 tokens, so it summarises only at 242,144 tokens. Model, engine, recipe, server settings and prompt are the same as in the first run. The first run's world is no longer shown here. Browser check 8.0 out of 10: the page loads, runs without console errors, is not blank, builds a world of 56,214 parts and 676,872 triangles with English text, animates, and the automatic camera tour works (the picture changed on its own in both 5-second windows). The 2 lost points are the frame rate (1.3 frames per second in software rendering without a GPU, 20 are needed: 0 of 1 point) and the orbit check (mouse drag and wheel did not change the picture beyond what the page animates on its own: 0 of 1 point). The agent worked for 91.7 minutes. The “finish now” message (at 90 minutes) reached it in 2 requests, and it then ended by itself before the hard stop at 120 minutes. One try, no help. 14 versions of the page were seen, 11 loaded without errors, and the final version counts. The limit per answer was 253,952 tokens, the highest value the model card names (BottleCap card, README line 92). The recipe's own server default is 131,072 tokens (scripts/serve.py:77-80) and applies only when a request sets none, so I raised the limit; the server setup is unchanged. My test gate shortened the limit of a request 61 times to what was left of the context. The run made 62 requests (gate-stats.json) and the model wrote 144,489 tokens in total. My count from the gate log: 61 were the agent's own steps and 1 wrote the title, OpenCode did not summarise the conversation once (0 times, against 24 in the first run), and the longest prompt had 168,597 tokens. That log is not published because it holds file paths from the agent's tool output. Thinking was on with the card's thinking sampling (temperature 1.0, top_p 0.95, top_k 20). No reasoning effort was sent; the chat template's default is xhigh (chat_template.jinja:47).

run_showcase.sh --harness opencode-limit-input --task VX --upstream http://127.0.0.1:43407/v1 --model Qwen3.8 27B Kearuga (ThinkingCap) --sampling-file $RUN/sampling-show.json --out $RUN/raw/tc-neubau-l1-2210-show-r0/show --limit-s 7200 --inject-after-s 5400 --poll-s 20 --ctx 262144

How fast it runs

Method: code+prose; 2 run(s) each; 512 tokens; 1 warm-up(s); median; requests at once (later supplementary run of 2026-10-22, same setup): C1,C2,C4,C8 at once; 2 rounds each; 512 tokens per request; prose prompt; total = all tokens / wall time, per request = tokens / end-to-end time; median over the rounds. Measured 2026-10-20 (requests at once: 2026-10-22). Raw files: speed result · speed contract · log · long answer · speed result · speed contract · log.

Requests at once: the server has 16 slots (from the author's recipe). The speed test ran with the model card's sampling (temperature 1.0, top_p 0.95, top_k 20; the card names one set for thinking on and off) and thinking off. The recipe runs 16 lanes (scripts/serve.py:77), so 1, 2, 4 and 8 requests at once all fit within them: the total grows from 38.55 to 125.15 tok/s while each request slows from 38.55 to 16.42 tok/s.

python3 speed2.py --base-url http://127.0.0.1:40065/v1 --label run-speed-r0 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/raw/plan-2010-speed-r0/work/speed2 --contract $RUN/raw/plan-2010-speed-r0/work/speed2/speed-contract.json --parts decode,prefill,conc,l1 --prefill-depths 2048,8192,32768 --prompt-ids code,prose --runs 2 --max-tokens 512 --warmups 1 --prefill-runs 3 --tokenizer-json $HOME/thinkingcap-1910/recipe/models/target/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 1.0, "top_p": 0.95, "top_k": 20, "min_p": 0.0} --sampling-source https://huggingface.co/0xWhiteMage/ThinkingCap-Qwen3.8-27B-Kearuga-EXL3-4.00bpw/blob/11447639033dd80a4c04536b5b37ed7d642802ee/README.md lines 178-181 (curl example: temperature 1.0, top_p 0.95, top_k 20, chat_template_kwargs enable_thinking true + reasoning_effort xhigh) and generation_config.json lines 9-11 (temperature 1.0, top_k 20, top_p 0.95); min_p 0.0 from https://huggingface.co/bottlecapai/ThinkingCap-Qwen3.8-27B-GGUF README.md line 100 (rev dc3aa8563d5d48d1d83637eb67147e1b52215cf7). The card gives no separate non-thinking set: the same values are used with thinking off. presence_penalty is not named by any ThinkingCap card -> not sent. --model Qwen3.8 27B Kearuga (ThinkingCap) --no-cache-prompt --server-log $RUN/logs/server-A.log --engine-version-file $RUN/logs/engine-version.txt

# Requests at once: supplementary run of 2026-10-22 (raw folder speed-r0-conc)
python3 speed2.py --base-url http://127.0.0.1:38621/v1 --label run-speed-r0 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/raw/plan-2210-speed-r0/work/speed2 --contract $RUN/raw/plan-2210-speed-r0/work/speed2/speed-contract.json --parts conc --prefill-depths 2048,8192,32768 --prompt-ids code,prose --runs 2 --max-tokens 512 --warmups 1 --prefill-runs 3 --conc-levels 1,2,4,8 --conc-rounds 2 --conc-max-tokens 512 --conc-prompt prose --tokenizer-json $HOME/thinkingcap-1910/recipe/models/target/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 1.0, "top_p": 0.95, "top_k": 20, "min_p": 0.0} --sampling-source https://huggingface.co/0xWhiteMage/ThinkingCap-Qwen3.8-27B-Kearuga-EXL3-4.00bpw/blob/11447639033dd80a4c04536b5b37ed7d642802ee/README.md lines 178-181 (curl example: temperature 1.0, top_p 0.95, top_k 20, chat_template_kwargs enable_thinking true + reasoning_effort xhigh) and generation_config.json lines 9-11 (temperature 1.0, top_k 20, top_p 0.95); min_p 0.0 from https://huggingface.co/bottlecapai/ThinkingCap-Qwen3.8-27B-GGUF README.md line 100 (rev dc3aa8563d5d48d1d83637eb67147e1b52215cf7). The card gives no separate non-thinking set: the same values are used with thinking off. presence_penalty is not named by any ThinkingCap card -> not sent. --model Qwen3.8 27B Kearuga (ThinkingCap) --no-cache-prompt --server-log $RUN/logs/server-A.log --engine-version-file $RUN/logs/engine-version.txt --server-slots 16 --server-slots-source 0xWhiteMage/thinkingcap-qwen3.8-27b-exl3-tensorfold-cuda@55efde56 scripts/serve.py:77 (GB10 box profile default --parallel 16; passed to tensorfold serve at :42; README.md:42 "C16 aggregate") --supplement-of run-speed-r0

How well it answers

Thinking off, except the last test. Seed 42. Sampling from the model card. A cut-off answer counts as wrong. Measured 2026-10-20.

Note from the run: 6 of 30 GPQA answers with thinking were cut off at their limit of 16,384 tokens and 1 of 40 LiveCodeBench answers at its limit of 32,768 tokens; these count as wrong. In the other quality-v2 tests (MMLU-Pro, GPQA Diamond (letter only), IFEval and the long-text tests) no answer was cut off. GPQA Diamond ran on the public mirror fingertap/GPQA-Diamond (the original is gated). These are my own tests of this setup.

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-tensorfold-1x.json --parts mmlupro --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-tensorfold-1x.json --parts gpqa --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-tensorfold-1x.json --parts ifeval --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-tensorfold-1x.json --parts lcb --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-tensorfold-1x.json --parts ruler --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-tensorfold-1x.json --parts ruler --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-tensorfold-1x.json --parts think --job plan-2010

How much context fits

Memory test. For each context size (4K, 8K, 16K ... up to the largest size tested for the setup) the server is started again with that context, one prompt that fills about 95 % of the context is sent, and the model must answer. The largest size that loaded and answered counts. Decode speed is measured on that answer at the largest size. Peak memory is the rise of used memory (MemTotal - MemAvailable) over the idle value before the step, on the one box. Unified memory, so GPU and CPU share it. Measured 2026-10-20. Raw files: result of every step · log · contract.

Note from the run: The largest size tested is 262,144 tokens, the recipe's context; all seven sizes loaded and answered. Decode speed at these sizes is not measured (the server returns no timings), so the sentence on decode speed in the method text does not apply to this run. The memory number is the rise over the idle value (unified memory) at the largest step and includes the model weights.

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-tensorfold-1x.json --parts fit --job plan-2010

Also made this possible

• ModelQwenHugging Face @Alibaba_Qwen GitHub Website
• ThinkingCap fine-tuneBottleCap AIHugging Face GitHub Website
• Engine (TensorFold)Ash Hart@ashxhart GitHub Hugging Face Website

Run it yourself

What you need and how to start it, step by step. The results below come from exactly this setup.

What you need

Hardware

1x NVIDIA DGX Spark

Model

0xWhiteMage/ThinkingCap-Qwen3.8-27B-Kearuga-EXL3-4.00bpw @d6df32fa (recipe pin; weights = HEAD 11447639) (ThinkingCap by BottleCap AI on Qwen3.8-27B)

ThinkingCap fine-tune

huggingface.co/bottlecapai/ThinkingCap-Qwen3.8-27B

Engine

TensorFold on one DGX Spark — the program that loads the model and answers requests · github.com/ashhart/TensorFold

Recipe and EXL3 quant (Kearuga 4.00 bpw)

github.com/0xWhiteMage/thinkingcap-qwen3.8-27b-exl3-tensorfold-cuda by 0xWhiteMage

Context window

262,144 tokens: how much text the model can see at once

Steps

1. Get the recipe, the engine and the model files from the list above.

2. Start the server with this command. It loads the model into memory. When the model has loaded, the server waits for requests on port 8888, only from this computer.

   Copy

   python3 scripts/serve.py ($HOME/thinkingcap-1910/recipe @55efde56, no flags; = docker run \
     -d \
     --name thinkingcap-exl3 \
     --gpus all \
     --ipc=host \
     --network host \
     --cpuset-cpus 5-9,15-19 ... tensorfold serve /models/target \
     --drafter /models/drafter \
     --drafter-bits 4 \
     --backend cuda \
     --kv-dtype bf16 \
     --no-prefill-fp8 \
     --parallel 16 \
     --context 262144 \
     --host 127.0.0.1 \
     --port 8888 \
     --name 'Qwen3.8 27B Kearuga (ThinkingCap)' \
     --max-tokens 131072 \
     --no-update-check); via GB10 box 2-thinkingcap-27b-kearuga.sh start

   What the parts mean

   • --parallel 16how many requests it answers at the same time
   • --host 127.0.0.1who can connect: only this computer
   • --port 8888the network port the server listens on

TensorFold Python CUDA 0.6.6 (ashhart/TensorFold ed78d6fc + PR #260 rebased + GB10 depth planning), image thinkingcap-exl3:0.2.0, GB10 box profile; python3 scripts/serve.py ($HOME/thinkingcap-1910/recipe @55efde56, no flags; = docker run -d --name thinkingcap-exl3 --gpus all --ipc=host --network host --cpuset-cpus 5-9,15-19 ... tensorfold serve /models/target --drafter /models/drafter --drafter-bits 4 --backend cuda --kv-dtype bf16 --no-prefill-fp8 --parallel 16 --context 262144 --host 127.0.0.1 --port 8888 --name 'Qwen3.8 27B Kearuga (ThinkingCap)' --max-tokens 131072 --no-update-check); via GB10 box 2-thinkingcap-27b-kearuga.sh start

Mia's own benchmark, run unchanged

This is Mia's own benchmark tool (commit 21a3511), run unchanged. It has its own section on this page, and it is never mixed with my numbers. A cut-off answer counts as wrong here, so a value can differ from sparkDash's own screen.

Seed 1234 applies to the two quality tests; decode, prefill and tool eval send no seed. The benchmark client ran on a separate machine that is never part of the measured group. Measured 2026-10-20. Version 2.50.0, commit 21a3511.

QA. Quality QA, 150 items, seed 1234, temperature 0, thinking off, 4 requests at once (Mia's default). An answer cut off at the token limit counts as wrong. ± is the 95 % margin (Wilson).

MMLU. Quality MMLU, 285 items (5 for each of 57 subjects, 4 answers), seed 1234, temperature 0, thinking off. An answer cut off at the token limit counts as wrong. ± is the 95 % margin (Wilson).

Decode. Decode bench, 1 request at once, 400 tokens, prompt type structured, temperature 0, thinking off. No seed is sent.

Prefill. Prefill bench at 4K, 8K, 16K and 32K tokens. sparkDash skips a size that does not fit into the context. No seed is sent.

Tool Eval Quick. Tool Eval Quick: tool-eval-bench (SeraphimSerapis, commit c61319b), 15 core scenarios (--short), --no-think, --timeout 120. Score 0 to 100. No seed is sent.

python3 tools/quality2/sparkdash_client.py tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-tensorfold-1x.json <box> --client <client machine> --job plan-2010 --out $RUN

tool-eval-bench --base-url http://127.0.0.1:<port> --model 'Qwen3.8 27B Kearuga (ThinkingCap)' --short --no-think --timeout 120 --json-file $BENCH/sparkdash-client/runs/work/tooleval/result.json --no-live