UTM
Virtual machines for Mac — run Windows, Linux, and more
Quick Take: UTM
UTM fills an important gap: free (or cheap) virtual machines on Mac without the Parallels tax. ARM64 Linux VMs run beautifully via Apple's Virtualization.framework, and the QEMU backend handles legacy x86 and exotic architectures for edge cases. It's not as polished as Parallels for daily Windows use, and x86 emulation is inherently slow, but for developers who need occasional VMs, students who need Linux, and tinkerers who want to explore old operating systems, UTM gets the job done without a subscription.
Best For
- •Developers Testing Across Operating Systems
- •Students Running Linux for Coursework
- •Retro Computing Enthusiasts
Install with Homebrew
brew install --cask utmWhat is UTM?
UTM lets you run virtual machines on your Mac. Need Windows 11 to test your app in Edge? Spin up a Windows VM. Need Ubuntu for a Linux-specific build tool? Spin up a Linux VM. Want to run macOS Ventura alongside macOS Sequoia to test backward compatibility? Spin up an older macOS VM. UTM wraps Apple's Virtualization framework and QEMU into a native macOS app with a straightforward interface for creating, configuring, and running VMs. The name stands for 'Universal Turing Machine,' and the ambition matches: UTM can virtualize ARM64 operating systems at near-native speed (using Apple's Virtualization.framework on Apple Silicon) and emulate x86 operating systems (using QEMU) at reduced but usable speed. This means you can run ARM64 Linux distributions—Ubuntu, Fedora, Debian—with full GPU acceleration and shared clipboard at speeds that feel like running a native app. For x86 guests like Windows or older Linux distros that haven't been ported to ARM, UTM uses QEMU's full system emulation, which is slower but functional. UTM positions itself between OrbStack (focused on containers and lightweight Linux VMs) and Parallels Desktop (a $100/year commercial product with polished Windows integration). UTM is free if you download it from GitHub, or $10 on the Mac App Store (same app, the paid version funds development and gets automatic updates). For developers who need occasional VM access without Parallels' price tag, students who need to run Windows for a specific class, and tinkerers who want to emulate old operating systems or architectures, UTM is the practical choice.
Deep Dive: How UTM Makes Virtual Machines Accessible on Mac
UTM's dual-engine architecture, the role of Apple's Virtualization framework, and why free VM software matters for developers.
History & Background
UTM started as an iOS project—a QEMU frontend that could run virtual machines on jailbroken iPhones and iPads. Developer osy ported it to macOS when Apple Silicon arrived, recognizing that the new ARM64 architecture created demand for a free VM solution. With Parallels charging $100/year and VMware Fusion's future uncertain after the Broadcom acquisition, UTM filled a critical gap. The addition of Apple's Virtualization.framework support in 2022-2023 transformed UTM from a QEMU wrapper into a genuinely fast virtualization tool for ARM64 guests.
How It Works
UTM has two backends. For ARM64 guests, it uses Apple's Virtualization.framework—the same technology that powers macOS's built-in Rosetta Linux support. This provides near-native performance with hardware-accelerated CPU, memory, and I/O virtualization. For x86 and other architectures, it uses QEMU's full system emulation, translating instructions in software. The frontend is a native SwiftUI app that manages VM lifecycle, configuration, and display. SPICE handles the remote display protocol, providing shared clipboard, dynamic resolution, and smooth rendering.
Ecosystem & Integrations
UTM's VM gallery provides pre-built images for the most common use cases: Windows 11 ARM, Ubuntu, Fedora, Arch Linux, FreeBSD, and several retro operating systems. The gallery is community-maintained, and users submit tested VM configurations with documentation. UTM also integrates with Apple's file provider for shared directories and supports VirtIO networking for high-performance network access within guests.
Future Development
UTM's 2026 roadmap includes improved GPU passthrough for better graphics performance in Linux guests, support for Apple's newer Virtualization.framework features (such as Rosetta for Linux x86 translation within ARM64 VMs), and a revamped UI for managing large numbers of VMs. The developer is also exploring snapshot and checkpoint features for saving and restoring VM states.
Key Features
Apple Virtualization Framework Integration
On Apple Silicon Macs, UTM uses Apple's built-in Virtualization.framework for ARM64 guests. This provides near-native performance—ARM64 Linux VMs boot in seconds, run at full CPU speed, and can access GPU acceleration through Virgl. macOS guests also run via this framework, letting you run older macOS versions alongside your current one. The Virtualization.framework integration means VMs are energy-efficient and don't overheat your MacBook the way QEMU emulation does.
QEMU Emulation for x86
For operating systems that don't have ARM64 versions—older Windows, legacy Linux distros, DOS, classic Mac OS—UTM uses QEMU to emulate x86, x86_64, PPC, and other architectures. Performance is 3-10x slower than native, but it's sufficient for running Windows 11 for testing, playing retro games, or booting vintage operating systems. QEMU's broad architecture support means UTM can emulate systems most people have forgotten about.
Shared Directories
UTM supports VirtIO shared directories between host and guest. Mount a folder from your Mac inside the VM, and files are accessible from both sides. This eliminates the need to SCP or FTP files between your Mac and the VM—edit code on your Mac, run it in the Linux VM, and changes are instantly visible. Shared directories work with both Virtualization.framework and QEMU guests.
USB Device Passthrough
Connect a USB device to your Mac and pass it through to a VM. This is useful for developers working with microcontrollers (Arduino, Raspberry Pi Pico), hardware tokens (YubiKey), or specialized peripherals that only have Windows drivers. The VM sees the USB device as if it were directly connected. UTM supports USB 2.0 and 3.0 passthrough depending on the backend.
GPU Acceleration for Linux Guests
ARM64 Linux VMs can use Virgl 3D acceleration for basic GPU rendering, which means running desktop environments (GNOME, KDE) with compositing effects at reasonable frame rates. It's not gaming-level GPU performance, but it's enough for a smooth desktop experience and basic OpenGL applications. This sets UTM apart from bare QEMU, which offers no GPU acceleration on Mac.
Gallery of Pre-Built VMs
UTM's website hosts a gallery of pre-configured VM images: Windows 11 ARM, Ubuntu, Fedora, Arch Linux, FreeBSD, and various retro operating systems. Download a pre-built image, import it into UTM, and boot—no manual OS installation required. This is the fastest way to get a working VM for common use cases.
Who Should Use UTM?
1The Cross-Platform Web Developer
A frontend developer needs to test their web app in Edge on Windows. They download UTM's pre-built Windows 11 ARM image, boot the VM, install Edge, and test their site. The shared directory feature means they can edit code on macOS in their preferred editor and refresh the browser in the VM instantly. When they're done testing, they suspend the VM—it resumes in seconds next time.
2The CS Student
A computer science student's coursework requires running Ubuntu with specific libraries (GCC, Valgrind, GDB) that behave differently on macOS. They create an ARM64 Ubuntu VM in UTM, install the required tools, and do their assignments inside the VM. The VM runs at near-native speed on their M-series MacBook, and they can share their project folder between macOS and the VM.
3The Retro Computing Enthusiast
A hobbyist wants to run classic Mac OS 9, Windows XP, and BeOS. UTM's QEMU backend emulates PowerPC and x86 architectures, letting them boot these vintage operating systems. It's slower than native, but perfectly functional for exploring old software, running legacy games, and preserving computing history on modern hardware.
How to Install UTM on Mac
UTM is available for free from GitHub or for $10 on the Mac App Store (supports development with automatic updates).
Install via Homebrew
Run `brew install --cask utm` to install UTM from Homebrew. This installs the free GitHub version to your Applications folder.
Download a Pre-Built VM (Optional)
Visit mac.getutm.app/gallery to browse pre-configured VM images. Download the one you need (e.g., Ubuntu 24.04 ARM64) and import it into UTM.
Create a New VM
Alternatively, click 'Create a New Virtual Machine' in UTM, choose Virtualize (for ARM64 guests) or Emulate (for x86 guests), select your ISO, configure RAM and storage, and install the OS from scratch.
Install SPICE Guest Tools
For the best experience (shared clipboard, dynamic resolution, shared directories), install SPICE guest tools inside the VM. UTM provides these tools and documentation for each supported guest OS.
Pro Tips
- • Allocate at least 4GB RAM and 2 CPU cores to Windows VMs for acceptable performance.
- • Use 'Virtualize' mode for ARM64 Linux (near-native speed). Only use 'Emulate' when the OS doesn't have an ARM64 version.
- • The Mac App Store version is identical to the GitHub version but includes automatic updates—worth $10 to support the developer.
Configuration Tips
Use Virtualize Mode for ARM64 Guests
When creating a VM for ARM64 Linux or macOS, always choose 'Virtualize' mode. This uses Apple's Virtualization.framework for near-native performance instead of QEMU emulation. The difference is massive—10x faster boot times and 5x faster general performance.
Set Up Shared Directories Early
Configure a shared directory in UTM's VM settings before booting the guest. Inside the VM, mount it with `sudo mount -t virtiofs share /mnt/shared`. This creates a persistent bridge between your Mac file system and the VM, eliminating the need for file transfer tools.
Alternatives to UTM
UTM occupies a unique space between lightweight containers and commercial VM products.
OrbStack
OrbStack is a Docker Desktop replacement that also runs lightweight Linux VMs. It's faster and lighter than UTM for Linux containers and simple Linux environments. But OrbStack can't run Windows, can't emulate x86, and doesn't support macOS guests. Use OrbStack for Docker and quick Linux shells. Use UTM when you need Windows, full OS VMs, or architecture emulation.
Parallels Desktop
Parallels is the commercial gold standard for running Windows on Mac. It offers Coherence mode (Windows apps in macOS windows), DirectX 11 support, and polished integration. It costs $100+/year. UTM is free/cheap and handles most use cases, but Parallels is superior if you run Windows daily or need gaming performance. Choose based on how often you use Windows.
Docker Desktop
Docker runs containerized applications, not full operating systems. If you need to run a Linux service (PostgreSQL, Redis, Nginx), Docker is lighter and faster than a full VM. If you need a full desktop environment, a Windows install, or architecture emulation, use UTM. Many developers use both.
Pricing
UTM is free when downloaded from GitHub (github.com/utmapp/UTM). The Mac App Store version costs $9.99 (one-time purchase) and includes automatic updates. Both versions are functionally identical. The $10 purchase supports ongoing development. There are no subscriptions, no feature gates, and no tiers.
Pros
- ✓Free from GitHub, $10 on App Store for automatic updates
- ✓Near-native ARM64 VM performance via Apple Virtualization.framework
- ✓x86 emulation via QEMU for legacy operating systems
- ✓Shared directories between host and guest
- ✓USB device passthrough for hardware development
- ✓GPU acceleration for ARM64 Linux desktops
- ✓Pre-built VM gallery for quick setup
- ✓Supports macOS guests (run older macOS versions)
Cons
- ✗x86 emulation is noticeably slower than native (expect 3-10x slowdown)
- ✗Windows ARM support is functional but rougher than Parallels' polished integration
- ✗No DirectX GPU passthrough—Windows gaming in VMs isn't practical
- ✗SPICE guest tools installation can be fiddly for some guest OSes
- ✗Less mature than VMware or Parallels for enterprise use cases
Community & Support
UTM has a growing community on GitHub with over 27,000 stars. The project is maintained primarily by osy (the lead developer) with community contributions. Support happens through GitHub Issues and a Discord server. The UTM documentation site covers VM creation, guest OS setup, troubleshooting, and advanced QEMU configuration. The pre-built VM gallery is community-curated, with new images added as operating systems release ARM64 versions.
Frequently Asked Questions about UTM
Our Verdict
UTM fills an important gap: free (or cheap) virtual machines on Mac without the Parallels tax. ARM64 Linux VMs run beautifully via Apple's Virtualization.framework, and the QEMU backend handles legacy x86 and exotic architectures for edge cases. It's not as polished as Parallels for daily Windows use, and x86 emulation is inherently slow, but for developers who need occasional VMs, students who need Linux, and tinkerers who want to explore old operating systems, UTM gets the job done without a subscription.
About the Author
Productivity & Workflow Analyst
Related Technologies & Concepts
Related Topics
Virtualization & Containers
Tools for running virtual machines and containers on Mac.
Development Environment
Tools for setting up development environments on macOS.
Sources & References
Fact-CheckedLast verified: Feb 23, 2026
- 1UTM Official Website
Accessed Feb 23, 2026
- 2UTM GitHub Repository
Accessed Feb 23, 2026
Research queries: UTM virtual machine Mac 2026