GLM-5.3-Flash · Maya-XS, Maya-S, Maya-S24, Maya-M and Maya-L

Maya-L: 99.2% of the full FP8 model's accuracy on zero-shot tasks (ARC, HellaSwag, WinoGrande, PIQA), in 156 GB. Maya-S: 97.9% in a 96 GB file. Maya-S24: 97.7%, and up to 14% faster decode on 24 GB cards, in 94.7 GB. Maya-M: 97.9%, and closer to the full model token by token, in 116 GB. Maya-XS: 92.4% in 73.4 GB, small enough for a PC with 64 GB of RAM and one 24 GB card at 128K context.

GGUF quantizations of zai-org/GLM-5.3-Flash (321 B parameters, a mixture of experts with about 18 B active per token), made for Project Maya. Project Maya keeps the most-used experts on the GPU, the next in RAM and the rest on the SSD, so all five run well below the model's size (two GPUs with 30 GB of RAM in the measurements below). More memory is faster, and every machine is different: try it on yours. All five are made from Z.ai's own FP8 release - the precision the model is served at - not from a re-quantized file.

• Maya-XS (73.4 GB) is the smallest, made to run without the SSD on a PC with 64 GB of RAM and one 24 GB card, at 128K context with the KV cache in int8: its routed experts in about 1.5 bits (IQ1_S gate and up, IQ2_XXS down), more bits in the layers that lose the most, and Maya-S24's 4-bit attention and shared experts. It gives up some accuracy for that size; pick Maya-S or Maya-S24 when they fit.
• Maya-S (96.5 GB) is the compact one, made for PCs with a smaller memory pool across RAM and VRAM: its routed experts - most of the model - in about 2 bits (IQ2_XXS / IQ2_S), its attention and shared experts in 6-bit (Q6_K).
• Maya-S24 (94.7 GB) is Maya-S for 24 GB cards (RTX 3090 / 4090): the same 2-bit routed experts, with only the small part every token runs through - the attention and shared experts - in 4-bit (Q4_K) instead of Maya-S's 6-bit. That leaves about 1.5 GB more room for experts on the GPU.
• Maya-M (116 GB) is closer to the full model, for PCs with a bigger memory pool: built with the same FP8-statistics recipe and more bits where they count (2- to 3-bit experts), calibrated toward tool calls and front-end code.
• Maya-L (156.3 GB) is the closest, for PCs with the biggest memory pool: Maya-M's recipe one step up (3- to 4-bit experts: IQ3_S / IQ4_XS, Q5_K in the most sensitive layers).

Built partly on the IST Austria DAS Lab (ISTA-DASLab) recipe. All five use their GPTQ-style error-feedback rounding for the experts (each expert rounded against its own input statistics from the FP8 model), and are measured the way they measure their quants: task accuracy against the full-precision model.

Files

The model's NextN (MTP) layer is included in all five, so engines that draft with it get speculative decoding.

What is in them

How they were made

1. Calibration text: 128 sequences of 2,048 tokens in GLM's own chat template, reasoning blocks included - chat, multilingual chat, reasoning traces, web code (single-file HTML/CSS/JS pages, three.js scenes, canvas and WebGL animations), other code and tool calls; Maya-M's and Maya-L's weighted further toward tool calls and front-end code. Maya-XS's is eight times bigger: 1,024 sequences, led by tool calls, then code and three.js, agentic traces, long multi-turn chats, English, Japanese and Chinese; its bits per layer follow a sensitivity scan on that text.
2. Statistics from the FP8 model itself, layer by layer: an importance matrix for every expert separately, not one per layer.
3. Error-feedback rounding of the experts' gate and up projections (GPTQ-style, at the quantizer's 256-weight blocks, each expert with its own input statistics): on held-out text it lowers the experts' output error by about a quarter against plain importance-weighted rounding at the same size.
4. llama.cpp's own quantizers (ggml), so the files are ordinary GGUFs.

Against the original (FP8)

Maya-L keeps 99.2% of the full model's zero-shot accuracy; Maya-S and Maya-M 97.9%, Maya-S24 97.7%, Maya-XS 92.4%. Multiple-choice tasks at 400 questions each do not separate Maya-S, S24, M and L (a point or two either way is within the test's noise); token by token, below, Maya-M is clearly closer to the FP8 model. Maya-XS is clearly below them: that is the price of its size.

400 questions per task, the same questions for every model, scored the way lm-evaluation-harness scores them (the answer with the highest log-likelihood; length-normalized where the choices differ in length) - the FP8 model run layer by layer in PyTorch, the quants through Project Maya's engine (tools/maya_quant/zs_*.py).

Token by token, on held-out text never used for calibration (7,672 positions), with the FP8 model's own predictions as the reference:

¹ Measured with a later engine, next to Maya-S at 0.421 in the same run. ² Measured with a later engine, next to Maya-M at 0.291 (same top token 86.8%) in the same run.

Closest on chat and reasoning text, furthest on tool-call formats and on text the FP8 model has memorized.

Maya-XS was not run through that comparison; on Project Maya's own tool-call, three.js and loop tests it passed every case Maya-S24 passed (no loops in ten 8,000-token answers at 128K context).

No loops in long generation (Maya-S): 14 answers of 6,000-14,000 tokens (three.js scenes, canvas animations, explanations, a plan in Portuguese, a proof; temperature 1.0 and greedy) without a repeated passage. The context fill test (a fact at the start of an 8k, 16k and 30k-token context, asked about at the end) finds it every time.

Speed

Maya-S on two Tesla V100 32 GB (30 GB RAM) with Project Maya: decode (writing the answer) up to 40 tokens/s, with the MTP block drafting, and it keeps that pace at long context (60K tokens); prefill (reading the prompt) up to 560 tokens/s (up to 670 with Project Maya v1.0.15). On one Tesla V100 32 GB with 64 GB of RAM: decode up to 19 tokens/s, prefill up to 370 tokens/s. Maya-S24 on the same card limited to 24 GB: decode 13.5 tokens/s against Maya-S's 11.8 (+14%); on the full 32 GB 19.1 against 17.2 (+11%); prefill the same. ./maya.sh --bench measures your machine the same way.

Running it

Project Maya sets everything up and runs it:

git clone https://github.com/mw00/project-maya.git && cd project-maya
./setup.sh          # Windows (experimental): START-MAYA.bat

• It checks the PC, downloads the model you pick and verifies every file's sha256, compiles the engine for your GPU(s), and starts it. Press Enter at each question for the recommended choice: Maya-S, or Maya-S24 when every card has 24 GB or less. ./setup.sh --setup --model Maya-S24 or --model Maya-M or --model Maya-L sets up the others, and --model glm-maya-xs sets up Maya-XS with its own defaults (int8 KV cache, thinking budget 8192).
• GPUs: NVIDIA, V100 / RTX 20 or newer, one GPU or up to 16 that share the model. AMD (experimental, Linux, ROCm 7): RX 7900 XT / XTX and Radeon AI PRO R9700 / RX 9070 (one or two), Strix Halo (one).
• Memory: the most-used experts stay in VRAM, the next in RAM and the rest are read from the SSD, so it runs with 32 GB of RAM; more VRAM and RAM is faster. Put the model on an NVMe SSD.
• Use it: the dashboard at http://127.0.0.1:8080 (chat, pictures through the vision files above, a live monitor), or the OpenAI- and Anthropic-compatible API at the same address (streaming and tool calls; Claude Code: ANTHROPIC_BASE_URL=http://127.0.0.1:8080).
• ./maya.sh --bench measures your machine; --bench and --report in a GitHub issue add it to the users' speeds.

License

The model is Z.ai's GLM-5.3-Flash under the MIT license; these quantizations are released under the same license.