Apple users experimenting with the Apertus open foundation model — the Swiss-built sovereign AI model designed for transparent, locally hosted inference — are running into a string of frustrating problems on macOS. Reports surfacing in the Apple Support Community describe failed model downloads, broken Python bindings, runaway memory usage on Apple Silicon, and inference crashes that occur the moment the model attempts to load. The issue is widespread enough that anyone trying to run Apertus locally on a Mac is likely to hit at least one of these roadblocks.
This guide walks through what is actually going wrong, how to fix it in the right order, and when to escalate the problem. The instructions assume you are on a modern Apple Silicon Mac (M1 through M4) running macOS Sonoma or Sequoia, since that is the configuration most affected.
What Causes This Issue
Apertus is distributed as a large open-weights model, and running it on macOS introduces several layers of fragility that Linux users do not face. Based on patterns shared by users in the Apple Support Community and known behaviour of the underlying tooling, the root causes fall into a handful of categories.
The first is Metal Performance Shaders (MPS) compatibility. PyTorch’s MPS backend, which lets Apple Silicon GPUs accelerate model inference, still lacks support for certain operations Apertus uses. When an unsupported op is encountered, the runtime either crashes outright or silently falls back to CPU, causing extreme slowdowns.
The second is memory pressure. Apertus ships in multiple sizes, and the larger variants demand more unified memory than many Macs can comfortably provide. macOS aggressively swaps when memory pressure spikes, which manifests as beachballs, kernel panics, or the dreaded “Python quit unexpectedly” dialog.
Third, broken Hugging Face Hub downloads are common. Large model shards time out behind certain ISPs or VPNs, leaving partial files that pass existence checks but fail integrity verification on load.
Fourth, mismatched llama.cpp or MLX builds cause tokenizer errors. Apertus uses a custom tokenizer, and older builds of these inference engines do not recognise it.
Finally, Gatekeeper and Xcode Command Line Tools quirks can prevent native extensions from compiling, breaking the whole stack before inference even begins.
Step-by-Step Fixes
Work through these in order. Skipping ahead tends to mask the real problem.
- Verify your macOS and Xcode tools are current. Open System Settings, go to General, then Software Update. Install any pending macOS update. Then run xcode-select –install in Terminal and accept the license with sudo xcodebuild -license accept. Many native build failures trace back to stale Command Line Tools.
- Use a clean Python environment. Do not install Apertus dependencies into the system Python. Install Miniforge or use uv to create an isolated environment. A typical setup: python3 -m venv ~/apertus-env, then source ~/apertus-env/bin/activate. This eliminates the most common cause of dependency conflicts on macOS.
- Install the correct PyTorch build. Run pip install –upgrade torch torchvision. Confirm MPS is detected by running a short Python check: import torch; print(torch.backends.mps.is_available()). If it returns False, your PyTorch wheel is wrong for your architecture.
- Pick a model size that fits your RAM. On a 16 GB Mac, stick to the smallest Apertus variant or a quantised GGUF version. On 32 GB, mid-size variants are workable. Anything above that needs 64 GB or more of unified memory for comfortable inference. Quantisation to 4-bit dramatically reduces footprint with modest quality loss.
- Download model weights with resumable tooling. Use huggingface-cli download with the –resume-download flag rather than letting a Python script pull weights mid-execution. If a shard fails, delete that specific file from ~/.cache/huggingface/hub and re-run the command.
- Prefer MLX over PyTorch where possible. Apple’s MLX framework is built specifically for Apple Silicon and handles Apertus-class models more efficiently than PyTorch MPS. Install with pip install mlx mlx-lm, then load Apertus through mlx_lm.load. Memory usage typically drops by 30 to 50 percent.
- Disable VPNs and proxies during download. Several users in the Apple Support Community reported that corporate VPNs and certain consumer privacy tools corrupt large shard downloads. Toggle them off, redownload, and re-enable afterwards.
- Test inference with a minimal prompt first. Before running long generations, send a single short prompt. If that succeeds, gradually increase context length. Crashes on long contexts usually mean you have run out of unified memory and need a smaller quantisation.
Additional Solutions
If the ordered fixes above do not resolve the issue, several adjacent tweaks often help.
Increase the GPU memory ceiling. macOS sets a default cap on how much unified memory a single process may allocate to the GPU. You can raise it for the current session with sudo sysctl iogpu.wired_limit_mb=24576 (adjust the number to suit your machine). Do not exceed roughly 75 percent of total RAM, and remember the setting resets on reboot.
Switch to the GGUF format and run Apertus through llama.cpp. Use a recent build (compiled with Metal support via LLAMA_METAL=1) so the custom tokenizer is recognised. This route avoids Python entirely and tends to be the most stable option for older Macs.
Monitor with Activity Monitor’s Memory tab while loading the model. If memory pressure turns yellow or red before generation begins, the model is too large for your hardware regardless of which framework you use.
Clear the Hugging Face cache if you suspect corruption: delete ~/.cache/huggingface entirely and start fresh. This is heavy-handed but resolves stubborn integrity failures.
Disable Spotlight indexing on your model directory. Add the folder to Spotlight’s Privacy list in System Settings. Indexing multi-gigabyte weight files burns CPU and can interfere with active reads.
When to Contact Apple Support
Apertus itself is third-party software, so Apple Support will not debug your Python stack. However, contact Apple if you encounter kernel panics that survive a clean reinstall of the model tooling, if Metal-level errors appear in Console even when no AI workload is running, or if your Mac reports hardware faults under memory diagnostics. These point to issues Apple can address through service or a hardware repair.
For the Apertus model itself, raise issues on the project’s official repository on Hugging Face or its public issue tracker. For PyTorch MPS bugs, the PyTorch GitHub repository is the right venue. Apple’s developer forums are useful for MLX-specific questions.
FAQ
Can I run Apertus on an Intel Mac? Technically yes through CPU-only inference, but performance will be extremely poor. The model is realistically usable only on Apple Silicon.
How much disk space do I need? Reserve at least 60 GB free for full-precision weights, or roughly 20 GB for a 4-bit quantised version. Add headroom for the cache and temporary files.
Why does inference work briefly then crash? Almost always a memory ceiling problem. Either the context grew too long or the model exceeded available unified memory. Drop to a smaller quantisation.
Is Apertus safe to run locally? The weights are open and the model runs entirely offline once downloaded. No prompts leave your Mac.
Will future macOS updates improve this? Likely yes. Each macOS release expands MPS operation coverage, and MLX is actively developed by Apple. Expect smoother Apertus support over time.
