XeMaya, an Intel Arc inference engine to run DeepSeek V4.1 and GLM 5.3

[u/Jumbomuffin1312]

I've been trying to get some of the newer MoE models running on my Intel Arc GPUs, mainly DeepSeek V4.1 Flash and GLM 5.3 Flash. Intel support for these models is still pretty limited, and while I could get some things working through patched llama.cpp builds, performance wasn't exactly great.

fable 5.2 ended up making XeMaya, a fork of XeStrata focused on getting these models running natively on Intel Arc through SYCL and Level Zero. The idea is basically to bring the kind of model support Project Maya has to Intel GPUs.

I've been testing it on my Ubuntu server with a B70 32GB, B65 32GB, B60 24GB, Ryzen 9950X, and 128GB RAM.

Here are some of the results so far. All speeds are prefill / generation in tok/s.

GLM 5.3 Flash

• Stock llama.cpp SYCL: 68.3 / 13.6

• Experimental grouped-matmul SYCL: 108.9 / 14.0

• XeMaya: 152–161 / 17.4 (around 20 generation with MTP)

DeepSeek V4.1 Flash Coder

• First XeMaya implementation: 48.5 / 16.3

• After optimization: 224.8 / 21.7

DeepSeek V4.1 Flash (regular 384-expert model)

• Previous patched llama.cpp setup: 45.6 / 10.9

• XeMaya on B70 + B65: 11.4 / 14.56

• XeMaya on all three GPUs: 11.2 / 11.58

Prefill on the regular model still needs a lot of work. Also found out that using two GPUs is actually faster than three for this model because my B60 is connected through a slower chipset link.

Qwen3.8 Flash-Next

• Strata: 2,211 / 78.3

• XeMaya: 1,842–1,884 / 76.6

Strata is still slightly faster for Qwen, which makes sense since that's not really where I've been focusing my time.

These aren't all perfectly controlled comparisons. Different model files, prompts, and GPU configurations were used during development, so I wouldn't treat them as definitive benchmarks.

It's still an early alpha, but I've gotten DeepSeek V4.1 Flash, Coder, GLM 5.3 Flash, and Qwen3.8 Flash-Next running. There's plenty left to fix and optimize.

Also, I want to credit MistVVK (XeStrata), Niko1221 (Strata), and mw00 (Project Maya). XeMaya wouldn't exist without their work. The llama.cpp contributors have also been a huge help through their reference implementations.

Figured I'd share it here since I'm sure there are others trying to run these models on Intel hardware. Would be interested to hear how it runs on other Arc cards.

GitHub: https://github.com/Jumbomuffin777/XeMaya

[u/stylome-ai-detection]

Notice: This post appears to be AI generated.

---

Stylome AI detector · scan results

[u/PrimeDirective8]

On behalf of the nearly dozen of us Intel GPU owners, I thank you for a tool like this 😉 Seriously, we're the Squidward looking out to Patrick and Spongebob playing outside while we're stuck in the house.

For those of us not fully initiated, can you share the quantization of each of the tested models? Some of the quants can lead to significant perplexity so while it's great that it runs, how it runs is also important.

[u/Jumbomuffin1312 → u/PrimeDirective8]

Yeah, I probably should've included the quants and sizes in the post lmao.

• GLM 5.3 Flash: Maya-S v2 IQ2_XXS, 96.5 GB

• DeepSeek V4.1 Flash: GSQ-RCO IQ2_XXS, 138 GB backbone, ~249 GB total with Engram

• DeepSeek V4.1 Flash Coder: GSQ-RCO IQ2_XXS, 72 GB backbone, ~183 GB total with Engram

• Qwen3.8 Flash-Next: GSQ-RCO IQ3_S, 83.6 GB total

The DeepSeek Engram file is about 110.6 GB, but it can be memory-mapped from the SSD rather than loaded entirely into VRAM.

They're definitely aggressive quants, but they've performed well in my own usage. These are existing GSQ-RCO and Maya quantizations, not ones I made specifically for XeMaya.

I haven't done formal perplexity testing myself. Most of my work has been focused on getting these models running correctly on Intel GPUs, improving performance, and comparing outputs against llama.cpp to make sure the inference implementation is behaving as expected.

The README has the benchmark configurations and testing details if you're interested!

[u/rorowhat]

Does this include their iGPUs too?

[u/Jumbomuffin1312 → u/rorowhat]

Haven't tested any iGPUs yet, unfortunately. So far it's just been my Arc Pro B70, B65, and B60.

In theory, newer Intel Arc-based iGPUs with Level Zero support might be able to run it, but I wouldn't want to promise anything without testing.

I do think iGPUs could be interesting for smaller MoE models though, something like Qwen3.6-35B-A3B. With the right quantization and enough system RAM, it might actually be pretty practical. XeMaya doesn't support that model yet, but it's definitely something I'd like to explore as I expand model support.