Apple Silicon has been a weird liminal space for ML practitioners. The hardware is genuinely impressive—unified memory, Neural Engine, actually competitive GPU compute—but the tooling has always felt like a second-class citizen. You could run models, sure, but it involved PyTorch MPS backends that felt perpetually half-baked, or you'd venture into Apple's MLX framework and realize you're now maintaining a parallel universe of model code.
That gap just got a lot smaller. Hugging Face shipped native MLX support in Transformers, and it's exactly the kind of "why didn't this exist already" feature that makes you wonder how we lived without it.
The headline: you can now run Transformers models on Apple Silicon via MLX with essentially zero code changes. Same APIs, same model hub, same everything—just faster and more memory-efficient on your MacBook.
Why MLX matters (and why it didn't matter enough)
MLX is Apple's answer to JAX—a NumPy-like framework designed specifically for Apple Silicon. It's actually quite good: lazy evaluation, automatic differentiation, unified memory model. The problem was always adoption. If you're training models, you're probably on CUDA. If you're doing inference, you might reach for MLX, but then you're rewriting model code and losing access to the Hugging Face ecosystem.
The Hugging Face Hub has become infrastructure. When someone says "I'm using Llama 3.2," they almost certainly mean they're pulling it from the Hub with transformers. The idea of maintaining a separate MLX implementation of every model you care about is... not appealing.
So models existed in MLX-land—there's a whole community converting weights and publishing MLX versions—but it was fragmented. You'd find mlx-community/Llama-3.2-3B-Instruct-4bit, and it would work great, but you're now in a parallel package ecosystem (mlx-lm instead of transformers), and every model needs manual conversion.
The integration that should have always existed
What Hugging Face shipped is elegantly simple: MLX is now a first-class backend in Transformers, sitting alongside PyTorch and TensorFlow. You instantiate a model, and if you're on Apple Silicon and have MLX installed, it just works.
The API is predictable if you've used Transformers before:
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-3.2-3B-Instruct",
device_map="mlx"
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B-Instruct")
That's it. Same model ID, same code structure, just device_map="mlx" instead of device_map="auto". Transformers handles the weight conversion and backend dispatch automatically.
What actually changed under the hood
This isn't just a thin wrapper. Hugging Face built actual MLX implementations of the core modeling code. If you look at the implementation, you'll find MLX-native model classes that mirror the PyTorch ones—same architecture, different backend.
The clever bit is the automatic conversion. When you call from_pretrained with an MLX device map, Transformers will:
- Download the PyTorch weights (or use cached ones)
- Convert them to MLX format on the fly
- Load the MLX model class
- Give you back something that looks and acts like a normal Transformers model
You can also save models in MLX format explicitly with save_pretrained, which means you can convert once and load fast on subsequent runs. The Hub supports MLX weights natively now, so you can publish and share MLX-native models directly.
The performance story
This wouldn't matter if MLX wasn't actually faster. But on Apple Silicon, it genuinely is—often significantly so.
MLX is optimized for unified memory architecture. Instead of copying tensors between CPU and GPU memory (which is what PyTorch MPS does), everything lives in shared memory. For inference on memory-bound workloads (which LLMs definitely are), this is a big deal.
The blog post doesn't include comprehensive benchmarks, but the MLX community has been reporting 2-3x speedups over PyTorch MPS for inference on M-series chips. Anecdotally, I've seen similar: a Llama 3.2 8B model that struggled at ~10 tok/s on MPS hits 25+ tok/s on MLX on an M3 Max.
Quantization support is also cleaner. MLX has native 4-bit and 8-bit quantization that's designed for the hardware. You can load quantized models directly, and the memory savings are real—running 70B models on a Mac Studio suddenly feels reasonable instead of theoretical.
What this means for the ecosystem
The immediate impact is obvious: if you're developing on a Mac, your workflow just got better. You're no longer choosing between "use the tools I know" and "get good performance."
But the longer-term effect is more interesting. Hugging Face is essentially declaring MLX a supported platform, which means:
- Model authors can target MLX without maintaining separate codebases
- The Hub becomes the distribution mechanism for MLX models
- Apple Silicon becomes a legitimate inference target, not an afterthought
This also puts gentle pressure on Apple. MLX is open source, but it's clearly Apple's baby. If it's now part of the standard Transformers stack, Apple has more incentive to keep it competitive and well-maintained.
The rough edges (because there always are)
This is a new integration, and it shows. Not every model architecture is supported yet—you'll find MLX implementations for the popular ones (Llama, Mistral, Qwen, Gemma), but if you're reaching for something obscure, you might be out of luck.
Training support is also limited. The initial release focuses on inference, which is probably the right call (most people aren't training on MacBooks), but if you wanted to do fine-tuning, you're still in PyTorch land.
And there's the usual Apple Silicon caveat: this only helps if you're on Apple Silicon. If you're on an M1 or newer, great. If you're still rocking an Intel Mac, this does nothing for you.
Why this feels significant
On one level, this is just plumbing. Backend support, weight conversion, API consistency—not exactly headline-grabbing stuff.
But it's the kind of plumbing that changes behavior. How many people have bounced off running models locally because getting PyTorch set up on a Mac was annoying, or performance was disappointing, or they didn't want to learn a new framework?
Hugging Face just removed a bunch of friction. If you have a recent MacBook, you can now pip install transformers mlx and be running state-of-the-art models at decent speeds with the same code you'd use anywhere else.
That's the kind of change that doesn't announce itself with benchmarks or architecture diagrams. It just quietly makes the thing you wanted to do possible, and you move on with your day.
The meta-lesson
The title of the blog post is "The PR you would have opened yourself," and that's exactly right. This isn't a moonshot feature. It's not research. It's just obvious, unglamorous infrastructure work that makes everyone's life slightly better.
The ML ecosystem needs more of this. We spend a lot of time arguing about which architecture is 0.3% better on MMLU, but we underinvest in making the tools actually work together. Hugging Face is good at this—the Hub, the transformers library, now MLX integration. They find the seams where things don't quite fit and smooth them out.
If you're on Apple Silicon and you've been curious about running models locally, this is your excuse to try it. Install MLX, pull down a model, and see what your laptop can actually do. You might be surprised.