RTX 3080 MoE Offloading Beats MS-03 in XDA Local AI Test

The MS-03 wins on loading convenience, while the RTX 3080 wins on generation​

XDA’s Ty Sherback compared a MINISFORUM MS-03 with an Intel Core Ultra 9 386H and one 32GB memory module against an Intel Core i7-6700K desktop carrying a GeForce RTX 3080 with 10GB of dedicated graphics memory. The desktop was already serving as a home lab, running Immich machine learning and Jellyfin transcoding alongside the llama.cpp software used for local AI inference. MINISFORUM supplied the review unit; Sherback disclosed that the company had no editorial input or advance access to the report.

That desktop context matters. Sherback ran llama.cpp in an LXC container on Proxmox and imposed a roughly 10GiB system-memory limit to protect the host’s other workloads. Consequently, this comparison measures a particular shared-service deployment against a particular mini PC configuration. It does not establish the maximum performance of every RTX 3080 system or every MS-03.

According to XDA, the MS-03 loaded both Qwen3.6-35B-A3B and Gemma 4 26B without the expert-placement tuning required on the older desktop. Sherback found loading the models somewhat more straightforward under Windows 11, although he preferred Linux for his own setup. On the mini PC, he reported inconsistent behavior with the SYCL and OpenVINO software backends, including failures to run; Vulkan delivered the most consistent generation speeds.

The largest reported generation-speed advantage came with Qwen3.6-35B-A3B in its IQ4_XS quantization. XDA measured up to 45.02 tokens per second on the tuned RTX 3080 system, compared with approximately 8–9 tokens per second on the MS-03. The available reporting does not include an independent reproduction of those measurements, so they should be treated as a useful configuration-specific finding rather than a general product ranking.

Qwen’s active parameters reduce computation, not the whole memory requirement​

The comparison depends on two separate techniques: mixture-of-experts architecture and quantization. Understanding their different jobs explains why the mini PC could load the models—and why the desktop could still be faster.

In XDA’s description of Qwen3.6-35B-A3B, the model contains approximately 35 billion parameters but activates roughly three billion for each generated token. A routing mechanism selects a subset of specialist networks, known as experts, while shared components and attention layers continue to operate. The total model size and the amount of active computation per token are therefore different quantities.

The important limitation is that inactive experts still belong to the model. Selecting only some experts for a particular token does not make the remaining weights disappear or turn the whole model into a three-billion-parameter memory allocation. Those weights must remain accessible, which is why a model with relatively modest active computation can still exceed a graphics card’s memory capacity.

Quantization addresses the storage side by representing model weights with fewer bits. XDA reported these sizes for the two Qwen files used in its tests:

The 2.40GiB difference became consequential near the desktop’s memory limits. Both files were substantially larger than the 9,873MiB of usable graphics memory Sherback reported on his RTX 3080, so neither could reside entirely in that card’s VRAM.

The MS-03’s larger shared-memory pool made loading these models easier in XDA’s testing. Even there, model-file size is only a starting point for capacity planning: XDA’s explanation explicitly distinguishes model weights from the additional memory required for context. A 32GB memory specification should not be read as permission to allocate all 32GB to weights.

llama.cpp’s expert placement changed the RTX 3080 result​

The desktop breakthrough came from llama.cpp’s --n-cpu-moe option, abbreviated -ncmoe. As described in XDA’s test, it controls how many model layers have their expert weights placed in CPU memory, allowing other model data to use the graphics card.

This is a more specific adjustment than moving an entire model between CPU and GPU. Its usefulness here follows from the MoE architecture: the large collection of expert weights can be treated differently from the model’s other components. In Sherback’s configuration, reducing the number of layers assigned to CPU memory put more of those weights within reach of the GPU’s limited VRAM.

XDA reported the following progression for the IQ4_XS version of Qwen3.6-35B-A3B:

The progression is more informative than the peak number alone. According to XDA’s measurements, changing expert placement raised generation speed from 16.45 to 45.02 tokens per second without replacing the graphics card or processor. That is approximately a 2.7-fold improvement calculated from the reported rates.

But -ncmoe 24 is a test result, not a universal recommended setting. It worked near the capacity boundary of this particular model file and desktop configuration. XDA did not establish it as a suitable value for another model, another context configuration, or even the larger quantization of the same model.

Nor does the report supply a complete reproducible Windows command line. It describes Windows 11 experiments on the mini PC and a Proxmox/LXC environment for the desktop, without publishing every build, driver, context, and runtime detail needed to turn the comparison into a cross-platform installation procedure. The supported lesson is to consider expert placement when evaluating an existing GPU, rather than to copy one flag and expect the same throughput.

The larger Qwen file exposed the container’s second memory limit​

The RTX 3080 had two relevant memory constraints in this experiment: its dedicated VRAM and the system-memory allowance of the llama.cpp container. The larger Q4_K_M file encountered both.

According to XDA, Q4_K_M failed at -ncmoe 24, even though IQ4_XS ran successfully there. Its fastest reported working configuration reached 24.91 tokens per second. Sherback also reported that the container remained near its 10GiB limit, at approximately 9.92GiB, during the Q4_K_M runs.

XDA attributed part of the slowdown to expert weights failing to remain cached in system memory and being repeatedly reread from NVMe storage. Across working splits, the report put Q4_K_M decoding 25–37 percent below IQ4_XS. Those percentages describe its matched working configurations; they should not be confused with the difference between the two formats’ separately reported maximum speeds.

This is where a simple “Does the model fit?” buying question becomes inadequate. In the reported desktop setup, successful allocation did not necessarily mean all useful model data could remain in the faster memory available to the runtime. The larger file changed the balance between graphics memory, host memory, and storage access.

For a home-lab administrator, the container limit was also a deliberate resource-management decision. Sherback wanted to preserve memory for other services. The experiment therefore demonstrates the performance achieved within that constraint, not proof that the i7-6700K platform itself could supply no more host memory.

The evidence supports a practical comparison between the two model files’ speed and capacity behavior. It does not include an output-quality evaluation that would establish whether IQ4_XS is the better choice for every task. Choosing the faster file on these numbers alone would leave answer quality unassessed.

The MS-03’s single memory module leaves its upgrade benefit unmeasured​

XDA measured Gemma 4 26B generation at approximately 9–13 tokens per second on the MS-03 using Vulkan. Sherback contrasted that with a 22.05-token-per-second figure he attributed to MINISFORUM’s website and identified the review unit’s single-channel memory configuration as the main explanation for the gap.

The useful finding is that the tested unit contained one 32GB SODIMM and delivered those lower measured rates. The stronger claim—that adding a second module would double token generation—was not established by a second test. A two-module upgrade was proposed, not benchmarked.

That boundary matters when making a purchase. The report supplies neither an otherwise identical single-channel-versus-dual-channel comparison nor a demonstrated match between the vendor’s benchmark conditions and Sherback’s workload. It supports investigating memory population before buying this configuration, but not budgeting around a guaranteed twofold speed increase.

Generation speed also captures only part of the interaction. Prefill is the initial processing of the prompt; decoding is the subsequent generation of output tokens. XDA reported that the MS-03 generally had much faster prefill, while the tuned RTX 3080 delivered faster decoding. Without numerical prefill results and matched prompt-and-output lengths, the report cannot establish a universal end-to-end completion-time winner.

The MS-03 retains other practical attractions in Sherback’s account: easier model loading, a smaller physical footprint, and networking comprising two 10GbE SFP+ ports, one 10GbE RJ45 port, and one 2.5GbE port. Those features can be relevant to a home-lab server decision, but the comparison does not show that they improve local token-generation speed.

Choose local AI hardware around the workload and the memory boundary​

If you already own an RTX 3080-class system, these results justify evaluating its supported MoE offloading options before replacing it purely to gain model capacity. If you are considering the MS-03, the evidence favors treating memory configuration and measured generation performance as purchase criteria alongside the advertised ability to load a large model.

• Keep the reported configurations attached to the numbers: XDA tested a single-module 32GB MS-03 and an RTX 3080 desktop with a tightly limited llama.cpp container.
• Treat -ncmoe 24 as one successful Qwen IQ4_XS configuration, not a safe default for other models or quantization formats.
• Account for host memory as well as VRAM, because XDA reported storage rereads when the larger model file pressed against the container’s memory limit.
• Separate prompt-processing speed from output-generation speed when judging responsiveness; the MS-03’s reported prefill advantage does not erase its slower decoding.
• Do not assume a second MS-03 memory module will double throughput, because that upgrade was not tested in this comparison.
• Keep answer quality in the decision, because the reported speed advantage of IQ4_XS was not accompanied by a comparative quality assessment.

The concrete outcome is encouraging for owners of older gaming hardware: in XDA’s home lab, selective expert placement made a model larger than the RTX 3080’s VRAM usable at substantially higher generation speed than the tested mini PC. The MS-03 offered easier access to larger models, but its untested two-module configuration remains a separate buying decision. For either route, the meaningful target is a model that runs well within the memory you can actually allocate—not merely one that loads.