![[personal profile]](https://www.dreamwidth.org/img/silk/identity/user.png){kind=small}
liam_on_linuxThe excellent LowEndMac website for users of vintage Apple kit has a thriving FB community, which is full of the sort of people who recommend that whatever your vintage Mac, you crack its firmware and run the latest OS on it. As an example they got very excited recently because someone found a leaked beta of Mac OS X 10.6 for PowerPC. 10.6 "Snow Leopard" was the first Intel-x86-only release of OS X. This was apparently a late decision and 10.6.0 did have an unfinished version that ran on the older PowerPC chip.
These guys -- and they are almost all guys -- would rather run an unstable beta of a newer OS than the stable, patched version of 10.5 with its plethora of stable, supported PowerPC apps.
Currently, they're getting very excited about the new ARM Macs and excitedly telling one another about how fast they are and how Rosetta 2 can magically translate any x86-64 app into a full native ARM app and how the M1 is a system-on-a-chip and therefore the RAM is built in to the processor and so is much faster than boring external RAM. (The RAM is DDR4 in a separate die -- just a single die, which is possibly a bad sign bandwidth-wise -- that is in in the same physical package as the SoC, like a Pentium II's L2 cache was.)
They're also under the impression that Rosetta 2 will magically allow Windows 10 in a VM, like on current Macs.
I tried to answer...
Apple has used 4 CPU architectures so far:
[1] Motorola 680x0
[2] AIM PowerPC
[3] Intel x86-32 and then x86-64
[4] ARM
In each case it's provided some kind of emulation for the generation immediately before which can run some, individual programs from the old architecture.
A hypervisor is not just "a program". A hypervisor splits up a CPU into multiple instances, each of which can run a separate OS.
An ARM hypervisor can virtualise multiple ARMs. An x86 hypervisor can virtualise multiple x86.
But you can't just run a hypervisor through a translation tool such as Rosetta. It interacts with the host CPU and the guest OSes and the programs on them run on that host CPU too.
If I give you a copy of a very long book, such as The Lord of the Rings, and a very big very complete English-to-Chinese dictionary, you could given enough time produce something that was kind of like the LotR in something like Chinese, but it will never be as good as a translation by a Chinese native who speaks English.
In the same way, a translated app will never be as good as a native app.
But given that super-complete Chinese dictionary, you look up English words and phrases and it gives you some characters to write down. You can't read them if you don't speak Chinese.
So if a Chinese person came up to you and said "你好！ 你吃了吗？" ... then that fancy dictionary isn't going to help you. It's a English to Chinese dictionary and unless you can read Chinese, then even a Chinese to English dictionary won't help you.
You can do a not-very-good one-time one-way translation, but you can't translate in both directions. You can't interact in Chinese.
Apps inside Parallels are x86 apps that run on an x86 chip, and that runs on an x86 OS, which interacts with the hypervisor which interacts with the processor.
TechRadar's article carefully says that they demonstrated Linux. Linux is cross-platform. Linux runs on ARM. They could run ARM Linux in an ARM VM under ARM Parallels on ARM macOS and it will work fine, and fast too -- because it's all-native -- making for a great demo.
If they're cheeky they can do this with ARM Win10 as well and it will look good, but it won't run native MS Office because there's no such product.
If you get the fancy ARM Windows supplied with ARM tablets that can emulate x86-32, you will get MS Office for x86 running on an emulator. That is 1 level of emulation: the OS is native, but the app is translated.
There are ARM versions of Windows these days but they are limited, heavily locked-down things. One version is only available preinstalled on ARM tablets. It's like MS-DOS in the v1-v4 era: it's not a retail product. The only way to get it is to buy a computer running it, and it's hardware-locked to the firmware device it came with, like a phone OS.
Another version of ARM Windows 10 is a special "Internet of Things" edition of Windows 10 – it doesn't have a desktop and so on. This runs on a Raspberry Pi, but it's intended to run on a smart doorbell, not a full-function personal computer. Of course people have found a way to hack it to get a full desktop, but it's not trivial, it's not supported, and there are very few ARM Windows apps out there -- just a few FOSS things that have been recompiled.
So: you can't just buy full desktop Windows for ARM and run it on an ARM VM as you can with x86 Windows. Table ARM Win10 does do it own internal x86-32 emulation -- just as RISC Windows NT on MIPS, POWER, Alpha and so on emulated x86-16 in the 1990s. But there's no x86-64 just yet, and anyway, running any performance-critical app in emulation is undesirable. Running an entire VM in one would be nasty.
Emulation is sluggish but it'll do for stuff that is not performance-critical. OK for MS Word, not desirable for MS Excel if you're working with big complicated databases.
And if you want to run x86 Windows then you can't virtualise that on ARM, because an ARM chip can't run x86 instructions.
So ARM Macs mean saying goodbye to running x86 Windows in a VM. (And x86 Linux, but who cares? You can run ARM Linux and ARM Linux has all the FOSS apps from x86 Linux -- but no x86 games or other proprietary apps.)
So you have to emulate x86.
Rosetta 2 can't help you here. It can't "see" into a VM. It doesn't know what OS is inside the VM and what apps are on that OS, so it can't translate them.
So it has to emulate the whole thing.
It works, but it's slow. You take your fast elegant ARM chip and emulate a huge complex x86 chip with 10x as many transistors, and it will work, but it's not quick.
Anyone old enough to have run Insignia SoftWindows or SoftPC on a PowerMac under MacOS 7/8/9 in the mid-1990s has tried this. It works but it's not elegant and it's not fast.
But I personally have been using ARM computers since 1988 or so, when I bought an Acorn Archimedes. It had an 8MHz ARM2 chip. Native software was blindingly fast: it was about 4-8x faster than the fastest x86 box my employers sold, an IBM with a 80386DX chip running at 25MHz with secondary cache.
Note those numbers. An 8MHz ARM running ARM code was at least 4x faster than a 25MHz 386 running 386 code. That is how much more efficient than x86 ARM can be.
I had a program called !PCEm on my Arc. It was a complete PC emulator and it could run MS-DOS 3.3 and PC apps such as Lotus 1-2-3, MS Word for DOS and QuickBASIC. I used it for some work.
The original IBM PC ran at 4.77 MHz. These days, 4.77 GHz is just about possible. A thousand times faster.
But my Arc emulating an x86 chip ran at about 2MHz.
An ARM chip that was some 4x faster running ARM code was well over 10x slower running x86 code -- more like 15-20x slower.
This stuff is not new. I was running x86 code on ARM before IBM and Motorola invented the first PowerPC chip.
It works. It can be usable. But you lose all the high-performance of your ARM chip, and it works flat out, running hot, burning power, to give mediocre x86 performance.
So yes, some x86-64 native macOS apps will run usably on ARM, because the whole OS isn't being emulated -- 1 translated app is being run.
But that doesn't apply to running Windows, or running a hypervisor.
They can probably make it work and run x86 Windows on ARM Macs, but don't expect it to be as fast as running x86 Windows on an x86 Mac, where under BootCamp it runs at full native speed and in Parallels or whatever it runs 10-15% slower.
