# NVIDIA RTX Spark Encrypted Firmware Slows Linux LLMs 78%

*Updated on November 4, 2026*

AI engineers purchasing Nvidia's new 128GB unified-memory RTX Spark laptops—such as the MSI Prestige N16 Flip AI Plus, Asus ProArt, and Dell XPS—with plans to wipe Windows and run native Linux for local LLM inference are hitting a severe firmware wall. According to a hands-on hardware and driver investigation published by MindStudio Director of Product Luis Chavez-Mattos, booting native Linux on an RTX Spark laptop causes the GPU clock speed to collapse from `2.2 GHz` to roughly `780 MHz` the moment the machine is plugged into wall power, slashing local inference throughput by `78.7%`.

The RTX Spark mobile platform pairs an ARM CPU with the same unified-memory GPU architecture found in Nvidia's desktop `DGX Spark` workstation, offering up to `128GB` of shared system and video memory capable of holding `120-billion-parameter` models locally. However, while the desktop DGX Spark ships with Nvidia's custom Linux OS out of the box, every RTX Spark laptop ships with **Windows on ARM**.

When MindStudio benchmarked `GPT-OSS-120B` across operating systems on the MSI Prestige RTX Spark laptop, Windows on ARM delivered `65.4 tokens per second` and Windows Subsystem for Linux (`WSL2`) achieved `65.1 tokens per second`—actually edging out the desktop `DGX Spark` (`61.0 tokens per second`). On native dual-boot Linux using Nvidia's open kernel driver, however, the exact same laptop struggled to reach `13.9 tokens per second`.

Tracing the clock-speed collapse revealed that dynamic power allocation between the ARM CPU and GPU is governed by a proprietary Windows-only component called the **Nvidia Platform Controllers and Framework**. Because the firmware's power delivery table is cryptographically encrypted, only the Windows driver can decrypt it and authorize boost clocks above `780 MHz`; native Linux cannot read the power table and defaults to a fallback safe clock.

<a aria-hidden="true" id="executive-fast-facts"></a>  Fast Facts

- **Hardware Tested**: `Nvidia RTX Spark` 128GB unified-memory laptop (`MSI Prestige N16 Flip AI Plus`, sharing silicon lineage with Asus ProArt, Dell XPS, and desktop `DGX Spark`), audited in the [MindStudio RTX Spark Linux benchmark report](https://www.mindstudio.ai/blog/linux-nvidia-rtx-spark-laptop).
- **GPT-OSS-120B Throughput Gap**: Native Windows hit `65.4 tok/s` and `WSL2` hit `65.1 tok/s`, whereas native dual-boot Linux dropped `78.7%` to `13.9 tok/s` (compared to `61.0 tok/s` on desktop DGX Spark).
- **Root Cause (Encrypted Power Table)**: GPU clock speed locks at `~780 MHz` on AC wall power under Linux instead of `~2.2 GHz` on Windows because the **Nvidia Platform Controllers and Framework** power table is encrypted and lacks a Linux driver port.
- **96GB Firmware Memory Trap**: By default, system firmware reserves `96GB` of the `128GB` unified RAM exclusively for the Windows GPU driver, leaving native Linux with only `28GB` of visible system RAM unless reconfigured from Windows first.

## Benchmark &amp; Firmware Comparison Across RTX Spark Environments

For developers evaluating whether to run native Windows, `WSL2`, native Linux, or a desktop `DGX Spark` for local 70B–120B model serving, the MindStudio telemetry highlights how firmware locks dictate real-world performance:

| Execution Environment | GPU Clock on Wall Power | GPT-OSS-120B Speed (tok/s) | Visible RAM Out-of-Box | Linux AI Tooling (`vLLM` / `SGLang`) Support |
|---|---|---|---|---|
| **Windows on ARM (Native)** | ~2,200 MHz (Full Boost) | **65.4 tok/s** | 128GB (96GB GPU / 32GB OS) | Limited (Windows ports required) |
| **WSL2 on Windows on ARM** | ~2,200 MHz (Full Boost) | **65.1 tok/s (99.5% of Native)** | Configurable up to 120GB+ | **Full (Rides Windows power driver)** |
| **Nvidia DGX Spark (Desktop)** | ~2,000+ MHz (Desktop Linux) | **61.0 tok/s** | 128GB Unified | **Full Native Linux Out-of-Box** |
| **Native Dual-Boot Linux (Laptop)** | **~780 MHz (Firmware Locked)** | **13.9 tok/s (-78.7%)** | **28GB** (Until Windows split changed) | Full, but severely clock-throttled |

## The Hidden 96GB Unified Memory Split Trap on Dual-Boot Systems

Even before hitting the `780 MHz` clock ceiling, engineers attempting to dual-boot Debian or Arch-derived distributions (`Omarchy`) on RTX Spark laptops encounter a firmware memory partition lock. Out of the box, the laptop's UEFI/firmware carves out `96GB` of the `128GB` physical memory for the GPU using a hardware reservation register that only the Windows driver stack knows how to address or resize.

When booted directly into Linux with default factory settings, the Linux kernel only sees `28GB` of total system memory—rendering the machine unable to load large models. To unlock the full memory pool for Linux, users must first boot into Windows, lower the Windows-side dedicated GPU memory reservation from `96GB` down to `4GB`, and reboot; only then does Linux detect `120GB` of usable unified memory.

## Why WSL2 Is the Mandatory Workaround Until Nvidia Updates Linux Drivers

Because `WSL2` executes a real Linux kernel inside a lightweight hypervisor while delegating hardware power management and CUDA scheduling to the host Windows on ARM driver, it completely bypasses the encrypted power-table lockout. In `WSL2`, Linux-native inference engines like `vLLM` and `SGLang` sustain `65.1 tokens per second` on `GPT-OSS-120B`—matching native Windows within `0.5%` and even outpacing the desktop `DGX Spark`.

  Next Steps

1. **Use WSL2 Instead of Native Dual-Boot on RTX Spark Laptops**: Run `vLLM`, `SGLang`, and PyTorch workloads inside `WSL2` on Windows on ARM to retain the full `2.2 GHz` GPU boost clock and `65.1 tok/s` throughput on `120B` models.
2. **Adjust the Windows GPU Memory Split Before Dual-Booting**: If you must boot bare-metal Linux for kernel development, first lower the Windows GPU memory reservation from `96GB` to `4GB` so Linux can address `120GB` of unified RAM.
3. **Choose Desktop DGX Spark for Pure Bare-Metal Linux Servers**: If your deployment policy forbids Windows host OS layers, purchase the desktop `DGX Spark` (`61.0 tok/s` on native Linux) until Nvidia ports the Platform Controllers power logic to its open Linux kernel module.