Your Mac has a hidden AI chip. Developers are finally unlocking it.

Every Apple silicon Mac ships with a dedicated AI processor that most owners, and most developers, have never properly used. Independent researchers have now measured what it can really do, and in June, Apple announced it is finally opening the chip up properly.

Section 01What the Neural Engine actually is

The Neural Engine (often shortened to ANE) is a processor built into every piece of Apple silicon, designed to handle one thing: the mathematics behind AI. Not general computing, not graphics. Just AI, done as fast and efficiently as possible.

It wasn't born out of an AI strategy. It was born out of a camera problem. Around 2017, Apple's camera team was using neural networks to push photo quality beyond what traditional image processing could manage: separating subjects from backgrounds, portrait lighting, real-time enhancement. The catch was that running those calculations continuously on a CPU or GPU would flatten an iPhone battery in short order. So the camera team asked the chip engineers for something new.

The result first appeared in the A11 Bionic chip in 2017, and its launch feature was Face ID, something hundreds of millions of people now use every day without a second thought. Apple's own engineers told AppleInsider at the time that they "couldn't have done it (Face ID) properly without the neural engine". From that point it quietly spread into nearly everything: autocorrect, voice recognition, camera processing, on-device Siri. Most users have no idea it exists, let alone that it's working constantly in the background.

Under the bonnet, the Neural Engine isn't a small GPU. It's what engineers call a graph execution engine: you hand it a complete, pre-compiled description of an AI calculation, and it runs the whole thing in one go. That design is what makes it so efficient, and, as we'll see, it's also what made it so hard to reach.

Section 02The CoreML toll booth

To use the Neural Engine, Apple requires every developer to go through a framework called CoreML, a layer of software that sits between an app and the hardware. Rather than talking to the chip directly, you submit a request and CoreML decides how to handle it, distributing work across the CPU, GPU and Neural Engine as it sees fit.

The intention is sound: it keeps things simple and safe, and for most apps it works well. But convenience has a cost. CoreML adds extra steps (scheduling, translation, housekeeping) between your application and the chip doing the actual work. For big, long-running AI jobs that overhead barely registers. For small, rapid-fire operations, exactly the kind that matter in real-time applications, it can dominate.

For years, most developers accepted this as simply how Apple silicon worked. CoreML was the only documented door in, so CoreML was what you used.

One developer went looking for another door.

Section 03How someone found a way in

In early 2026, an independent developer named Manjeet Singh, publishing under the name Maderix and working openly in collaboration with an AI assistant, started, by his own account, simply by poking at the private software on an M4 Mac mini he'd picked up. The question that emerged was simple: what was actually underneath CoreML?

By studying the software Apple ships inside macOS and watching how CoreML behaved while running, he found something Apple had never publicly documented: the set of internal frameworks CoreML itself uses to talk to the Neural Engine. A staff entrance, effectively, that had never been put on the map. From there it was detective work: running models repeatedly, tweaking inputs, watching which internal components responded, until a picture emerged of the hidden machinery beneath CoreML, and with it a way to schedule work on the chip directly.

A small community of researchers had poked at the Neural Engine's internals before, and Maderix credits their work openly. But nobody had previously achieved direct access on the M4 without CoreML, measured the chip's true peak with the overhead stripped away, or trained a model on it. All of the code was published openly on GitHub, and other developers began building on it within days.

One important caveat before we get to the results: this all relies on private, undocumented Apple software. Apple doesn't support it, could change or break it in any macOS update, and apps using these techniques can't be distributed through the App Store. This is research, not a product, but it's research that tells us something real about the hardware.

Section 04What the measurements showed

The first thing to test was whether Apple's headline number held up. Apple markets the M4 Neural Engine as delivering 38 TOPS, trillions of operations per second. That figure follows an industry-wide convention: chipmakers quote AI performance using a cheaper type of calculation (INT8) that is assumed to run twice as fast as the standard one (FP16). On most AI chips it does. On the Neural Engine, the benchmarks show, it doesn't work that way: the chip converts the cheaper format back to standard precision before doing the actual maths, so INT8 buys no extra calculating speed. What it does save is memory: smaller numbers are quicker to shuttle around. Hold onto that distinction between calculating and moving data: it explains a twist we found later, in Section 05.

Strip the convention away and the measured peak is 19 TFLOPS, half the headline figure. To be fair to the hardware: 19 TFLOPS is essentially 100% of the chip's theoretical FP16 rate, so the silicon is doing exactly what it was built to do. It's the counting convention, not the chip underperforming, that makes the headline look twice the FP16 figure, and Apple is far from alone in the industry in quoting numbers this way.

The second finding was the CoreML overhead itself. Running identical operations through CoreML and then directly, the difference was stark: for smaller, time-sensitive operations, CoreML added 2–4× to the total time. The gap narrows on big workloads where the chip's compute time dominates, but for latency-sensitive work, the responsiveness you feel in real-time AI applications, that's performance developers have been unknowingly leaving on the table for years.

The third finding is the one that matters most, and it's unambiguously good news: efficiency.

At idle, the Neural Engine draws exactly zero watts: it doesn't just slow down when unused, it switches off completely. Running flat out, it delivers around 6.6 TFLOPS per watt of electricity. Nvidia's A100 data-centre GPU manages roughly 0.08 TFLOPS per watt. Per unit of AI work, the chip inside a Mac mini is about 80 times more power-efficient than the hardware running much of the world's AI infrastructure.

The honest caveat, which the researchers themselves make: an A100 has roughly 50 times the total throughput. If you need raw speed, the data centre still wins comfortably. But for AI running on your desk or off a battery, efficiency per watt is the metric that matters, and there, the Neural Engine is exceptional.

Section 05We ran it ourselves, across the whole family

Everything above was measured on a single M4. That left an obvious question hanging over the refurbished machines we sell every day: how does the rest of the family compare? So we got hold of Macs spanning every Apple silicon generation (M1, M2, M3, M4 and M5) and ran Maderix's own benchmark on each one. No new method: the same deep convolution that saturates the Neural Engine, paired with Apple's powermetrics to read its wattage, five runs per chip, averaged.

Two things stood out.

First, raw speed climbs steadily with each generation, from about 11 TFLOPS on the M1 to 19 on the M5. No surprise there, and reassuring: these throughput figures are timing-based and tightly reproducible. The M3 landed between 18.58 and 18.60 across all five runs; the M5 between 19.28 and 19.32.

Second, and more interesting: efficiency doesn't follow the same line. The humble M1 turned out to be the most power-efficient of the lot, and the M2 the least, a reminder that a newer chip isn't automatically a more efficient one. The M4 is where two things changed at once. It became markedly more efficient, the benefit of a smaller manufacturing process, and it was the first chip fast enough for INT8's lighter data to turn into real extra throughput, about 1.9×, rather than just lower power.

At first glance this looks like it contradicts Section 04, but it's the other half of the same story. Remember the distinction from earlier: INT8's only benefit is moving less data, not doing the maths any faster. On the slower M1, M2 and M3, the Neural Engine is limited by raw calculating speed, so lighter data changes nothing and INT8 matches FP16 exactly, just at lower power. On the faster M4 and M5, the chip is quick enough that moving data becomes the bottleneck instead, and there INT8's smaller footprint pays off: a real ~1.9× gain, 35 TOPS on the M4 and 36 on the M5. It's the same memory saving Maderix identified (not a separate, faster INT8 engine) showing up only on the chips fast enough to feel it. One honest wrinkle: Maderix's own M4 runs, made months earlier on the older macOS and an earlier version of the benchmark, showed no INT8 gain at all, so we can't rule out that Apple's newer compiler also handles INT8's packed data better than the old one did. The gain is real and repeatable on our machines; the exact mechanism is our best reading of the evidence, not a settled fact. Read that way, the M4's INT8 result lands close to Apple's "38 TOPS": for that chip the headline number is largely real, just reached through memory bandwidth rather than a dedicated INT8 core.

One honest note on method, in the same spirit as the caveat above. The wattage, and so the efficiency ranking, comes from Apple's own powermetrics, which reports Neural Engine power as an estimate and explicitly warns against comparing those estimates between different devices. The large swing between the M1 and M2 readings is exactly where that estimate is least reliable. So treat the per-watt ranking as a strong indication, not a lab-grade measurement. The throughput column carries no such caveat: it's measured from the clock, and we trust it completely. We're publishing every per-run figure so you can judge for yourself.

One number to reconcile before we move on: our own M4 came out at 5.97 TFLOPS per watt, not the 6.6 shown back in Figure 1. The throughput matched, our 18.64 TFLOPS against the 18.6 his repository reports for this exact benchmark (the 19 TFLOPS quoted earlier is his absolute peak, from a slightly different configuration), so the gap is entirely in the power reading: our steady-state figure was 3.1 watts against his 2.8. Different machine, a different day, and the same estimate-tool caveat we've just described. We've kept both numbers on the page rather than quietly averaging them away.

Section 06The thing Apple's tools say you can't do

Running an AI model on the Neural Engine is one thing. Training one, teaching it from scratch rather than using a model someone else built, is something else entirely. Running a model is like following a recipe. Training one is like writing the recipe through thousands of rounds of trial and error: make a guess, measure how wrong it was, adjust, repeat. The Neural Engine was only ever designed for the first part, and Apple's tools offer no way to attempt the second.

Getting it to work meant solving problems Apple never intended anyone to solve. The chip does its maths at a lower precision than training normally demands, so the tiny corrective signals a model learns from were being rounded down to zero: the model appeared to be training while learning nothing at all. Deeper networks saw their numbers spiral out of control. Each fix revealed another problem underneath it.

Eventually it came together. A 109-million-parameter model, comparable in scale to the very first version of GPT, trained from scratch, on the Neural Engine, in around 1.3 hours. By the end it was generating coherent children's stories. The technique has since been scaled to a 596-million-parameter open-source model.

The power figure deserves the emphasis. Throughout training, the Neural Engine drew 2.8 watts. Training the same model on the M4's own CPU cores would draw 15–20 watts for similar speed. As the researchers themselves put it, the chip wins on watts, not speed: a data-centre GPU would finish far faster, but nothing else finishes on this little electricity, on hardware already sitting inside a standard Mac.

Section 07What developers built with it

The work didn't stay theoretical for long. With the code published openly, other developers picked it up within days. One contributor built a hybrid inference engine that runs a 2-billion-parameter language model at 32 tokens per second, roughly 25 words, fast enough for genuinely real-time use. Another built an AI music synthesiser that runs 79 times faster than real time, entirely on the Neural Engine. These were working tools within weeks, doing things Apple's own frameworks couldn't get close to.

None of this is production software, and the usual caveats apply: private interfaces, no Apple support, and every macOS update carries the risk of breaking it. But that's not really the point. In any platform's life there's a moment when the developers who understand the hardware deepest start building things others simply can't. For the Neural Engine, that moment is now.

Section 08Then Apple opened the door

Three months after that research went public, Apple moved. At WWDC26 in June, it announced Core AI, described by Apple as a brand-new framework designed to be the best way to run models on device, built around the unified memory and Neural Engine of Apple silicon. It is the official successor to CoreML for modern AI work: developers can bring their own models over from standard tools, run them across the CPU, GPU and Neural Engine under one interface, and, for the first time, get fine-grained control over how inference runs, with proper profiling and debugging tools alongside. It's capable of running full-scale language models locally, from compact 3-billion-parameter models up to 70-billion-parameter ones on machines with enough memory. CoreML doesn't disappear; it stays on for classic machine-learning workloads, while Core AI takes the forward path.

To be clear about the timing: frameworks of this size take years to build, and a major CoreML successor had been rumoured before any of this research was published. Nobody should read Core AI as Apple responding to one developer's GitHub repository. But the sequence is still striking: in March, the community measured what the chip could do and showed what Apple's software was leaving on the table; in June, Apple announced official, supported, deeper access. Whatever the internal history, both were pulling in the same direction.

The honest caveats still apply. Core AI is in developer beta now and doesn't reach ordinary users until the next macOS ships in the autumn. It remains focused on running models: training on the Neural Engine, the most striking thing the community achieved, is still not something Apple supports. And the question this article's benchmarks raise, how much of that measured 2–4× overhead the new framework actually eliminates, can only be answered once it ships. That's a testable claim, and one worth returning to.

Section 09The bottom line

Every Mac and iPhone sold in the last several years contains AI hardware that most developers have never properly accessed. The software layer Apple built around it was well-intentioned, but it came at a cost, and that cost has now been measured: up to 4× overhead on the tasks where speed matters most, on a chip whose real strength is doing serious AI work on almost no electricity.

The hardware is already there, in millions of machines, and after years behind Apple's software, both the community and Apple itself are now opening it up. The question is no longer whether Macs get serious on-device AI. It's how quickly the software catches up with silicon that has been ready for years.