UTM: An Apple hypervisor with some unique extra abilities

Friday FOSS Fest UTM is a handy hypervisor for Macs and Apple fondleslabs, but it’s more than just that. It has some very particular skills. We are quite taken with it.

UTM is a desktop hypervisor for Apple kit – notably for Macs with macOS 11 or later, but it also supports some iOS devices too. (Sadly, The Reg FOSS desk has none new or powerful enough to give this a try.) It supports both x86-64 and Apple Silicon based Macs, but it can do more than most other hypervisors. Judging from the Alan Turing quotation on its Github page, we think that the name stands for Universal Turing Machine.

Among other things, UTM can act as a front-end to Apple’s built-in hypervisor, a feature in macOS 10.10 or above, called simply Hypervisor. In its own right, the Apple hypervisor offers some useful facilities: for instance, it enables Linux VMs to call Rosetta 2 for very fast x86-64 to Arm64 translation. However, UTM supports other forms of virtualization as well.

The Arm64 edition of Debian running on an Intel-based iMac is much easier to achieve with UTM than it is with unassisted QEMU.

The Arm64 edition of Debian running on an Intel-based iMac is much easier to achieve with UTM than it is with unassisted QEMU (click to enlarge)

There’s already a choice of desktop hypervisors for Macs, of course: VMware Fusion, Parallels Desktop, and of course the cross-platform VirtualBox. Most are available in native versions for Apple Silicon Macs, too – but as with any standard hypervisor, what they do is run virtual machines of the same CPU type as the underlying host machine. So, for instance, Parallels’ knowledge base carefully explains that it can only run Windows for Arm on Apple Silicon Macs.

This is standard behavior for a hypervisor: they virtualize the underlying hardware, so VMs get the same type of CPU as the host. So, if you run an x86-64 hypervisor on x86-64, it can only run x86-64 guests, and if you run an Arm hypervisor on Arm, it can only run Arm guests.

This is where UTM is different. As well as the Apple hypervisor, it also supports the open source QEMU by French low-level programming überboffin Fabrice Bellard.

QEMU is an unusual and complex tool, able to operate in several different ways, which means that it is often misunderstood. QEMU is able to act as a whole-system emulator, running software for one CPU family on a totally different CPU. In order to do this, it has tools for creating and managing emulated hard disk drives, graphics and network cards and so on: all the virtual hardware that the emulated system needs to run.

However, where it gets confusing is that ever since version 2.6.20 back in 2007, the Linux kernel has its own built-in KVM hypervisor, which in turn uses the hardware virtualization facilities in all modern Intel and AMD chips, as the Reg FOSS Desk covered in painstaking detail back in 2011. But all that KVM can do is talk to the CPU’s built-in facilities that start and stop virtualized instances. KVM on its own has no ability to define virtual disk drives, or graphics adaptors, or any of that.

That is where QEMU comes in. It’s widely used in most Linux distros to provide this supplementary front-end scaffolding: to create, provide and manage all the additional hardware for VMs. Essentially, the Linux kernel provides the CPU, and QEMU does the rest. In this mode, QEMU does no processor emulation at all: the OS is providing that, meaning that the guest code runs at close to native speed on the real underlying CPU. Rather less well known is that it can do the same on macOS.

This is where the misunderstanding of QEMU comes from. It can work both as a full-system emulator and as a type 2 hypervisor with the help of a kernel and CPU that provide the relevant functionality.

UTM wraps a friendly GUI around two different hypervisors, one of them able to run in two different modes. It can use the Apple hypervisor directly, virtualizing your underlying Intel or Apple Silicon CPU, but as well as that, it can also use QEMU, either as a hypervisor for native-speed virtualization, but also, in emulation mode.

UTM running both classic MacOS and Solaris on an M1 MacBook Air under Sonoma.

UTM running both classic MacOS and Solaris on an M1 MacBook Air under Sonoma (click to enlarge)

This means that UTM can run an x86 guest on Apple Silicon, or it can run an Arm64 guest on an Intel Mac. And it’s not limited to Arm and x86: it can run a PowerPC or SPARC VM on both Intel and Arm64 Macs, as well.

To test this, we downloaded a MacOS 9.2.2 universal install ISO file from MacOS9Lives, chose a PowerPC VM, and a few minutes later we were deeply impressed to be running Classic under macOS Ventura. We also installed the Arm64 edition of Debian 12 on a Core i7 iMac.

If you don’t want to configure your own VM, UTM offers a gallery of pre-built guest images, and in testing, we’ve successfully run the PowerPC-native Classic MacOS 9.2.1 on both M1 and Core i7 Macs. We also got the SPARC version of Sun Solaris 9 running on both machines, too.

Emulation is nowhere near as fast as true virtualization: the SPARC VM was not exactly snappy, but it’s usable. However, even an eight-year-old Core i7 is substantially faster than the fastest Macs able to natively boot MacOS 9, and MacOS 9 requires just 40MB of RAM and ran well on 233MHz G3 Macs: it’s not a demanding OS by 21st century standards.

This isn’t the same thing as Classic Mode in Mac OS X 10.0 through to 10.4: there’s little integration between the host and guest OS, and you must work out for yourself how to move files between them. Even so, we were very impressed how easy UTM makes it go get this feat of emulation working.

We also tested the Fedora 39 beta in UTM, and it ran more smoothly than under VirtualBox – doubtless because Fedora’s native hypervisor, GNOME Boxes, uses the same underlying QEMU tooling.

Even if you don't want all the emulation stuff, it's a perfectly serviceable x86-on-x86 hypervisor, here running the latest Fedora beta.

Even if you don’t want all the emulation stuff, it’s a perfectly serviceable x86-on-x86 hypervisor, here running the latest Fedora beta (click to enlarge)

Running entire x86-64 OSes on our M1 MacBook Air was less impressive: Rosetta 2 does app-by-app translation, and it can’t help with full-system emulation. Performance of the guest OS was a little sluggish, but bearable: you could tolerate it for modest use.

It reminded this vulture strongly of using Acorn’s !PCEm [PDF] software PC emulator on the original ARM desktop computer, the Acorn Archimedes, under RISC OS in the late 1980s. While you’d always prefer to use native software if it’s available, it was very impressive that an 8MHz ARM2 had the raw horsepower to completely emulate an x86 PC at usable speed. It was impressive an ARM computer could emulate a sub-5MHz XT-class IBM compatible with 640 kB of RAM 35 years ago, and it’s just as impressive it can emulate a 64-bit multi-core PC with 4GB of RAM today.

UTM is a free download from Github, but if you get it from Apple’s macOS App Store, it costs $9.99, which helps to fund the program’s development. ®


This website uses cookies. By continuing to use this site, you accept our use of cookies.