CaptchaKraken MidnightV2-4B (bf16)
Full-precision weights. Also available: the unmerged adapter CaptchaKraken/MidnightV2-4B-LoRA
and CPU builds for llama.cpp in CaptchaKraken/MidnightV2-4B-GGUF. Smaller models:
CaptchaKraken/TwilightV2-2B, CaptchaKraken/SunlightV2-0.8B.
The Midnight V2 family (4B)
Midnight V2 is the 4B CaptchaKraken v2 pointer model. Every repo below holds the same trained model:
| Repo | What |
|---|---|
CaptchaKraken/MidnightV2-4B |
merged bf16 weights, for vLLM (GPU) โ this repo |
CaptchaKraken/MidnightV2-4B-q4 |
4-bit GPTQ (W4A16) weights, for vLLM (GPU) |
CaptchaKraken/MidnightV2-4B-LoRA |
unmerged LoRA adapter + pointer heads, for further training |
CaptchaKraken/MidnightV2-4B-GGUF |
llama.cpp builds (Q4_K_M, BF16, mmproj), for CPU |
The other v2 pointer families: Sunlight V2 (0.8B, CaptchaKraken/SunlightV2-0.8B), Twilight V2 (2B, CaptchaKraken/TwilightV2-2B).
What this is
The generation-3 pointer model: Qwen/Qwen3.5-4B, LoRA-trained (rank 16, merged) with
small heads (pointer_heads.safetensors) that read the whole answer (action, points, drags,
text, video moment) from one
prefill of the prompt. There is no text generation. vLLM runs it as a pooling model
through the CaptchaPointerForConditionalGeneration plugin.
- Training run
20261103-qwen-4b-44k-offload: 43,963 boards (2 epochs over 23,343 rows), lr 1e-4 (heads 1e-3), accum 8, gradient checkpointing, half the boards drawn with numbered element marks. Trained on one RTX 5080 (1.27 s/board, 14.6 GiB peak). The 828 boards with 28โ32-frame videos had their saved activations offloaded to host RAM instead of being skipped (the previous Midnight run skipped 830); 3 boards were still skipped for memory. - Prompt: the fixed single prompt ("every captcha is asked the same prompt").
Loading it (read this first)
The heads match client commit c5c1620 of CaptchaKraken plus client-fixes.patch
(in this repo; it changes python/src/captchakraken/pointer/ only). The patch adds the
element-number head these weights were trained with (elem, 6-wide slots, PACKED = 225),
the marks cross-check, and the two vLLM serving fixes from the 0.8B card (full video
markers; prefix caching off). The unpatched c5c1620 client will refuse these heads.
from captchakraken.pointer.service import PointerService # client c5c1620 + client-fixes.patch
svc = PointerService("<this repo, downloaded>")
svc.solve(image=pil_image, marked=False) # no element detector; or frames=[...] for a clipvideo-cut video
On vLLM 0.25.1 the plugin is registered in the calling process only. Set
VLLM_ENABLE_V1_MULTIPROCESSING=0, or the engine process will report the architecture as
unsupported.
End-to-end solve rate (Tier 3)
Tier 3 is the whole product working: the CaptchaKraken client opens a real browser, finds the captcha on the page, asks this model, then clicks, drags, types or holds like a person, and the page's own answer check decides whether it was solved. It covers 149 captcha kinds from 18 vendors, each rebuilt as a local page from real captures, driven through both the Python and the JavaScript client (298 kind ร client pairs). A pair counts as solved when 2 attempts succeed, out of at most 3, each on a freshly dealt board. Mobile repeats 14 kinds on an emulated Pixel 7 with touch input. The gauntlet deals boards that cannot be solved mixed with ones that can, and passes only if the client works through the impossible ones without stalling and solves the rest.
| Pairs solved | Sunlight | Twilight | Midnight | Abyss (hosted API) |
|---|---|---|---|---|
| All kinds | 73% (219/298) | 79% (236/298) | 84% (251/298) | 88% (263/298) |
| Mobile (Pixel 7) | 54% (15/28) | 86% (24/28) | 79% (22/28) | 86% (24/28) |
| Gauntlet | 100% (2/2) | 100% (2/2) | 100% (2/2) | 100% (2/2) |
By vendor (pairs; each kind counts twice, once per client):
| Vendor | Sunlight | Twilight | Midnight | Abyss (hosted API) |
|---|---|---|---|---|
| hCaptcha | 81% (158/194) | 86% (166/194) | 92% (178/194) | 93% (180/194) |
| Dingxiang | 60% (12/20) | 70% (14/20) | 70% (14/20) | 85% (17/20) |
| GeeTest | 62% (10/16) | 75% (12/16) | 75% (12/16) | 88% (14/16) |
| FunCaptcha (Arkose) | 14% (2/14) | 14% (2/14) | 14% (2/14) | 36% (5/14) |
| NetEase Yidun | 29% (4/14) | 57% (8/14) | 64% (9/14) | 79% (11/14) |
| reCAPTCHA | 50% (4/8) | 75% (6/8) | 75% (6/8) | 75% (6/8) |
| BotDetect | 100% (6/6) | 100% (6/6) | 100% (6/6) | 100% (6/6) |
| Tencent | 100% (6/6) | 100% (6/6) | 100% (6/6) | 100% (6/6) |
| AWS WAF | 100% (2/2) | 100% (2/2) | 100% (2/2) | 100% (2/2) |
| CaptchaFox | 100% (2/2) | 100% (2/2) | 100% (2/2) | 100% (2/2) |
| HUMAN Security | 100% (2/2) | 100% (2/2) | 100% (2/2) | 100% (2/2) |
| KCAPTCHA | 100% (2/2) | 100% (2/2) | 100% (2/2) | 100% (2/2) |
| Lemin | 100% (2/2) | 100% (2/2) | 100% (2/2) | 100% (2/2) |
| MTCaptcha | 100% (2/2) | 100% (2/2) | 100% (2/2) | 100% (2/2) |
| Press-and-hold bars | 100% (2/2) | 0% (0/2) | 100% (2/2) | 100% (2/2) |
| Prosopo | 50% (1/2) | 100% (2/2) | 100% (2/2) | 100% (2/2) |
| Proton | 100% (2/2) | 100% (2/2) | 100% (2/2) | 100% (2/2) |
| Yandex SmartCaptcha | 0% (0/2) | 0% (0/2) | 0% (0/2) | 0% (0/2) |
By what the captcha asks for:
| Kind | Sunlight | Twilight | Midnight | Abyss (hosted API) |
|---|---|---|---|---|
| Click a still board | 66% (101/154) | 81% (125/154) | 81% (125/154) | 88% (136/154) |
| Click an animated board | 79% (22/28) | 68% (19/28) | 86% (24/28) | 79% (22/28) |
| Drag | 83% (68/82) | 80% (66/82) | 90% (74/82) | 93% (76/82) |
| Slider | 75% (12/16) | 75% (12/16) | 75% (12/16) | 81% (13/16) |
| Type the text | 83% (10/12) | 83% (10/12) | 83% (10/12) | 83% (10/12) |
| Press and hold | 100% (6/6) | 67% (4/6) | 100% (6/6) | 100% (6/6) |
Measured with the client that became release 4.2.0: Twilight, Midnight and Abyss on 2026-11-12, Sunlight on 2026-11-13 in bf16 through vLLM 0.25.1 on an RTX 3060. Twilight was served in bf16 through transformers, Midnight and Abyss as 4-bit GPTQ through vLLM 0.25.1 (Abyss's is the build the hosted API runs). Abyss is the hosted model (CaptchaKraken v1.2 Abyss), whose weights are not public. With 2โ3 attempts per kind, a single kind can flip between runs, so read small vendors as rough. Known weak spots for every model: FunCaptcha's matching games, and Yandex, whose two words are bent around a curve (the larger models read the first word and lose the second).
Static image annotation solving (Tier 2)
The Tier 2 gate set: 1,067 hand-labelled real boards.
Static image annotation solving is scored against real human solves. Every board is a real captcha captured from a vendor's live widget and solved by hand, and the points, drag ends, grid cells and text that person chose are the answer key. Each answer is scored by how close it lands to the human solve points: a click counts when every target is pressed once, each within 6% of the image diagonal of the human's point; a drag when it is dropped within 5%; a grid when it picks the same cells; typed text when it matches; and on an animated board the moment must be right too. No browser or vendor is involved: this measures how well the model reads one board, not the end-to-end solve (see Tier 3 above).
Solved rate, run through transformers on an RTX 5080 (median 151 ms per board), not through vLLM.
| solved | |
|---|---|
| All | 75.2% (1,067) |
| All stills | 77.9% |
| Click (674) | 78.3 |
| Grid (223) | 78.5 |
| Type (12) | 41.7 |
| Video (158) | 59.5 |
Against the previous Midnight run (20261102-qwen-4b-44k, same recipe, but the 830
longest videos skipped instead of offloaded): stills 76.7% โ 77.9%, video 59.5% โ 59.5%. Keeping the long videos did not
move the video score; the stills gained about a point.
These numbers are from transformers, so they are not directly comparable with the TwilightV2-2B card's vLLM numbers (72.6%).
Per-board results (eval/eval_gate.jsonl, one line per board and mode) and the run's
validation split scores (eval/val.json) are in eval/.
Static image annotation solving across the family (Tier 2)
This model is the Midnight column. Bold marks it.
Every v2 pointer model, on the same 1,067 hand-labelled real boards (scored against the human solve points as above), served through vLLM 0.25.1. Percent of boards solved; higher is better. q4 is 4-bit GPTQ (W4A16); the others are bf16 unless named. Sunlight is the 0.8B model, Twilight 2B, Midnight 4B, Abyss 4B (the hosted API, 4-bit).
| Sunlight | Sunlight q4 | Twilight | Midnight | Midnight q4 | Abyss (hosted API) | |
|---|---|---|---|---|---|---|
| All (1,067) | 58.9% | 59.1% | 72.6% | 75.4% | 75.1% | 78.6% |
| Click (674) | 65.4 | 66.3 | 76.3 | 78.3 | 77.9 | 84.1 |
| Grid (223) | 41.7 | 39.9 | 75.8 | 78.9 | 78.9 | 78.9 |
| Video (158) | 57.0 | 57.6 | 54.4 | 59.5 | 59.5 | 57.6 |
| Type (12) | 33.3 | 33.3 | 50.0 | 50.0 | 50.0 | 41.7 |
- Twilight solves 14 points more than Sunlight on the plain boards (clicks +11, grids +34). Midnight adds 3 more.
- Video barely follows size: Midnight leads it at 59.5%, and the three are within 5 points of each other.
- 4-bit moves the plain totals by 0.3 points or less. A Twilight q4 has not been measured or published.
How far to trust the gaps:
- Twilight and Midnight were trained on the same data (23,343 rows), so their gap is model size. Sunlight (40,000 rows, 2026-11-13) and Abyss were trained on newer builds that add FunCaptcha's pager games, so their gaps are not size alone.
- Type has only 12 boards, so treat that row as rough.
- Sunlight and Abyss were scored on an RTX 3060, the others on an RTX 5080. The answers are compared, not the speed.
- Abyss is the model the hosted CaptchaKraken API answers with (CaptchaKraken v1.2 Abyss): a Midnight-sized 4B trained further, served as 4-bit GPTQ. Its weights are not public, so it has no per-board link below.
- MidnightV2-4B's own Tier 2 results were run through transformers, so use this table, not those, to compare it with the other models.
Per-board results: Sunlight, Sunlight q4, Twilight, Midnight, Midnight q4.
License: LGPL-3.0.
- Downloads last month
- 86