GB10, Ryzen AI Max+ 395, or Mac: which is fastest?

#How did we compare three machines?

To compare the published Ryzen AI Max+ 395 and Mac benchmarks with the ATOM's measurements, we reused the exact format of previously published measurements. The first test has the machine read 512 tokens (a token is a piece of a word), then write 128 (“pp512” and “tg128” in llama-bench, the benchmarking tool for llama.cpp, a widely used open-source engine for local models).

This test was published for a Mac M5 Max in llama.cpp discussion #4167, and by kyuz0, an independent contributor, for a Framework Desktop with the Ryzen AI Max+ 395 and 128 GB. The second test measures speed when 32,768 tokens are already in memory. It's the one from llama.cpp discussion #16578, and kyuz0 also publishes it for the Ryzen.

Our protocol was frozen on October 6, 2026 at 13:30, before the first measurement. An amendment that same day, at 23:45, added this comparison format.

The 512-token read and 128-token write measurements date from October 7 at 22:38: five runs per model, llama.cpp build 11430, Flash Attention enabled as in kyuz0's measurements, and no other workload running on the machine. The 32,768-token measurements date from October 6. The methodology, file hashes, and the data behind our tables are published on our methodology page.

Speeds are in tokens per second (tok/s). A token is a piece of a word: in French, it equals about two-thirds of a word. Memory sizes are in GB (1 GB = 1,024 MB, as Linux displays it); memory bandwidth figures in GB/s are those stated by the manufacturers, in decimal units. Here are the commands used on the ATOM:

# lecture de 512 tokens, écriture de 128 tokens, 5 répétitions
llama-bench -m modele.gguf -ngl 99 -fa on -lm dio -p 512 -n 128 -r 5

# 32 768 tokens déjà en mémoire : lecture de 2 048 tokens, écriture de 32 tokens
llama-bench -m modele.gguf -ngl 99 -fa on -lm dio -d 0,4096,8192,16384,32768 -p 2048 -n 32 -ub 2048 -r 5

One caveat: the build is the llama.cpp version number, and the three machines don't use the same one. The Ryzen was benchmarked with builds b9187 or b9193 in May 2026, the Mac with b10621 in August, and the ATOM with b11430 in October.

A newer build may run faster. In the interest of fairness, for the 32,768-token test we also report our numbers with build 7941 from February 2026, which is older than the Ryzen's (no published benchmarks exist for the Mac in this format).

#Three 128 GB machines: what's the difference?

NVIDIA's GB10 combines 20 Arm cores and a Blackwell GPU around 128 GB of unified memory (shared by the CPU and GPU), with a rated bandwidth of 273 GB/s. AMD's Ryzen AI Max+ 395 (codenamed Strix Halo) also shares 128 GB between the CPU and GPU, with about 256 GB/s in theory. Apple's M5 Max goes up to 128 GB, with 614 GB/s and a 40-core GPU.

To write each token, the chip rereads the model's active weights (the parameters in use at that moment) from memory. So writing speed depends on memory bandwidth, while reading, which processes many tokens at once, depends on the GPU's compute power.

The GB10 and the Ryzen have similar bandwidth, and so do their writing speeds. The M5 Max offers 2.25 times the ATOM's bandwidth (614 vs. 273 GB/s): on the only published dense model, llama 7B, it writes about twice as fast.

As far as we know, all 128 GB GB10 machines share the same NVIDIA chip, so the speeds in this guide reflect the platform. What GIGABYTE adds is the one-liter chassis (1.2 kg), the cooling, the build quality, and the retail SKUs.

To verify that our unit actually delivers the platform's speeds, we reran the table that the llama.cpp project published for NVIDIA's DGX Spark, the platform's reference machine (build 7941, February 2026). Across six models and 60 data points, our reading results are +0.3% at the median (from −1.8% to +2.3%) and our writing results −2.8% at the median (from −4.3% to −0.3%): the two machines perform at the same level.

#Which reads fastest?

Reading is the ATOM's strong suit. The table covers the four models we were able to compare exactly, meaning with the same model and the same quantization on each machine. “llama 7B” refers to Llama 2 at 7 billion parameters, the reference model in these publications: it's a dense model (it uses all of its parameters for every token), whereas the other three are MoE models (they activate only a portion of them).

On these four models, the ATOM reads 2.1 to 2.8 times faster than the better of the Ryzen AI Max+ 395's two software stacks (Vulkan and ROCm are two ways to run computations on AMD's GPU). On gpt-oss 120B, it reads 2,005 tokens per second, so it processes a 2,000-token prompt (about 1,300 words) in one second.

Against the Mac, we have only one published comparison point in llama-bench format: the reference model from llama.cpp discussion #4167 on Apple chips, llama 7B (the 7-billion-parameter Llama 2) in Q4_0. There, the ATOM processes 3,955.7 tokens per second, versus 3,220.0 for the M5 Max: 23% more.

With Ollama (a tool for running models locally), on a document of about 17,000 tokens, our first guide in the series measured 1,816 tok/s on gpt-oss 120B for the ATOM, versus 1,388 for a MacBook Pro M5 Max measured by a reader, on a similar but not identical text (16,850 tokens for the ATOM, 16,689 for the Mac): 31% more.

Why does the ATOM read so fast? Reading is mostly computation, and the GB10's Blackwell GPU has cores dedicated to AI computation (NVIDIA's “Tensor Cores”). That's the criterion that matters for a fifty-page report, a code repository, or an agent that rereads its history before every response.

Two caveats when reading these results. First, the builds differ (10621 for the Mac, 11430 for the ATOM): treat the 23% gap as a ballpark figure. Second, the two smallest models (llama 7B and gpt-oss 20B) vary by 3 to 5% from one run to the next, because this test lasts about a tenth of a second. Even so, two separate series give averages within 1% of each other: 3,955.7 and 3,920.2 for llama 7B, 4,897.7 and 4,905.2 for gpt-oss 20B.

#Which writes fastest?

Writing is the pace at which the response is displayed. It tracks memory bandwidth, which differs from one machine to another.

Compared with the Ryzen AI Max+ 395's best software stack, the ATOM generates 4 to 7% faster on three models, and 15% faster on Nemotron-3 Super 120B. That's close: the two memory systems have similar bandwidth, and the builds differ.

On gpt-oss 120B, a 117-billion-parameter model, the ATOM generates 58.8 tokens per second over 128 tokens (58.0 over 32 tokens in our first guide), which is very smooth for a conversation. The Ryzen manages 56.6 at best.

The M5 Max Mac writes faster, about twice as fast on a small dense model (119.9 vs. 59.4 tokens per second), thanks to its 614 GB/s memory, 2.25 times that of the ATOM.

On a dense model, software can speed up generation. With speculative decoding, a small "draft" model proposes tokens that the large model validates in a single pass. Using this technique, Llama 3.3 70B on the ATOM goes from 4.7 to 12 tokens per second on French text (8 words ahead) and up to 18.7 on code (16 words ahead). That makes it 2.6 to 4 times faster (llama-server b11430, draft model Llama 3.2 1B, 6 and 7 October 2026). This technique is also available on the other machines, but we haven't measured it there.

#What happens with a long document?

The longer the existing text, the slower the output that follows. The long-context test measures reading and writing when 32,768 tokens are already in memory, which is roughly fifty pages. The table compares the ATOM with the Ryzen AI Max+ 395 on both gpt-oss models, with two builds for the ATOM. To our knowledge, no measurement in the same format has been published for the Mac.

With gpt-oss 120B, the ATOM reads 1,832 tokens per second at a 32,768-token context: 2.8 times faster than the Ryzen AI Max+ 395 on ROCm (653) and 6 times faster than on Vulkan (308). With build 7941, older than the Ryzen's, the lead is still 2.4 times and 5 times. With gpt-oss 20B and build 11430, the lead is 2.9 and 6.0 times.

In generation at 32,768 tokens, the ATOM (42.2 tok/s on gpt-oss 120B) is on par with the Ryzen's best stack (43.0 on Vulkan) and ahead of the other (36.3 on ROCm). So the takeaway is simple: on a long document, AMD's machine generates just as fast with its best stack (43.0 on Vulkan), but it takes 2.8 to 6 times longer to read it.

In practice, with llama-server (llama.cpp's server), our ATOM reads a 30,000-token document in 21.8 seconds with gpt-oss 120B, then generates its response at 42.8 tokens per second (measured in our first guide in the series).

#What about multiple users?

When several people or several agents (AI programs that work on their own) query the machine at the same time, a server like vLLM batches their requests and reads the model weights only once for all of them. Bandwidth then stops being the only bottleneck, and the GB10's compute power takes over.

In our first guide, gpt-oss 120B goes from 35.6 tok/s for one person to 160.3 tok/s in total for 16 people, with each still getting 10.2 tok/s. gpt-oss 20B goes from 49.1 to 322.4 tok/s in total, with 20.7 tok/s per person (vLLM 26.09, October 6, 2026).

Sustained performance matters as much as peak. Over 1 hour with 16 users (4,096-token requests, 512-token responses), gpt-oss 120B held at 124.8 tokens per second in total from start to finish: from 122.6 to 128.1 across the 14 measurement windows, or 0.0% drift, with the GPU peaking at 77 °C and no throttling.

Over 2 h with 8 users on Llama 3.3 70B in NVFP4 (a compressed format from NVIDIA), total throughput went from 38.7 to 38.5 tokens per second (−0.6%).

StorageReview measured a similar workload with vLLM on the AMD Ryzen AI Halo machine, from the Ryzen AI Max family, against a DGX Spark. The AMD machine remained 2 to 4 times behind in most high-concurrency scenarios, and up to 8.8 times behind on a read-heavy test with gpt-oss 120B. The DGX Spark uses the same chip as the ATOM, and these Ryzen figures come from StorageReview's test.

#What difference does CUDA make, especially for training?

CUDA is NVIDIA's software platform for computing on its GPUs. On the ATOM, under DGX OS 7.5.0 (CUDA 13.0, driver 580.159.03), llama.cpp compiled for the chip, vLLM in the container provided by NVIDIA, and Unsloth all worked in our setup. To our knowledge, many AI tools are written for CUDA first: that's an advantage for both serving and training models.

For training, NVIDIA advertises fine-tuning of models up to 70 billion parameters on the platform. We measured two cases with Unsloth 2026.10.1 and the QLoRA method (fine-tuning with weights compressed to 4 bits), using 1,024-token sequences and 40 steps, with the first 10 used as warm-up.

Llama 3.3 70B requires 41.3 GB of GPU memory at peak and 9.4 seconds per step. gpt-oss 120B requires 64.4 GB and 6.4 seconds per step. Two models of this size therefore train within the ATOM's memory, with room to spare.

A real-world example: a light 85-minute LoRA fine-tune of Qwen3-8B (one epoch, 2,000 examples) raised the share of invoices extracted with zero errors from 26.0% to 95.0%, on 200 unseen documents with strict scoring. That beats gpt-oss 120B without training (62.5%). The invoices are fictitious and were generated by us. Our fine-tuning guide in this series explains the method in detail.

Two QSFP ports (the ConnectX-7 network card, 200 Gb/s according to GIGABYTE) and a 10 GbE port round out the machine. According to GIGABYTE, up to four GB10 machines can be linked in a cluster; we haven't tested this setup.

#How much do these three machines cost?

Prices including VAT, checked on retailer pages in France on October 8, 2026. GB10 prices change every week, so check them before you buy.

The Ryzen AI Max+ 395 is the cheapest machine. At equal storage of 4 TB, the ATOM 9000 (PCIe 5.0 SSD, the version we measured) and an M5 Max Mac Studio fall in the same price range. The ATOM 9001, with a PCIe 4.0 SSD, is the cheapest 128 GB GB10 machine in the table; as far as we know, it keeps the same chip and the same memory.

The SSD mainly affects a model's load time, not its compute speed; the SSD readings apply to the 9000 version. We also list the price of an M5 Max Mac Studio because it uses the same chip as the machines measured in the publications; its speed was not measured in this guide.

The two ATOMs stand out for their one-liter chassis (1.2 kg) and GIGABYTE's choices: cooling, finish, SKUs.

#What this comparison doesn't tell you

Source of the measurements

The numbers for the Ryzen AI Max+ 395 (a 128 GB Framework Desktop) and the M5 Max Mac come from publications, with their build and date; the mini PCs in the price table were not measured. Treat differences under 10% as a tie: builds change, and two units of the same model differ by a few percent.

Apple's MLX engine is not measured

On a Mac, MLX can deliver different speeds than llama.cpp or Ollama. Our MLX vs. llama.cpp guide explains this difference.

Only one model in common with the Mac

The llama-bench format published for the M5 Max covers only llama 7B. For large models, we have only a reader's Ollama measurement.

Response quality

This guide compares speeds, not model quality.

Multiple users and training on the other machines

We did not measure them on either the Ryzen or the Mac. For the Ryzen, we cite StorageReview.

Updates and corrections: this page will be revised if a new llama.cpp build or a new publication changes these results; each correction will be dated.

#Who ATOM is the right choice for

The following comes from our measurements on the ATOM and the published figures cited above.

The ATOM is the right choice if you read long documents or code

It reads gpt-oss 120B 2.8 times faster than the Ryzen AI Max+ 395 with 32,768 tokens in memory, and a 30,000-token document in 21.8 seconds.

… if multiple people or agents share the machine

160.3 tokens per second in total for 16 users with gpt-oss 120B; with longer requests, throughput held at 124.8 tokens per second for 1 hour, with no drop.

… if you train or fine-tune models

QLoRA on a 70-billion-parameter model fits in 41.3 GB. A LoRA run on invoices took 85 minutes.

… if you want large MoE models in a one-liter box

gpt-oss 120B generates 58.8 tokens per second on a 1.2 kg machine.

A Mac M5 Max is the better fit if you work alone with small dense models

It writes about twice as fast on llama 7B (119.9 vs. 59.4 tokens per second).

A Ryzen AI Max+ 395 mini PC is the better fit if budget is the deciding factor

Writing stays close on MoE models, starting at €3,449.99, but reading is 2.1 to 2.8 times slower.

In short: if your work involves reading long texts, the ATOM is the right choice based on our comparisons. For serving multiple people or training, its own measurements are solid: 160.3 tokens per second in total for 16 users, and a 70-billion-parameter QLoRA in 41.3 GB. If you generate text on your own with small dense models, look at the Mac. If budget is the deciding factor, look at the Ryzen.

#FAQ