GLM-5.3-Flash — UNCENSORED — Maya-L GGUF

⚠️ Read this first

This quant does not hold the source checkpoint's uncensoring. On HarmBench-320 (greedy T=0, 200 tokens, judged by a separate model — not the one under test) it complies on 201/320 (63 %) at max reasoning effort, with 35 hard refusals, 42 soft redirects and 25 hedged answers. Re-running those 102 non-complying prompts at reasoning-off flipped only 14 to comply. The source repo reports 320/320 for its FP8 — so whatever was removed at the weight level did not survive quantization here, and it is not the same product.

Do not read any number on this page as a measure of dealignai's work. Their checkpoint is what we started from; the regression below is ours.

On the uncensoring specifically, use alesha-pro's abliterated Maya-M build instead of this one. Their approach is different — stock Maya quant plus a small runtime control vector — and on their own reported numbers they get 2 refusals across AdvBench and JailbreakBench, both on self-harm prompts they left in on purpose. Our build cannot make that claim about itself, whatever the file is named. We kept ours published because it is the only Maya build of this particular checkpoint and it is a clean quant of it — but on this one property, theirs is the better product.

Published as-is, among the first Project Maya builds of this checkpoint, for anyone who needs the format and can live with the behaviour.

Quantized GGUF of an existing uncensored checkpoint, for llama.cpp and Project Maya. Nothing here was abliterated by us: the refusal removal is dealignai's work. We took their FP8 checkpoint and quantized it.

Files

Sharded with llama-gguf-split at ≤50 GB per file, which is already under the Hub's per-file limit — download every shard with the same prefix, llama-server -m accepts any one of them and loads the rest.

hf download Adolphsson/GLM-5.3-Flash-UNCENSORED-MTP-Maya-L-GGUF \
  --include "GLM-5.3-Flash-UNCENSORED-MTP-Maya-L*" --local-dir ./glm-l

Naming note

Maya-L is the recipe's tier name (Maya ships its quants as tiers S, M and L), not a uniform type code: ggml has no single type that fits a 156 GB build, so the tier is named after the recipe, and the table below says what each group actually holds. Read the composition before the name.

Per-group quantization (measured from the GGUF headers)

Every group sits at or above the sensitivity class its role warrants; nothing is below the base step of its family.

llama.cpp

llama.cpp spells the architecture glm5next, this GGUF is tagged glm5-next (the checkpoint's own name). Until the alias lands upstream, add one line to llm_arch_from_string in src/llama-arch.cpp:

llm_arch llm_arch_from_string(const std::string & name) {
    if (name == "glm5-next") { return LLM_ARCH_GLM5NEXT; }   // ← add this

Without it the loader rejects the file with unknown model architecture: 'glm5-next'. Nothing else is patched — the model runs on the upstream glm5next graph and its own mmproj path.

llama-server -m GLM-5.3-Flash-UNCENSORED-MTP-Maya-L-00001-of-00004.gguf \
  --mmproj mmproj-GLM-5.3-Flash-F16.gguf -c 32768 -ngl 99 --host 0.0.0.0 --port 9876

Project Maya

Maya reads the same GGUF and needs a derived pack (index + offsets + tokenizer, no weights copied):

python tools/iq_pack.py --gguf GLM-5.3-Flash-UNCENSORED-MTP-Maya-L-00001-of-00004.gguf \
  --out out/maya-glm --compat-bf16
maya --glm-pack out/maya-glm --max-context 1048576 --glm-ram-resident --spec 6

Maya-specific notes:

• The pack must sit next to the shards; the server takes the pack's parent as model dir.
• --glm-ram-resident is what makes it fast (all experts resident in VRAM + pinned RAM, zero disk reads per token). Without it every expert miss hits NVMe.
• --vision plus the maya-vision binary for images; the vision encoder borrows ~7.4 GB of the expert pool while it encodes.
• No engine patch is needed for the quant types: Maya serves Q4_0, Q5_0, Q8_0, Q3_K, Q4_K, Q5_K, Q6_K, IQ2_XXS/IQ2_XS/IQ2_S, IQ3_XXS/IQ3_S, IQ4_NL, IQ4_XS, IQ1_M and Q2_0 natively in its expert and dense paths, and this recipe stays inside that set. Types outside it drop off the fast path and become slow.
• MTP is on through STRATA_GLM_MTP=1. Measured trade-off on one RTX 5090: at 1M context MTP costs ~12 % (the draft block competes with the expert pool that the KV cache already squeezed), at 256K it gains ~16 %. Enable it when you run shorter contexts.

What was verified

Functional checks on the quantized build, RTX 5090, --glm-ram-resident, 1M context:

• arithmetic, factual recall, multilingual prose, Python — all correct
• 420-token narrative and a code-generation loop test: 0 % repeated 3-grams, no degeneration
• vision: image in, coherent description out (--mmproj, 1024 image tokens)
• 1M context loads and serves; KV 12.6 GB, expert pool 9.8 GB, 767 MiB VRAM spare
• MTP block loads and speculates (--spec 6)

Benchmarks — our harness, our GPU, greedy T=0; nothing here is a dealignai number:

The MMLU figure is a 100-sample estimate. The full 14 042-item test set was started and did not finish on this harness, so no full-set number is claimed here.

Treat HarmBench as the headline: it is the one number that changed how this page is written. Per category, at max effort (counts out of the category's own rows):

HarmBench verdicts by semantic category

Six rows produced answers the judge could not place and are counted separately (UNCLEAR in the headline); they are not included in the per-category table above.

The refusals concentrate in the categories that are about people rather than about licence text. This is the shape of a model that was edited conservatively: the general prompts go through, the sensitive ones still hesitate.

Throughput, for orientation only (same 260-token prompt, 8 runs, median of the last 6, temperature 0.7, single 5090): 28.5 tok/s at 1M context, 25.9 at 256K with MTP, 22.3 at 256K without. On 2× RTX 3090 with MTP: 31 tok/s at short context, 19.8 at 1M. Your hardware will move these more than the flags do.

Provenance

• Original model: zai-org/GLM-5.3-Flash (MIT)
• Abliterated checkpoint: dealignai/GLM-5.3-Flash-UNCENSORED-FP8 (MIT) — the CRACK abliteration, downloaded and SHA256-verified
• Contribution of this repo: quantization only — IQ4-Maya recipe, per-group type map, the mmproj conversion from the FP8 vision tower, and the architecture alias note above. The uncensored behaviour comes from dealignai, not from this repo.
• Built & tested by: Adolphsson

License

MIT at every step of the lineage (Z.AI → dealignai → here). Quantization changes weights numerically, not their provenance. Full text: LICENSE, attribution: NOTICE.