How Fast Does GLM-5.3-Flash (320B) Write on the EVO-X2 Mini PC? Measured with llama.cpp v0.7.0

2026年10月24日

The quantized UD-IQ1_S version of “GLM-5.3-Flash" released by Z.ai (320 billion parameters in total, 18 billion used at a time) is 93.1GB for the file alone. I ran this model with llama.cpp v0.7.0 on the mini PC “EVO-X2" (a mini PC with a Ryzen AI Max+ 395 and 128GB of memory; the integrated GPU is a Radeon 8060S) and measured its speed. This is a model that the previous version of llama.cpp could not load. With the newer version it loads, but how fast does it write?

This reflects the state of things as of October 17, 2026.

Purpose: what this article measured

This article measured the following three things.

• Whether it loads: whether v0.7.0 can load a model that the previous version (b11192) could not
• Input-processing speed (pp512): how many tokens per second it processes when fed a 512-token input (the speed of reading)
• Generation speed (tg128): how many tokens per second come out when it writes 128 tokens of text (the speed of writing)

I also recorded the amount of memory used. I did not measure the quality or accuracy of the answers, the behavior with image input, or the behavior with long inputs. Details are in “Limitations: what I did not measure."

The goal is that, after reading, you have a rule of thumb: “a 93.1GB ultra-low-bit quantized version fits in a mini PC with 128GB of memory and writes at about 18 tokens per second."

Background: terms explained

Several technical terms follow in a row, so let me sort them out first.

• Token: the unit an AI uses when processing text. It does not match the character count; a word or a fragment of a word counts as one token.
• tok/s (tokens per second): the number of tokens processed per second. Larger is faster, and all speeds in this article use this unit.
• llama.cpp: software for running AI locally. I used v0.7.0 (build 620d222) this time, and b11192, which I had tried just before.
• llama-bench: a measurement tool that comes with llama.cpp. It measures the processing of a 512-token input (pp512) and the generation of 128 tokens (tg128).
• Vulkan: one of the mechanisms (APIs) for using a GPU. This time I used the Radeon 8060S through Vulkan.
• UMA (unified memory): a design in which the CPU and GPU share the same memory. The EVO-X2 shows no dedicated VRAM figure, so I look at main memory usage instead.
• Quantization: a method of making a model’s numbers coarser to shrink the file. The UD-IQ1_S used here is a very coarse format that holds each value in about 1.56 bits.
• MoE (Mixture of Experts): a design that holds many small parts called “experts" inside the model and uses only some of them for each token. Even if the total parameter count is large, the computation per token is only for the active parameters.
• Linear attention and sparse attention: tricks in the attention mechanism that make computation grow less as the text gets longer. I touch on them in the next section.

What GLM-5.3-Flash is: history and design trivia

Before the measurement, let me sort out where this model came from. This part was checked against public information on Hugging Face (a site that distributes AI models), and the sources are collected at the end of the article.

The GLM series lineage

The publisher is Z.ai (the organization name on Hugging Face is zai-org). The repository was created on August 25, 2026, the same day as the main GLM-5.3. Articles from sites such as Artificial Analysis (AA, a site that compares AI models from a third-party standpoint) are dated August 26.

The name GLM comes from the paper “GLM: General Language Model Pretraining with Autoregressive Blank Infilling," posted in March 2021. However, I could not confirm whether the current series still explains the abbreviation that way.

The origin of the name “Flash" is not explained in the README, AA, or any commentary article, so I could not confirm it. The same series has precedents: GLM-4.7-Flash (January 2026) and GLM-4.6V-Flash (December 2025).

Following the creation dates on Hugging Face, the series has progressed as follows.

Model	Date	Note
GLM-4.5 / 4.5-Air	July 20, 2025	MIT license
GLM-4.7-Flash	January 19, 2026	A small tier: 30B in total, 3B active
GLM-5	February 11, 2026	744B in total, 40B active
GLM-5.1	April 3, 2026	–
GLM-5.2	June 16, 2026	1M (one million) tokens of context
GLM-5.3 (main model)	August 25, 2026	Custom license
GLM-5.3-Flash	August 25, 2026	320B in total, 18B active. MIT license

On the license, the main GLM-5.3 uses a custom “GLM-5.3 License," whereas Flash is MIT. The MIT license is a typical permissive license that lets you use, modify, and distribute the software freely as long as you follow its conditions.

There was a gap in days between the official announcement and the release of the weights. GLM-5.3 was announced on August 14, and the weights were released on August 25. Flash drew attention the next day, August 26.

How to read the name: 320B-A18B

“320B-A18B" means 320B (320 billion) parameters in total, of which 18B (18 billion) are used per token. The share used is about 5.6%. Even though only 18 billion are used, the weights that must be kept on hand cover all 320 billion.

The internal design: a mix of linear and sparse attention

The README describes Flash as “the first natively multimodal model in the GLM-5 series." It is built to accept both images and text as input. It also says it “started from a newly trained base model, with the architecture and training method redesigned." It is said to have used 30 trillion tokens of multimodal training data.

The configuration file (config.json) lists the type of each layer. Of the 45 layers in total, 34 are linear-attention layers and 11 are DeepSeek-style sparse-attention layers. A sparse-attention layer comes once every 4 layers. The README says that the GLM series adopts a mix of sparse and linear attention for the first time, aiming to lower the computational burden at long context while keeping accuracy at long context.

For the MoE part, there are 288 routed experts, 8 of them used per token, and 1 shared expert that everyone uses. The first 3 layers are ordinary layers that are not MoE. There is 1 MTP layer (a layer that predicts ahead at the same time). For context length, the maximum position in the configuration file is 1,048,576 tokens (1M).

The README also says it adopts a mechanism called Manifold-Constrained Hyper-Connections (mHC) to improve the efficiency of scaling up. I have not confirmed how the mechanism works. The meaning of the item name “kda" in the configuration file and the intent behind the model format name glm5_next are not explained in the materials either, so I could not confirm them.

The earlier generations, GLM-5 through GLM-5.2, had 78 layers and 256 experts, with sparse attention in all layers. Flash has 45 layers and 288 experts, with a mixed attention mechanism and a part that looks at images added. It is distributed in FP8 (8-bit floating point), and the official files total 328.3GB. I could not find an official GGUF release, and the file used this time is a distribution by unsloth.

The performance the developer shows, and AA’s value

The developer’s evaluation values are printed on the graph attached to the model card. I quote Flash’s values for the 4 items whose values matched the evaluation data file (.eval_results). The values for the previous generation, GLM-5.2, shown alongside are this blog’s reading of the graph’s printed numbers by eye, and I could not check them against the evaluation data file.

Metric	GLM-5.3-Flash	GLM-5.2
Terminal Bench 2.1	84.3	81.0
DeepSWE v1.1	63.4	46.2
Agents’ Last Exam	26.3	20.4
HLE (with tools)	55.3	54.7

The values in the table are the developer’s own evaluations, not third-party verification. The README says it “surpasses GLM-5.2 across the board."

The Intelligence Index from AA (v4.3.2) was shown as 42 on AA’s model page. The median for comparable open-weight models (models whose weights are published) is written there as 19. This is a number published by AA, and I quote the value displayed on the model page, not a bar in a graph. It is not a measurement by this blog.

Method: how I measured

The machine and software I measured

The machine is the EVO-X2. It is a mini PC with a Ryzen AI Max+ 395 and 128GB of memory. I used the integrated Radeon 8060S GPU through Vulkan. The environment variable GGML_VK_VISIBLE_DEVICES makes only the 8060S visible. The software is llama.cpp v0.7.0 (build 620d222). I built it on a different machine and copied it to the EVO-X2.

Measurement conditions

Item	Details
Model	GLM-5.3-Flash-GGUF by unsloth, UD-IQ1_S (3 split files, 93,077,724,536 bytes in total = 93.1GB. 1.5625 bits per value)
Command	llama-bench -ngl 99 -p 512 -n 128 -r 5 -lm none
-ngl 99	A setting that places all layers on the GPU
-lm none	A setting that loads the file into memory up front, instead of the method (mmap) that reads only the parts it needs
Runs	5
Aggregation	Sort the 5 runs from smallest to largest and use the median of the middle 3

I also tried the same file with the previous version of llama.cpp (build b11192). The measurement dates were October 16, 2026 for b11192 and October 17 for v0.7.0.

Why I do not put ollama numbers in the same table

ollama is separate software from llama.cpp, with a different loading implementation and a different way of measuring. The numbers this time are llama-bench values, so I do not compare them in the same table with the numbers from this blog’s articles measured with ollama.

Results

The previous version could not load it

With b11192, the following error appeared and the model did not load.

• unknown model architecture: 'glm5-next'

This model’s architecture name is glm5-next. The name b11192 knows is glm5, and glm5-next was unsupported. With v0.7.0, the same file loaded and could be measured.

Speed

Run	Input processing pp512 [tok/s]	Generation tg128 [tok/s]
1	169.73	18.41
2	169.93	18.44
3	170.24	18.46
4	172.27	18.54
5	183.71	18.57
Median of the middle 3	170.24 (spread 2.34)	18.46 (spread about 0.1)

For input processing, the 5 runs ranged from 169.73 to 183.71 tok/s, and only the 5th came out high. The median of the middle three points (169.93, 170.24, and 172.27 tok/s) is 170.24 tok/s. At that rate, a 512-token input takes about 3.0 seconds to read.

Generation ranged from 18.41 to 18.57 tok/s and was consistent. The median is 18.46 tok/s. At that rate, 128 tokens take about 6.9 seconds to write. The values in the table are sorted from smallest to largest, not in the order they were measured.

Memory

The memory used was about 92.8GB. Because the EVO-X2 shares memory between the CPU and GPU, it shows no dedicated VRAM figure. An amount close to the file size of 93.1GB was placed on the main memory side.

I did not measure temperature or power consumption.

Discussion: what the results suggest

The generation speed of about 18 tokens per second is a value from one condition measured 5 times. I did not measure it with long inputs or with several questions used at once.

The fact about placement is that the 93.1GB file ran on a mini PC with 128GB of memory with the setting that assigns all layers to the GPU. Memory usage was about 92.8GB, within the range of 128GB. Examples of running large models on the same mini PC are in the Hy3 article and the gpt-oss-120b article. Because the software and quantization conditions differ, I do not line up the speed numbers for comparison.

Here an explanation comes to mind: “only 18 billion are used at a time, so even a 320-billion model gives 18 tokens per second." The share used is about 5.6% (18B ÷ 320B), so fewer weights are read per token. This is a guess, and I did not verify it.

I could not confirm why an outlier such as 183.71 tok/s in the 5th input-processing run appeared. The aggregation that takes the middle three points avoids the influence of this value.

The reason the previous version could not load it can be read from the error message as “no support for the architecture name glm5-next." Support was probably added in v0.7.0, but I did not read the source changes themselves in this article.

Limitations: what I did not measure

• Answer quality and accuracy: I did not measure how well the text is written, the rate of correct answers, or how often it hallucinates. Quality is unmeasured. I have not checked how much of the original model’s accuracy remains after quantization to around 1.56 bits.
• Image input: Flash is said to accept images too, but this time I measured with text only. Image input is untested.
• Values for a single question only: these are values from one llama-bench condition (512 input tokens, 128 generated tokens) measured 5 times. I did not measure behavior with long inputs, long generation, or several questions used at once. Behavior at the context length said to go up to 1M (one million) tokens is also unconfirmed.
• Switching reasoning strength: I did not try the reasoning_effort switch mentioned in the README.
• Temperature and power consumption: not measured.
• Comparison with ollama numbers: ollama is separate software. I did not compare against numbers measured with ollama in the same table.
• Differences in quantization: only UD-IQ1_S. I did not measure the differences from other quantized versions (UD-IQ1_M, UD-IQ2_XXS, and so on).
• Day of measurement: a single day, October 17, 2026, this one machine, and one version of v0.7.0 only. On another version or another day, the values may move.
• Performance figures: the evaluation values in the table are the developer’s own evaluations. The Intelligence Index of 42 is the value displayed on the Artificial Analysis model page (v4.3.2), and this blog did not verify it.

Summary: results of running GLM-5.3-Flash on the EVO-X2

• The UD-IQ1_S (93.1GB) of GLM-5.3-Flash (320B total, 18B active) ran with llama.cpp v0.7.0 on the EVO-X2, with the Radeon 8060S specified.
• The previous version, b11192, could not load it because the architecture glm5-next was unsupported.
• Input processing was 170.24 tok/s (pp512, median of the middle 3) and generation was 18.46 tok/s (tg128, same).
• The memory used was about 92.8GB, within the range of 128GB.

If you want to try it, first update llama.cpp to v0.7.0 or later and measure the values on your own machine with llama-bench. The values here are only a record of a single run on one machine.

This article did not measure quality or image input. I will keep following them in this blog’s local LLM articles.

References

• GLM-5.3-Flash (README, config.json, LICENSE): https://huggingface.co/zai-org/GLM-5.3-Flash
• GLM-5.3-Flash repository information (creation date): https://huggingface.co/api/models/zai-org/GLM-5.3-Flash
• GLM-5.3-Flash evaluation data: https://huggingface.co/zai-org/GLM-5.3-Flash/raw/main/.eval_results/GLM-5.3-Flash.yaml
• GLM-5.3-Flash GGUF (unsloth): https://huggingface.co/unsloth/GLM-5.3-Flash-GGUF
• Artificial Analysis (GLM-5.3-Flash): https://artificialanalysis.ai/models/glm-5-3-flash
• The GLM paper (GLM: General Language Model Pretraining with Autoregressive Blank Infilling): https://arxiv.org/abs/2103.10360
• GLM-5 technical report: https://arxiv.org/abs/2602.15763
• The information above was checked on October 17, 2026.