The moment I booted the Minix ER937‑AI, wiped Windows 11, flashed a Linux USB stick and had Ollama answering a prompt in seconds, it became obvious this tiny machine was more than a lightweight desktop — it was a compact, pragmatic workstation that delivered real local‑AI capability without the usual compromises.
Background / Overview
The Minix ER937‑AI arrived in the reviewer’s hands as a Windows‑shipped mini PC built around AMD’s latest mobile AI silicon, but the story that matters is what happened after the author installed Linux and used the machine for local AI experiments. Out of the box the unit reportedly includes an AMD Ryzen AI 9 HX 370 APU, AMD Radeon 890M graphics, a dedicated NPU, 32 GB DDR5 RAM and a 1 TB PCIe 4.0 NVMe SSD — a configuration that positions it between a conventional mini PC and a purpose‑built local‑AI appliance. The reviewer’s practical testing — installing Ultramarine Linux, setting up Ollama and running agentic browsing with qwen2.5:7b — produced fast, responsive results, though sustained heavy inference drove the cooling fans to audible levels. This hands‑on experience mirrors broader trends seen in recent mini‑PC reviews where Linux yields lower OS overhead and better throughput for CPU/NPU‑bound local LLM workloads.
What the ZDNET piece makes clear — and what this article expands on — is a practical recipe for converting a modern Windows mini PC into a productive Linux workstation while preserving the device’s strengths (compactness, ports, multi‑monitor capability) and addressing its practical tradeoffs (noise, thermals, occasional driver work).
Why Linux here matters: practical performance and workflow gains
Mini PCs like the Minix ER937‑AI are increasingly built with silicon that benefits from a lower‑overhead OS. The reviewer’s immediate experience — swapping Windows for Ultramarine Linux and seeing faster responsiveness, snappier boot times and lower latency for Ollama inference — is consistent with repeated observations across similar systems. Linux removes many background services, enables finer control of process scheduling and often benefits from community and upstream driver support on AMD platforms.
Two practical performance vectors matter for the local‑AI use case:
- System overhead and scheduling: Linux typically consumes fewer background resources and offers kernel scheduling that can be tuned for multi‑threaded inference workloads, which can unlock additional throughput on high‑core APUs.
- Runtime and driver maturity: Many inference runtimes and model toolchains were developed with Linux as a primary deployment target; once drivers and runtimes are working, throughput and stability often improve relative to a comparable Windows setup. Community reports show measurable gains for LLM workloads on Linux versus Windows in comparable hardware configurations.
These generalizations are not universal — exact gains depend on the model, quantization, runtime, and cooling — but they explain why the Minix, once reimaged to Linux, felt more capable for the reviewer’s Ollama + qwen experiments than the same tasks did on a larger desktop.
Hardware snapshot and what those specs mean for real work
The ZDNET review lists the ER937‑AI’s configuration in plain terms: an AMD Ryzen AI 9 HX 370 CPU, integrated AMD Radeon 890M graphics, an NPU block, 32 GB DDR5‑5600, and a 1 TB PCIe 4.0 NVMe SSD. The machine also offers modern I/O: USB4/USB‑C, USB 3.2, HDMI and DisplayPort outputs and dual 2.5 GbE. That combination makes it a flexible, small‑form‑factor workstation suitable for multi‑monitor productivity and local AI experimentation.
Why those elements matter:
- Ryzen AI 9 HX 370 — combines high‑frequency CPU cores with on‑package neural acceleration. For many distilled or quantized models in the 7B–13B parameter range, such an APU can deliver competitive latency without the need for a discrete GPU, provided there’s enough RAM and the model is optimized for the NPU/runtime.
- 32 GB DDR5 — is enough for many small‑to‑medium local models; larger models or multiple simultaneous sessions will push you to add more RAM or use swap (which degrades performance).
- PCIe 4.0 NVMe — crucial for fast model loading and reduced latency when dealing with swap or large model checkpoints.
- Modern I/O (USB4, DP, HDMI, 2.5 GbE, Wi‑Fi 7) — makes the machine viable as a primary workstation: external NVMe enclosures, network shares and multiple displays are all supported, which matters for productive desktop workflows.
Caveat: some vendor‑claimed display or throughput capabilities (for example, “four‑screen 8K@60Hz”) should be validated against the technical documentation for the specific ports and DP/HDMI versions on your SKU; marketing claims about maximum multi‑display resolution can depend on how the display outputs are wired internally and on driver support. Treat those claims as
likely achievable only with validated cabling and correct driver support.
The on‑device AI experience: Ollama, qwen and agentic browsing
The reviewer installed Ollama, pulled models and used an agentic browser workflow that chained web search and product selection — a useful, real‑world stress test. The unit handled small–medium models very quickly, producing near‑instant responses for short queries and completing a multi‑step, agentic Amazon search far faster than the reviewer’s larger desktop in the same test. That performance delta aligns with other hands‑on reports that show well‑configured mini PCs with modern APUs and NPUs outperforming larger, older desktops for certain inference tasks, particularly when the workload fits in RAM and uses runtimes optimized for the platform.
Two practical notes from that testing:
- Fan noise is real under sustained load. The reviewer noted loud fans during prolonged agentic browsing runs; small chassis and aggressive cooling profiles mean acoustic impact is a likely tradeoff for compact, high‑power mini PCs. Plan for remote placement or acoustic mitigation if you need silence.
- Model quality vs. latency tradeoffs. Faster wall‑clock answers on smaller or distilled models don’t always mean better answers. Many mini‑PC tests show that smaller quantized models can be quicker but less accurate than larger models run more slowly or on a different stack. Choose models with your quality/latency tradeoff in mind.
Step‑by‑step: how the reviewer converted the ER937‑AI to Linux (and how you can too)
Below is a practical, reproducible sequence — distilled from the reviewer’s method and general best practice — for turning a Windows‑shipped mini PC into a dependable Linux workstation for general use and local AI work.
- Back up everything
- Create a full image of the Windows drive (use Clonezilla, Macrium Reflect, or vendor recovery tools). Keep a copy on external storage.
- Prepare a Linux live USB
- Choose a distro (the reviewer used Ultramarine Linux; Ubuntu 24.04 / Kubuntu are excellent alternatives). Write the ISO to a USB using balenaEtcher or Rufus (on Windows) or the dd command.
- Preflight: check firmware and Secure Boot
- Boot into UEFI and note SATA/NVMe mode (AHCI recommended). If Secure Boot is enabled, decide whether to keep it; many distros support Secure Boot, but enabling it can complicate third‑party driver installs.
- Live boot and hardware test
- Boot the live USB, test display outputs, Wi‑Fi, Ethernet, audio and storage recognition. This confirms the hardware is usable before you wipe Windows.
- Install Linux
- Partition as you prefer (ext4 for root, swap file or swap partition sized to your RAM + buffer, separate /home if desired). Install, enable SSH and create a local admin user.
- Post‑install: drivers and firmware
- Update the kernel and firmware packages (linux‑firmware). For AMD APUs, modern kernels and mesa drivers are recommended.
- Install Ollama and runtime dependencies
- Follow Ollama’s Linux install path (binary or package); ensure model paths have enough disk space and the runtime has the correct permissions.
- Model selection and tuning
- Start with a quantized model (7B–13B) and an inference backend optimized for CPU/NPU. Measure latencies and monitor memory and swap usage.
- Thermal and power tuning
- Use tools like powertop, cpufrequtils and vendor power profiles to manage power. For noise reduction, consider limiting sustained CPU frequency (with careful benchmarking).
- Create a rollback plan
- Keep your Windows image and, if needed, a small Windows VM for remaining Windows‑only apps.
This workflow mirrors the pragmatic sequence the reviewer described: test first, backup, then commit — with a focus on verifying the exact model and inference workload you intend to run.
Best practices for local LLMs on compact systems
- Prioritize RAM and NVMe throughput over peak CPU frequency for reproducible local model runs.
- Start with quantized or distilled models and scale up only after monitoring RAM and swap behavior.
- Use a fast NVMe and configure tmp/model directories on the fastest storage available to reduce load times and swap pressure.
- For frequent model experimentation, keep a small set of validated models and scripts for repeatable comparisons.
- If you need a Windows fallback for legacy apps, keep a Windows image or a small VM available until you’re confident everything important runs well on Linux. Community guidance strongly recommends a staged migration: live USB → dual boot → full wipe only after testing.
Strengths: why this approach makes sense for many users
- Performance per cubic inch: Modern APUs with NPUs give significant on‑device inference capability without a discrete GPU, and a Linux stack often extracts that performance efficiently.
- Compact, quiet day‑to‑day use (when not under heavy AI load): For ordinary productivity tasks the mini PC remains unobtrusive; KDE Plasma or other lightweight desktops run smoothly.
- Cost effectiveness: At roughly $999 in the reviewed configuration, this class of machine offers an attractive balance of compute, I/O and upgradeability for buyers who want a small footprint and local AI experimentation capacity.
Risks, caveats and things the reviewer glossed over
- Noise under sustained inference: Small chassis require aggressive fan curves; expect audible noise under multi‑minute inference loads. This isn’t a defect so much as a physics problem: compact fans moving lots of air are loud. Plan for placement or quieter cooling strategies if needed.
- Model fidelity vs speed: The reviewer’s quicker agentic tasks used smaller or optimized models. If you expect large‑model parity with cloud inference, you’ll need larger hardware or to accept longer latencies. Beware equating speed on small distilled models with overall model quality.
- Driver and peripheral edge cases: While AMD has strong Linux support, some niche peripherals or fingerprint sensors (the Minix power button is said to double as a fingerprint reader) may need extra drivers or may not be supported on all kernels. That’s resolvable but can require additional work. Treat certain advanced features as “may require tinkering.”
- Warranty and support posture: Reimaging the device will likely change your support relationship with the vendor; keep recovery media and a record of original partitions in case you need to restore factory settings.
Where claims are purely anecdotal (for example, “this is the best mini PC I’ve ever used”), treat them as opinion. Technical claims — chip model, RAM, PCIe generation and connectivity — align with common hands‑on reports for similar hardware, but buyers should verify the exact SKU and vendor spec sheet before purchasing.
Practical tuning and follow‑up tips for a production setup
- If you plan to run multi‑session local inference, consider expanding RAM if the chassis and SKU allow. Extra RAM eliminates many swap bottlenecks.
- Invest in a fast external NVMe enclosure if you need to keep multiple model images available; a second NVMe slot or external USB4 enclosure can be a cost‑effective way to maintain responsiveness.
- Use systemd‑services to manage Ollama or inference runtimes so they start automatically and run under controlled cgroups — this improves stability for continuous workflows.
- Keep a small “rescue” USB with kernel and initramfs you’ve tested; this speeds recovery if a kernel update breaks a driver you rely on.
- For quieter operation, experiment with fan curves or frequency capping and measure the throughput impact; some users prefer a slightly slower steady state with far less noise.
Verdict: who should buy one and why
The Minix ER937‑AI (as reviewed) is for the user who wants a highly capable, compact workstation that doubles as a local AI sandbox: developers, privacy‑conscious researchers, power users who want to experiment with on‑device LLMs, and anyone who prefers a small, VESA‑mountable machine that still offers robust I/O and multi‑monitor support. For those priorities — and given the price/performance observed in the hands‑on testing — converting the device to Linux is a practical way to access additional responsiveness and lower inference latency for certain workloads.
Not a fit: users who rely on niche Windows‑only software with no viable Linux alternative, hardcore gamers who require consistent anti‑cheat support, or anyone who needs an ultra‑quiet studio environment under constant heavy AI load without external acoustic measures. For those buyers, a larger desktop with a discrete GPU or continuing to run Windows may be the better call.
Conclusion
The ZDNET hands‑on with the Minix ER937‑AI confirms a simple thesis: modern tiny PCs can be serious, practical workstations when paired with the right OS and software. Wiping the factory Windows image, installing a lightweight but modern Linux distro, and setting up a local inference runtime like Ollama gave the reviewer a machine that felt faster, more responsive and unusually capable for its size —
until long, thermally demanding workloads drove the fans into audible territory. That tradeoff — compact size and genuine compute density at the cost of acoustics under load — is the fundamental engineering compromise of the category.
For the enthusiast and the pragmatic developer alike, this is good news: a $999 mini PC can be a productive Linux workstation and a capable local‑AI host. The path is not without work — backups, driver checks, thermal tuning and model selection matter — but for many users the payoff will be a clean, powerful desktop that fits behind a monitor and actually accelerates local AI experimentation in a way larger, older desktops may not.
Source: ZDNET
I turned this Windows mini PC into a Linux workstation and don't regret it - here's how