You’ve been told your Mac apps belong to Apple. That’s a lie. The only thing stopping your macOS binary from running on a Linux machine is a thin layer of abstraction—and a lot of stubbornness. Now, a project called Kakehashi has proven that the wall between these two worlds is made of glass, not steel.
Kakehashi is an experimental userspace layer that runs macOS CLI binaries natively on Linux ARM hardware. It’s not an emulator. It doesn’t translate instructions. It simply bridges the gap between macOS’s system libraries and Linux’s kernel at the userspace level. The result? A 7-Zip binary compiled for macOS runs on Linux—and passes multi-threaded compression tests on an 8k-file tree. The only catch: it’s about 5.2x slower than native Linux execution.
But here’s the twist you’re not supposed to see: The 5.2x slowdown isn’t the story. The story is that it works at all. The moment you realize that a macOS binary can execute on Linux—on identical ARM hardware—you’re forced to confront a deeply uncomfortable truth for every platform vendor: the operating system is becoming an interchangeable compatibility layer, not a fortress.
Think about what this means. The hardware underneath is the same. The ARM architecture doesn’t care whether you’re running macOS, Linux, or something else. What matters is the software stack sitting on top. And if we can abstract that stack away—if we can build a compatibility layer that translates one set of APIs into another—then the entire concept of platform lock-in starts to crack.
Of course, the performance penalty is real. 5.2x overhead is a lot. But it’s a proof of concept, not a final product. The first time someone got Linux to run on a MacBook, it was slow and clunky. Now it’s a daily driver for millions. The trajectory is more important than the starting point. Kakehashi shows that the gap is bridgeable, and bridges get shorter with every iteration.
This isn’t just a technical curiosity—it’s a direct challenge to the walled gardens that Apple, Microsoft, and Google have built. The hacker ethos that drove this project is the same one that gave us Wine, Proton, and countless other compatibility layers. It’s the belief that your software should run where you want it, not where a corporation tells you it can run.
So what’s the endgame? Total decoupling of software from operating systems. Imagine a future where you buy a piece of software—a single binary, a universal executable—and it runs on any hardware, under any OS, because the OS is just a thin shim that provides basic services. That’s not a pipe dream. It’s the logical conclusion of work like Kakehashi. And it’s exactly what companies like Apple are terrified of.
The war on platform lock-in just got a new weapon. And it’s not going away.
FAQ
Q: But it's 5x slower, so what's the point?
A: The point is that it works at all. Performance overhead is expected in early-stage projects—just like the first Linux-on-Mac prototypes were unusable. The existence of a working compatibility layer proves the concept is viable, and optimizations will shrink the gap over time.
Q: How does this affect me as a regular user?
A: Right now, it's a proof of concept for developers. But in the long run, it signals a future where you can run any application on any operating system, breaking the lock-in that forces you to choose between Apple, Microsoft, or Linux ecosystems. Your software choices become independent of your hardware choices.
Q: Isn't this just a toy? Won't Apple patch it?
A: It's a toy today, but so was Wine in its early days. Apple can't 'patch' a userspace compatibility layer that doesn't rely on kernel exploits—it's a legitimate translation of system calls. The real barrier is legal, not technical. The project's existence challenges the assumption that OS lock-in is inevitable, and that's a powerful idea.