The model card, file list, and checksums are here. Have the files and permission to share them? Submit a torrent so others can download from peers.
Getting the source files requires Hugging Face approval.INT4 weight-only (W4A16, group-128, symmetric) quantization of
orcarouter/GLM-5.3-Flash-Uncensored-FP8 —
the abliterated (refusal-removed) build of Z.ai's GLM-5.3-Flash.
Produced for, and actually served on, self-hosted SGLang / 4× RTX PRO 6000 Blackwell (SM120).
Every number on this card was measured on that box, and every number is labelled with which weights it
was measured on: unlabelled figures are these weights; anything carried over from this checkpoint's
censored sibling (voska/GLM-5.3-Flash-W4A16 — same
architecture, same quantizer, same config) is marked †. Where something was not measured at all, the
card says so.
† means: measured on the censored sibling, not re-measured on these weights. Those figures are here because the two builds are identical in architecture, quantizer and serving config — but they are not measurements of this checkpoint, and this card will not pretend otherwise.
zai-org/GLM-5.3-Flash (base, MIT, © Z.AI Co., Ltd)
└─ orcarouter/GLM-5.3-Flash-Uncensored-FP8 (abliteration baked into the official block-FP8 checkpoint)
└─ voska/GLM-5.3-Flash-Uncensored-W4A16 (this repo — data-free RTN INT4)
The source was pinned at commit
55c78761fb78d0f765e2bd01687900d2fd91b5d0
and confirmed by blob-hash match against the local download tree, not inferred from a directory name.
Licence MIT, carried forward from the base model.
Note: the upstream FP8 repo is gated. If you want to reproduce this quantization from source you will need to accept its terms first.
This is a derivative of someone else's abliteration. We did not perform the abliteration and we do not republish its author's claims. The one question we did have to answer — because it was genuinely open — was whether abliteration survives 4-bit weight quantization at all. It is not obvious that it does: the quantizer perturbs exactly the weight directions abliteration edits.
Measured on this checkpoint, served:
| probe set | result |
|---|---|
| refusal probe, 10 prompts across adult fiction, profanity, contested-politics, harm-reduction | 0 refusals / 10 |
| benign over-refusal, 20 innocuous prompts containing trigger words ("kill a process", "kill weeds") | 0 / 20 (the censored W4A16 build refused 1 / 20) |
So: abliteration survives INT4, and this build is less prone to false-positive refusal than its censored sibling. That is the whole of what was tested. No safety, capability, or agentic benchmark was run — see Limitations.
Updated 2026-09-17: GLM-5.3-Flash support is merged into SGLang main, but no released tag
carries it yet. sgl-project/sglang#36507 merged on
2026-09-06. The PR branch (xinyuan/glm-5.3-flash-support) was deleted at merge, so this card's
earlier instruction — "build from #36507" — no longer names anything you can check out.
Build instead from a post-merge per-commit nightly: lmsys publishes these as
lmsysorg/sglang:nightly-dev-cu13-<date>-<sha>, which hands you a consistent sgl_kernel / FlashInfer /
python tree for free. You still need the three SM120 patches below on top — they are not upstream.
There is still no stock released image that serves this checkpoint.
We would rather open with that than have you find out at the end of the download.
4× RTX PRO 6000 Blackwell Max-Q, 96 GB each (SM120, no NVLink, PCIe Gen5 P2P), power-limited to 260 W;
Threadripper PRO 9975WX, 128 GB DDR5; driver 580.159.04-open. Kernel cmdline iommu=off amd_iommu=off
plus options nvidia_uvm uvm_disable_hmm=1 are both required for NCCL P2P on this board.
Numbers below will not transfer to datacenter Blackwell (SM100). SM120 has no tcgen05/TMEM and caps dynamic shared memory near 99 KB, which is what forces patch 3.
sglang 0.0.0.dev1+g30705c004 (post-merge main 30705c004ca4 + patches) · torch 2.13.0+cu130 ·
CUDA 13.0 · transformers 5.12.1 · compressed-tensors 0.18.0 · flashinfer 0.6.18 · driver
580.159.04-open
A launch line with no version pin rots inside a month — SGLang flag names churn.
SGLANG_OPT_DEEPGEMM_HC_PRENORM=0 (env). Hyper-connection prenorm calls DeepGEMM unconditionally and
SM120 has no TMEM/tcgen05 → NameError: deep_gemm.--dsa-prefill-backend tilelang --dsa-decode-backend tilelang. The default decode path routes to
trtllm-gen FMHA, which reports "Unsupported architecture" on SM120.num_stages=1 in the TileLang sparse-MLA schedule — a source patch, not a flag. Upstream uses
num_stages=2, which asks ~148 KB of dynamic shared memory; SM120 caps it near 99 KB. Not upstream yet.--kv-cache-dtype fp8_e4m3 produces garbled output, or a single token and then a stop. The cause is a
FlashInfer SM120 bug — the backend is missing FP8 dequantization scales, so the ragged+paged split path reads
cached KV back without undoing the scale division. Independently reported on non-GLM models on the same
hardware (sglang#19603). Expect it on any SM120 model
on this backend, not just this one.
docker run --rm --name glm53 --gpus all --network host --ipc=host \
-v /path/to/GLM-5.3-Flash-Uncensored-W4A16:/model:ro \
-v /srv/triton-cache:/triton-cache \
-e TRITON_CACHE_DIR=/triton-cache \
-e SGLANG_OPT_DEEPGEMM_HC_PRENORM=0 \
-e SGLANG_ENABLE_SPEC_V2=True \
-e PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
YOUR_SGLANG_IMAGE_BUILT_FROM_A_POST_MERGE_NIGHTLY_PLUS_THE_3_PATCHES \
python3 -m sglang.launch_server \
--model-path /model --served-model-name glm-5.3-flash \
--tp 4 --context-length 1048576 \
--dsa-prefill-backend tilelang --dsa-decode-backend tilelang \
--kv-cache-dtype bfloat16 \
--speculative-algorithm NEXTN \
--speculative-num-steps 3 \
--speculative-num-draft-tokens 4 \
--speculative-eagle-topk 1 \
--mem-fraction-static 0.90 \
--chunked-prefill-size 4096 \
--max-running-requests 12 \
--schedule-policy lpm \
--mamba-radix-cache-strategy extra_buffer \
--mamba-track-interval 2048 \
--cuda-graph-max-bs 16 \
--reasoning-parser glm45 \
--tool-call-parser glm47 \
--enable-hierarchical-cache \
--hicache-ratio 0.5 \
--hicache-write-policy write_through \
--enable-metrics --trust-remote-code \
--host 0.0.0.0 --port 8100 \
--disable-shared-experts-fusion \
--prefill-decode-interval 16
Drop the four --speculative-* flags for the autoregressive configuration; nothing else changes.
--prefill-decode-interval 16 is not cosmetic. Without it, a live decode stream collapses to
1.6 tok/s for the whole duration of anyone else's cold prefill — measured here at 65x, against a 4.6x
figure reported on other stacks, because a 100K+ prompt at --chunked-prefill-size 4096 is ~29 consecutive
extend batches and the scheduler re-arms on every one of them. At 16 the same victim holds 23.1 tok/s. It
costs ~9% on a synchronized 12-way burst and inflates cold TTFT by ~27%.
--disable-shared-experts-fusion is mandatory, not stylistic. Without it this architecture emits fluent
gibberish and never stops, on any quantized build. determine_num_fused_shared_experts() sizes the MoE at
n_routed_experts + 1 = 289 slots, then a separate wrapper gate — evaluated ~2 minutes later during weight
loading — decides the config does not support fusion and never populates slot 288. Every token then routes
through an uninitialized expert. Harmless on the FP8 release; fatal once expert slots are INT4-packed.
Parsers are not optional. Without --reasoning-parser glm45 the chain-of-thought lands in content with
a stray </think>; without --tool-call-parser glm47 every agentic client gets a 400 while plain chat looks
perfectly healthy. Both failure modes shipped to production here before they were caught. /health says
nothing about parsers.
--chunked-prefill-size 4096 is a ceiling, not a tuning knob. 8192 crashed the scheduler on a 305K-token
cold prefill: the DeepGEMM MQA-logits buffer is chunk × max_seqlen_k × ~1.14 bytes, so at 8192 against a
1.8M-token pool it wants 4.07 GB — more than this box ever has free. Do not lower it either; see the
chunk-size table on the censored sibling's card.
systemd, secrets stripped. MODEL/IMAGE/SPEC_ARGS/EXTRA_ARGS are passed as Environment= to a
wrapper script that execs the docker run above.
[Unit]
Description=GLM-5.3-Flash-Uncensored (W4A16, TP=4) on SGLang with SM120 fixes
After=docker.service network-online.target
Requires=docker.service
# This box has produced a 206,804-restart loop. Rate-limit restarts.
StartLimitIntervalSec=900
StartLimitBurst=4
[Service]
Type=simple
ExecStartPre=-/usr/bin/docker rm -f glm53
ExecStart=/usr/local/bin/glm53-run.sh
ExecStop=/usr/bin/docker stop -t 90 glm53
Restart=on-failure
RestartSec=45
# 178 GiB (191 GB) across 4 GPUs + CUDA graph capture. Model load takes minutes.
TimeoutStartSec=1500
TimeoutStopSec=150
Environment=MODEL=/srv/models-cache/GLM-5.3-Flash-Uncensored-W4A16
Environment="SPEC_ARGS=--speculative-algorithm NEXTN --speculative-num-steps 3 --speculative-num-draft-tokens 4 --speculative-eagle-topk 1"
Environment="EXTRA_ARGS=--disable-shared-experts-fusion --prefill-decode-interval 16"
[Install]
WantedBy=multi-user.target
TimeoutStartSec matters: startup to healthy is ~5m30s with the MTP head enabled, and 135 s of
that is target-verify CUDA-graph capture — it looks like a hang and is not. A shorter timeout turns a
normal boot into a restart loop.
Quote multi-word Environment= values. systemd splits on whitespace into separate assignments, so an
unquoted SPEC_ARGS=--speculative-algorithm NEXTN --speculative-num-steps 3 reaches the wrapper as
--speculative-algorithm alone, silently. Confirm with systemctl show <unit> -p Environment --value
before you restart.
If your deploy is right, you should see approximately this. If max_total_num_tokens comes up materially
below it, your --mem-fraction-static or context length differs — the pool, not the --context-length
flag, is what enforces the input ceiling.
| with MTP (NEXTN) | autoregressive | |
|---|---|---|
| weights / GPU | 41.98 GB + 4.08 GB NextN | 41.98 GB |
max_total_num_tokens (KV pool) |
2,048,896 (KV 24.27 GB/GPU) | 1,883,328 |
mamba/KDA slots · max_running_requests |
290 · 12 | 582 · 12 |
| hard input ceiling | 1,048,576 | 1,048,576 |
| free device memory after graph capture | 7.87 GB | — |
| startup to healthy | ~5m30s (95 s weights, 10 s NextN, 135 s verify-graph capture) | ~2m |
Both columns are this checkpoint now — read off /metrics and the boot log on the live resident. The
autoregressive column used to be † on this card because these weights had never been served without a
draft; they since ran autoregressive in production from 2026-08-31 to 2026-09-10, so it is measured.
Note the direction of the pool change: enabling the MTP head made the KV pool BIGGER (1,883,328 → 2,048,896, +8.8%) while shrinking the mamba/KDA pool (582 → 290 slots). Spec decode re-partitions those two pools and the direction is not intuitive — re-read both from the startup lines after any speculative change rather than inferring them.
Single-stream figures are idle-gated on sglang:kv_used_tokens == 0 and token-accurate from
usage.completion_tokens.
| with MTP (NEXTN) | autoregressive | |
|---|---|---|
| single-stream, short prompt | 227.2 tok/s (n=5, 203.4–241.7) | 117.4 tok/s |
| single-stream, warm long prefix | 246.5 tok/s (n=5) | 108.4 tok/s |
| aggregate @ concurrency 12 | 783–820 tok/s, median 799 (n=4) | 617.5 tok/s |
| accept length (of 4) | 2.83 lifetime over 7.2 days of production | n/a |
| tokens per SSE chunk | 2.98 short · 3.15 warm-longprefix | 1.00 |
| largest prompt served | 997,565 tokens, correct needle retrieval, 191.1 s | — |
| prefix reuse (cold → repeat → new suffix) | 20.77 s → 0.608 s → 0.410 s | — |
The MTP column was re-measured on 2026-09-17 after 7.2 days of continuous production serving; the autoregressive column is this checkpoint on the same engine build, measured 2026-09-07/09-10.
Three measurement traps — these numbers will not reproduce if you hit them:
usage.completion_tokens.sglang:num_running_reqs is not a live concurrency signal. It refreshes only on the decode-log tick
(~1 s here) and never at request admission or completion — it read 1.0 while two requests concurrently
held KV, and 0.0 while one held 15,104 tokens. Gate idleness on sglang:kv_used_tokens, which moves
immediately and counts active requests only.kv_used_tokens
already reads zero. State which one you measured.A fourth, specific to comparing models: under speculative decoding tok/s is comparable across configs on
one model, but not across models — a tersely-answering model posts a different tok/s at an identical
engine step rate. The invariant is chunks/s, not tokens/s.
Correction (2026-09-17). The previous revision of this card was wrong, and the fault was in this repo's own metadata, not in the model.
Earlier revisions told you never to enable this checkpoint's built-in NEXTN/MTP head, and offered a generalisable rule to go with it: an MTP head's acceptance does not survive quantizing the target. Both were wrong. The head works. What did not work was how this repo declared it to SGLang.
quantization_config.ignore listed layer 45 only in the compressed-tensors regex dialect,
re:.*layers\.45\..*. SGLang's glm5_next_nextn.py::_resolve_nextn_quant_config decides whether to
build the NextN block unquantized with an exact string membership test, not a regex match:
nextn_layer_pattern = f"model.layers.{config.num_hidden_layers}.*" # "model.layers.45.*"
if nextn_layer_pattern in ignored: # list membership on raw strings
return None # -> BF16 draft modules
return super()._resolve_nextn_quant_config(config, quant_config) # else: inherits W4A16
The regex entry never satisfied it, so the MTP layer's routed experts were built W4A16 against bf16
weights. Drafts were essentially never accepted, and enabling speculation cost about a third of the decode
rate. self_attn, shared_experts, mlp.gate, eh_proj and shared_head survived by accident — their
regexes still match after the loader rewrites model.layers.45 to model.decoder. The experts did not.
Nothing errors and nothing warns on that path. The only tell is the NextN module loading at roughly 45% of its own weight size — 1.56 GB/rank against the 4.08 GB/rank it should be at TP=4. That number sat in our journal for twelve days.
Fixed in this repo as of 2026-09-17: config.json carries the literal string alongside the regex
(11 ignore entries → 12). The added entry is inert for the target model — should_ignore_layer
returns an identical verdict on all 14 probed target-model prefixes with and without it; it only trips
SGLang's NextN gate. If you pulled this checkpoint before 2026-09-17, re-pull config.json.
Measured on 4x RTX PRO 6000 Blackwell Max-Q (SM120), TP=4, SGLang built from post-merge main, with the
speculative flags byte-identical across rows 2 and 3 and only the ignore list changing between them:
| configuration | accept length | short single-stream |
|---|---|---|
autoregressive (no --speculative-* flags) |
n/a | 117.4 tok/s |
MTP head, regex-only ignore (the defect) |
1.0 of 4 | 81.0 tok/s |
MTP head, literal ignore present |
2.83 of 4 lifetime | 227.2 tok/s |
Launch flags:
--speculative-algorithm NEXTN \
--speculative-num-steps 3 \
--speculative-num-draft-tokens 4 \
--speculative-eagle-topk 1
--speculative-num-draft-tokens is stated, not left to inference. A standalone-draft report on
identical hardware (sglang#33800) traces a
corruption class specifically to the flag-omitted native-block-size path, so do not omit it.
Confirm the fix is live by looking for this line at startup, on every rank:
GLM5 NextN layer model.layers.45.* is checkpoint-declared unquantized; using BF16 draft modules
Read acceptance off GET /server_info → internal_states[0].avg_spec_accept_length (lifetime since
start), or off meta_info.spec_accept_length on /generate (per request; the OpenAI
/v1/chat/completions route does not return it). Do not read the sglang:spec_accept_length Prometheus
gauge — it is reset every decode-log interval, so a scrape reports roughly the last second, not an
average. We published two wrong acceptance figures off that gauge before noticing; its observed range on
an idle box was 2.025–3.775 within 36 seconds.
A 24 h controlled A/B on production agentic traffic measured DFlash2 causing a 6.9x increase in runaway
generations: requests that never emit </think>, produce no tool call, and burn to max_tokens.
1.12 per 1,000 with speculation off against 8.91 per 1,000 with DFlash2 (P = 8.2e-10), and 0.04 against
6.69 per 1,000 on the sharpened finish_reason='length' + empty-content predicate. It reproduced on two
independent API keys and on three different checkpoints, so the weights are ruled out; the only constant
was the draft. We parked it permanently on 2026-08-31.
Its throughput numbers were real and we do not dispute them. We do not run it, and we would not run it on agentic traffic. The MTP head above is faster anyway and ships inside these weights.
We served the FP8 source of these exact weights on the same box and rolled it back. It works, but 75.28 GB/GPU of weights instead of 42.03 leaves an entirely different machine:
Config stamp: both columns below were taken with a standalone DFlash2 draft, which this card no longer recommends. Their pool and slot figures describe that config, not the launch line above — which gives 2,048,896 and 290. Treat the columns as a valid FP8-vs-W4A16 comparison, not as sizing numbers.
| this W4A16 | the FP8 source | |
|---|---|---|
max_total_num_tokens |
1,814,144 | 347,008 |
| hard input ceiling | 1,048,576 | 347,002 |
| mamba/KDA slots | 214 | 52 |
| aggregate @ concurrency 12 | 705–738 tok/s | ~400 tok/s |
Measured directly rather than inferred: a 335,616-token prompt succeeds on FP8, and 351,816 returns
HTTP 400 — Input length (351816 tokens) exceeds the maximum allowed length (347002 tokens).
On 4×96 GB, quantization format is a context-length decision, not just a speed one. Keep resident weights under ~250 GB or the KV pool stops covering your own prompt distribution.
Quantized: routed-expert gate_proj / up_proj / down_proj for layers 3–44 only
(42 × 288 × 3 = 36,288 packed tensors). Also 1,050 tensors dequantized FP8→BF16 and 1,432 copied
unchanged.
Left at BF16 (in the ignore list) — each for a reason:
| module | why |
|---|---|
self_attn.* |
34 KDA linear-attention + 11 DSA layers + the sparse indexer; recurrent state is precision-sensitive |
visual.* |
vision tower — this model is natively multimodal |
layers.45.*, eh_proj, shared_head |
MTP / NEXTN draft head — declared in both the re: and the literal model.layers.45.* dialect; see Speculative decoding for why both are needed |
*_hc.* |
mHC (Manifold-Constrained Hyper-Connections) |
shared_experts.* |
always-active, higher sensitivity than routed experts |
mlp.gate |
MoE router — tiny and precision-critical |
layers.0/1/2.mlp.* |
dense layers (first_k_dense_replace = 3) |
embed_tokens, lm_head |
standard |
Known inefficiency, not fixed here: the 1,050 non-expert tensors that were blockwise-FP8 in the source are
stored as BF16, doubling their bytes on the always-active path. A parameter census puts attention at ~58% of
per-token decode bytes and routed experts at only ~20%, so re-storing those as FP8 is the obvious next gain
(~13% fewer bytes/token). Not done because SGLang's FusedMoE path reads only the top-level
compressed-tensors format and rejects mixed-precision
(sglang#16276 — fixed for Linear, not MoE).
Streaming tensor-level transform directly from the FP8 source (no BF16 checkpoint was materialised — dequantized BF16 is 642 GB and does not fit in 384 GB VRAM + 128 GB RAM):
weight_scale_inv) → fp32compressed_tensors.calculate_qparams, computed against the
BF16-rounded scale that is actually stored (quantizing against the fp32 value and then storing BF16
leaves the checkpoint self-inconsistent at inference)compressed_tensors' own packerweight_scale_inv removedMean sampled relative L2 error vs the FP8 source: 11.093% (n=200).
This is data-free quantization — not GPTQ, not AWQ, no calibration set, no activation-aware scaling. A calibrated build should beat it on quality.
It takes 7.2 minutes on a single GPU. 328 GB in, 191 GB out (= the 178 GiB on-disk figure above; same bytes, decimal vs binary), 432 seconds, one RTX PRO 6000. This is worth stating plainly because the widespread belief that quantizing a 320B MoE is an overnight job stops people trying: that belief is true of calibration-based AWQ/GPTQ, which runs forward passes over calibration data, and false of data-free RTN, which is a pure per-group weight transform. At 0.76 GB/s against a drive that does ~12, it is per-shard compute-bound and trivially shardable across GPUs if anyone needs it faster.
ignore list, fixed 2026-09-17 — see
Speculative decoding. It is recorded here rather than
quietly edited out because anyone who pulled these weights before that date and followed the card got the
broken configuration.This is an abliterated / refusal-removed model. It will comply with requests that the base GLM-5.3-Flash
declines. It is tagged not-for-all-audiences deliberately. You own what you deploy it for, and you own the
guardrails you put in front of it — there are none in these weights.
MIT, carried forward from zai-org/GLM-5.3-Flash
(© 2026 Z.AI Co., Ltd) through
orcarouter/GLM-5.3-Flash-Uncensored-FP8.
This repository contains only a requantization of that checkpoint; the abliteration is OrcaRouter's work, not
ours. The DFlash2 draft discussed above is a separate repo under a separate, more restrictive licence
(CC-BY-NC-ND-4.0) and is not redistributed here.
model-00002-of-00062.safetensors 10 GBmodel-00001-of-00062.safetensors 8.1 GBmodel-00017-of-00062.safetensors 3.3 GBmodel-00035-of-00062.safetensors 3.0 GBmodel-00028-of-00062.safetensors 3.0 GBmodel-00022-of-00062.safetensors 3.0 GBmodel-00053-of-00062.safetensors 3.0 GBmodel-00005-of-00062.safetensors 3.0 GBmodel-00040-of-00062.safetensors 3.0 GBmodel-00011-of-00062.safetensors 3.0 GBmodel-00046-of-00062.safetensors 3.0 GBmodel-00032-of-00062.safetensors 3.0 GBmodel-00059-of-00062.safetensors 3.0 GBmodel-00024-of-00062.safetensors 2.9 GBmodel-00038-of-00062.safetensors 2.9 GBmodel-00045-of-00062.safetensors 2.9 GBmodel-00052-of-00062.safetensors 2.9 GBmodel-00007-of-00062.safetensors 2.9 GBmodel-00014-of-00062.safetensors 2.9 GBmodel-00021-of-00062.safetensors 2.9 GBmodel-00042-of-00062.safetensors 2.9 GBmodel-00049-of-00062.safetensors 2.9 GBmodel-00008-of-00062.safetensors 2.9 GBmodel-00012-of-00062.safetensors 2.9 GBmodel-00015-of-00062.safetensors 2.9 GBmodel-00018-of-00062.safetensors 2.9 GBmodel-00025-of-00062.safetensors 2.9 GBmodel-00029-of-00062.safetensors 2.9 GBmodel-00036-of-00062.safetensors 2.9 GBmodel-00050-of-00062.safetensors 2.9 GBmodel-00039-of-00062.safetensors 2.9 GBmodel-00043-of-00062.safetensors 2.9 GBmodel-00054-of-00062.safetensors 2.9 GBmodel-00004-of-00062.safetensors 2.9 GBmodel-00019-of-00062.safetensors 2.9 GBmodel-00026-of-00062.safetensors 2.9 GBmodel-00033-of-00062.safetensors 2.9 GBmodel-00031-of-00062.safetensors 2.9 GBmodel-00047-of-00062.safetensors 2.9 GBmodel-00056-of-00062.safetensors 2.9 GBmodel-00057-of-00062.safetensors 2.9 GBmodel-00060-of-00062.safetensors 2.9 GBmodel-00010-of-00062.safetensors 2.9 GBmodel-00003-of-00062.safetensors 2.9 GBmodel-00061-of-00062.safetensors 2.8 GBmodel-00009-of-00062.safetensors 2.8 GBmodel-00048-of-00062.safetensors 2.8 GBmodel-00027-of-00062.safetensors 2.8 GBmodel-00034-of-00062.safetensors 2.8 GBmodel-00041-of-00062.safetensors 2.8 GBmodel-00020-of-00062.safetensors 2.8 GBmodel-00013-of-00062.safetensors 2.8 GBmodel-00006-of-00062.safetensors 2.8 GBmodel-00051-of-00062.safetensors 2.8 GBmodel-00044-of-00062.safetensors 2.8 GBmodel-00030-of-00062.safetensors 2.8 GBmodel-00037-of-00062.safetensors 2.8 GBmodel-00023-of-00062.safetensors 2.8 GBmodel-00016-of-00062.safetensors 2.8 GBmodel-00055-of-00062.safetensors 2.8 GBmodel-00058-of-00062.safetensors 2.8 GBmodel-00062-of-00062.safetensors 1.3 GBorcarouter/GLM-5.3-Flash-Uncensored-FP8