When a teammate asks for a clean macOS install to test a release script, the quickest answer on an Apple silicon Mac is a VM in UTM. It is free, it restores macOS straight from Apple’s IPSW restore image, and a utm macos vm can run next to an Ubuntu ARM guest on the Mac you already use.
UTM puts two engines behind one window. Apple’s Virtualization framework runs macOS guests (and optionally Linux), and QEMU runs everything else. The engine decides how folder sharing, the clipboard and networking behave, which is where most of the confusion starts. This guide covers the UTM install, an IPSW restore, an Ubuntu ARM guest, shared folders and network modes. We ran every step in November 2026 on an M4 Mac mini host (an EC2 Mac instance) running macOS 27 with UTM 5.0.8, building a macOS 27.2 guest and an Ubuntu 26.04.1 LTS guest, and every screen below comes from that machine.
Checking what your Mac needs
A macOS guest only runs on Apple silicon, because Apple’s Virtualization framework is the only thing that can boot an ARM macOS kernel. Disk space is what catches most people out. The IPSW alone is about 25 GB, and the guest grows to roughly the same size once Setup Assistant finishes. Before you start, check the Mac has:
- An M-series chip and macOS 13 or later
- About 60 GB free per macOS guest, IPSW included
- Another 15 GB for an Ubuntu desktop guest
- 16 GB of RAM or more for an 8 GB guest
UTM itself starts at macOS 12, but shared folders in a macOS guest need macOS 13 on both sides, so treat 13 as the real floor. Those disk figures come from our host: the IPSW was 25.6 GB, the macOS guest used 28 GB after setup, and the Ubuntu ISO plus install took about 14 GB. Apple’s macOS licence allows two additional copies of macOS in virtual machines on a Mac you own, for development, testing or personal non-commercial use. The Virtualization framework enforces the same ceiling, so a third macOS guest will not start while two are running, although Linux guests do not count toward it. If you need more macOS instances than that, a CLI tool on dedicated hardware is the better fit, which is why our Mac mini buying guide for agent workloads leans toward higher-memory models.
Installing UTM
UTM is free from GitHub and getutm.app, and the same build sells for $9.99 on the Mac App Store, where the money funds the project and updates arrive automatically. Both builds have the same features, so we install the free one with Homebrew, which also links the utmctl command-line tool. If the Mac doesn’t have brew yet, install Homebrew first.
brew install --cask utm
Homebrew moves UTM.app into /Applications and links utmctl into the Homebrew prefix. It took 20 seconds on our host.

The first launch shows the usual “downloaded from the Internet” prompt. After you click Open, UTM lands on a What’s New sheet and then an empty library with a Create a New Virtual Machine tile. If all you want is a headless Ubuntu shell with no desktop, Multipass gets you there with less clicking. If you are still choosing a hypervisor, our guide on how UTM compares with Parallels and VMware Fusion covers the trade-offs.
Creating a macOS VM from an IPSW
UTM installs macOS by restoring an IPSW into a blank virtual disk, the same restore a technician runs on a real Mac. If you leave the IPSW field empty, UTM downloads the latest image Apple says your host supports, which is the safe default. We prefer to download the file once and keep it. A failed restore then costs a retry instead of another 25 GB download. Apple’s CDN serves the file directly, and ipsw.me lists the current URL for the VirtualMac2,1 model.
curl -L -o ~/Downloads/UniversalMac_27.2_26B123_Restore.ipsw https://updates.cdn-apple.com/2026FallFCS/c9671975-52db-4fb5-9af2-00217169ba8d/UniversalMac_27.2_26B123_Restore.ipsw # https://ipsw.me/VirtualMac2,1
Click the + button in UTM and choose Virtualize. Emulate runs other CPU architectures on QEMU’s software CPU, which is far slower, and macOS guests are only offered under Virtualize. The next page lists the guest types. The macOS 12+ entry only appears when the host supports macOS guests.

Pick macOS 12+ and work through the wizard. The hardware page defaults to 4 GB of memory, which boots but makes Xcode and Safari crawl. We gave the guest four cores and 8 GB, a third of the host’s RAM:
- Hardware: 8192 MiB memory, 4 CPU cores
- Import IPSW: click Browse and pick the file in ~/Downloads
- Storage: 64 GiB, more if the guest gets Xcode
- Summary: name the VM and click Save
The Import IPSW page is the one that matters. Once the file is selected, its name shows above the path field. That name is your only check that you picked the restore image and not a similarly named installer app.

The Summary page confirms the engine is Apple Virtualization and repeats the memory, cores and disk you chose. The Share Directory box is greyed out here for macOS guests. You add shared folders from the VM’s settings after it is created, which we do further down.

Press the play button on the new VM. UTM asks you to confirm that it may install macOS, then opens a window whose title bar counts the restore up as a percentage. Ours went from the confirm click to the guest’s Hello screen in seven minutes. Most of that was the restore itself, since the IPSW was already on local disk.

Setup Assistant in the guest is the same one a new Mac shows. Skip the Apple Account sign-in for a throwaway test VM, which keeps the VM off your account’s device list. We also declined FileVault. If your Mac uses FileVault, the VM’s disk image already sits on an encrypted volume, and a second layer in the guest only adds a password prompt at every boot. When the desktop loads, About This Mac reports an Apple Virtual Machine with a virtual M4 chip and the macOS build from the IPSW.

Our guest is a full macOS install with its own serial number, which we have hidden in the screenshot. It’s a good place to rehearse an upgrade before you touch your own Mac, and our notes on what macOS 27 broke for developers are a decent checklist to run inside it.
Installing an Ubuntu ARM VM
Ubuntu publishes an arm64 desktop ISO, and that is the image you want, because the amd64 one would force UTM into emulation. Download it and check the hash against Canonical’s SHA256SUMS before you build anything on it.
curl -L -o ~/Downloads/ubuntu-26.04.1-desktop-arm64.iso https://cdimage.ubuntu.com/releases/26.04/release/ubuntu-26.04.1-desktop-arm64.iso # https://cdimage.ubuntu.com/releases/26.04/release/
shasum -a 256 ~/Downloads/ubuntu-26.04.1-desktop-arm64.iso
Compare the digest with the ubuntu-26.04.1-desktop-arm64.iso line on the release page:
c54d196489d3c867975fb3bbb72ca52ec2e137456e305481f81096304e4d2517 /Users/mary/Downloads/ubuntu-26.04.1-desktop-arm64.iso
In the wizard, choose Virtualize, then Linux. UTM offers QEMU by default and labels Apple Virtualization as experimental. That is fair, since QEMU has more display options, USB passthrough and the SPICE tools. Our first Ubuntu VM used QEMU and booted the live session. Our test Mac was headless and driven over Screen Sharing, though, and the QEMU window stopped redrawing after we toggled full screen while the guest kept running and answered ping. Rebuilding it on Apple Virtualization fixed the display, and that is the VM the rest of this guide uses.
On a Mac with a real monitor attached, QEMU is the sensible default. Tick Use Apple Virtualization when you want the same virtiofs sharing and networking the macOS guest gets. The second mark below, Rosetta for x86_64 binaries, is optional and needs extra setup inside the guest, which UTM links from the same page. We left it off.

- 1Use Apple Virtualization
- 2Rosetta for x86_64 binaries
Browse under Boot ISO Image then picks the arm64 ISO you just verified. We gave the guest 4 GB, 4 cores and the default 64 GiB disk, and pointed the Shared Directory page at a host folder, ~/vm-share, so sharing was ready on first boot. The Ubuntu installer runs the same as on bare metal; with Erase disk and install Ubuntu, Default selection and no encryption, it took ten minutes from the Install click to the finished screen.

Click Restart now and press Enter at the prompt to remove the installation medium. The VM boots from its own disk to the GNOME login screen. If the guest window is cropped on a small display, Window, Fill in UTM’s menu bar resizes it to the screen.
Sharing folders and the clipboard
Both of our guests share a host folder over virtiofs, the Virtualization framework’s file-sharing device, so the host side is the same for each: a list of folders in the VM’s Sharing settings. QEMU guests use a different mechanism (VirtFS over 9p, or SPICE WebDAV), and UTM’s Linux guest docs cover those mounts. For a macOS guest, open the VM’s settings, choose Sharing and add the folder.

This step tripped us up. We first added the folder from the toolbar while the macOS guest was running, and nothing appeared inside it, neither a volume in Finder nor anything to mount by hand. The share only showed up after a full guest shutdown and start, when macOS mounted it automatically. Restart the guest after adding a folder, then check from Terminal inside the VM.
mount | grep -i virtio
cat "/Volumes/My Shared Files/vm-share/host-note.txt"
The share mounts as an AppleVirtIOFS volume called My Shared Files, with one subfolder per shared directory, so the host’s ~/vm-share shows up as /Volumes/My Shared Files/vm-share:
/dev/disk0 on /Volumes/My Shared Files (AppleVirtIOFS, local, nodev, nosuid, automounted)
hello from the host, 27.0
That “hello from the host” line is a file we created on the Mac before starting the guest, so the share is live in both directions. The guest’s Terminal shows the same checks plus its network address, which comes up again in the next section.

Ubuntu does not mount the share on its own. These commands need the Apple Virtualization backend, since a QEMU guest shares over 9p instead and this mount fails there. The device always carries the tag share, so create a mount point and mount it with the virtiofs driver from the stock Ubuntu kernel.
sudo mkdir -p /mnt/utm
sudo mount -t virtiofs share /mnt/utm
findmnt /mnt/utm
A successful mount shows the share source with the virtiofs type and read-write options:
TARGET SOURCE FSTYPE OPTIONS
/mnt/utm share virtiofs rw,relatime
Writing from the guest works without any UID mapping on the Apple backend. Each host folder appears as a subfolder of the mount point, so ~/vm-share is /mnt/utm/vm-share. We wrote a file there as the guest user and it was created without permission errors, and a file made on the Mac showed up in the guest listing owned by the guest user. The QEMU backend’s 9p share is the one that needs the bindfs remapping UTM documents. That is another small reason to pick Apple Virtualization for a dev box.

To mount it at every boot, add an fstab line. The nofail option matters here. Without it, a VM started with the share removed from its settings drops to an emergency shell instead of the desktop.
echo "share /mnt/utm virtiofs rw,nofail 0 0" | sudo tee -a /etc/fstab
sudo systemctl daemon-reload
sudo mount -a
We rebooted the guest to prove it, then checked the uptime and the mount from a fresh terminal:
uptime -p; findmnt /mnt/utm
Five minutes after boot, the share was back without anyone touching it:
up 5 minutes
TARGET SOURCE FSTYPE OPTIONS
/mnt/utm share virtiofs rw,relatime
The clipboard is a separate feature with its own requirements. According to UTM’s macOS guest docs, a macOS guest needs macOS 15 or later on both host and guest, Enable Clipboard Sharing under the VM’s Virtualization settings, and UTM’s guest tools installed from the toolbar’s CD button. Linux guests need the spice-vdagent package in the guest, on either backend. We didn’t install either for this guide, so treat those as UTM’s documented requirements rather than something we measured.
Choosing a network mode
Leave new VMs on Shared Network unless you have a reason not to. It puts the guest on a private subnet the Mac routes to the internet. Host and guest reach each other with no port forwarding, which covers SSH into a Linux guest and a dev server inside it. The Network page in a VM’s settings is where you change it.

On our host, both Apple Virtualization guests got DHCP addresses on Shared Network: the macOS guest drew 192.168.65.3 behind gateway 192.168.65.1, and the Ubuntu guest 192.168.64.11 behind 192.168.64.1. Both answered ping from the Mac. QEMU VMs show a different list, with Emulated VLAN in place of NAT Network.

Modes differ in who can reach the guest and whether it gets out to the internet. The table follows UTM’s network docs for each mode and the backends that offer it.
| Mode | Backend | Internet | Reachable from the Mac | Use it for |
|---|---|---|---|---|
| Shared Network | Apple, QEMU | Yes | Yes | Default dev VMs, SSH, local web servers |
| NAT Network | Apple (macOS 26+ host) | Yes | Not listed; VMs on it reach each other | Several VMs that talk to each other |
| Host Only | Apple (macOS 26+ host), QEMU | No | Yes | Malware samples, offline test labs |
| Bridged (Advanced) | Apple, QEMU | Yes, from your LAN | Yes, as a LAN device | A guest other machines must reach |
| Emulated VLAN | QEMU | Yes | Only with port forwarding | Isolated guests with a few forwarded ports |
Bridged is the one people reach for first and regret, because it hands the guest an address from your router, and UTM warns that bridging over Wi-Fi may need extra configuration. Use it only when another machine on the LAN has to reach the VM directly. For a box like a Proxmox server that you want macOS on permanently, our guide to running macOS on Proxmox VE is the better route, with the licence caveat that comes with non-Apple hardware.
Keeping the VMs healthy
Two habits save most UTM VMs: shut the guest down from inside before closing it, and take a snapshot before anything risky. UTM’s toolbar power button warns that a forced stop may corrupt the VM, and it is right. Ubuntu’s desktop got in the way of a clean shutdown on our VM, because sudo poweroff from Terminal was refused while the GNOME session held an inhibitor lock.
Operation inhibited by "mary" (PID 2495 "gnome-session-s", user mary), reason is "user session inhibited".
User mary is logged in on tty2.
Please retry operation after closing inhibitors and logging out other users.
'systemd-inhibit' can be used to list active inhibitors.
Alternatively, ignore inhibitors and users with 'systemctl poweroff -i'.
Use the power menu in GNOME’s top bar, or tell systemd to ignore the inhibitor. That shut our guest down cleanly in a few seconds.
sudo systemctl poweroff -i
Snapshots now work for Apple Virtualization VMs as well as QEMU ones, as long as the host runs macOS 27, per UTM’s snapshot docs. We took ours with the VM stopped, so it holds the disks only, not the running state. Select the VM, open the Snapshots tab under its preview and click New. Ours appeared within seconds and took 4 MB, because APFS clones the disk image instead of copying it.

That 4 MB grows as the guest diverges from it, so prune old snapshots the way you would prune old backups. Snapshots are not backups either, since they live inside the same VM bundle. The rest of the day-2 work is about that bundle:
- Back up a stopped .utm bundle from ~/Library/Containers/com.utmapp.UTM/Data/Documents
- Watch host free space: 28 GB macOS, 10 GB Ubuntu here
- Shut every VM down before a UTM update
The last item comes from UTM’s release notes, which warn that suspended VMs may not resume after an update. Scripting UTM has one more catch. utmctl talks to the running UTM app through Apple Events, so it only works from a Terminal inside a logged-in GUI session. Over SSH it fails every time.

If you want to start, stop and clone VMs from a script or a CI runner over SSH, UTM is the wrong tool. A CLI-first runner on the Virtualization framework such as Tart handles that without a GUI session. To run macOS on a Linux box you already own instead, our macOS on KVM guide covers OSX-KVM. If you’re choosing hardware for a VM-heavy desk, the Mac buying guide for local models weighs the same unified-memory trade-offs a pair of 8 GB guests forces on you.