mrkeyoor.com_
Sun 06 Sept 21:52 UTC
Dev Toolsevaluationupdated 06 Sept 2026

darwin-vm review

darwin-vm is a QEMU-based environment for booting recent iOS and macOS kernels into a bare root shell. It gives kernel researchers a place to inspect Darwin internals, patch a recovery filesystem, run command-line programs, and attach a debugger without using a physical iPhone or Mac as the target. It does not reproduce the screen or the rest of the consumer device experience.

trackingstars / 7d
Verdict

Our darwin-vm checkout installed 60 Rust packages in 9 seconds, but both the 10-second build and 4-second test run stopped because MESON_BUILD_ROOT was absent. Use it if recent Apple kernel research is the job and you can follow the full QEMU and macOS preparation path. Skip it for app testing, a desktop VM experience, or any workflow that needs a tagged, CI-backed release.

We ran it

Lab card: what happened when we ran darwin-vmScreenshot of darwin-vm (github.com/jprx/darwin-vm)
Install✓ · 9s60 packages
Build✗ · 10s
Tests✗ · 4sran, no count parsed
Repo86068 files~12,618,843 lines of source · 869.8 MB · 0 CI workflows · tests dir

Answers from our run

Does darwin-vm build from source?

Dependencies installed in 9 seconds (60 packages), and the build failed. We cloned commit 9044efc into a clean Debian container with 3 CPUs and no project-specific setup.

Do darwin-vm's tests pass?

The test command failed in our container, and its output did not report a pass or fail count.

Who should not use darwin-vm?

Mobile app teams that need a visual iPhone simulator: the README rules out a screen, graphics, GUI apps, Wi-Fi, Bluetooth, and full SpringBoard.

What are the alternatives to darwin-vm?

UTM, Darling, xnu-qemu-arm64. Our darwin-vm checkout installed 60 Rust packages in 9 seconds, but both the 10-second build and 4-second test run stopped because MESON_BUILD_ROOT was absent.

Setup1/5Mac firmware prep plus a missing Meson build environment
Docs4/5Detailed firmware, custom kernel, filesystem, and LLDB guides
Community3/51,043 stars and recent activity, but only 10 days of history
Maturity2/5No release or CI, and our build and test steps failed

Who it’s for

XNU and Darwin researchers who need a root shell on an emulated Apple platform.
Reverse engineers investigating SPTM, TXM, kernel startup, launchd, or userspace behavior.
Developers who want to add signed command-line programs to a modified recovery ramdisk.
Teams with access to macOS for firmware preparation and a separate machine for the QEMU build.

Who it’s NOT for

Mobile app teams that need a visual iPhone simulator: the README rules out a screen, graphics, GUI apps, Wi-Fi, Bluetooth, and full SpringBoard.
Linux-only teams unwilling to maintain their own firmware-preparation patches: the current README requires a Mac, while open issue 3 and pull request 1 cover unmerged Linux-host work.
Developers expecting the Rust directory to behave as a standalone Cargo project: the documented build goes through QEMU's configure and make path.
Organizations that require a tagged release and repository CI before adoption: GitHub lists no release, and our checkout had 0 workflow files.

Setup reality

Our commit 9044efc checkout installed 60 Rust packages in 9 seconds. The build failed with exit 101 after 10 seconds, and tests failed with exit 101 after 4 seconds. Both stopped in util-sys because MESON_BUILD_ROOT was absent.

Basic setup needs a Mac with Python, jq, ipsw, wget, APFS image tools, and sudo for ownership changes. Building QEMU can happen on another host after its system build dependencies are installed. The default path needs no API key; development kernels need a matching Kernel Debug Kit from Apple Developer Downloads.

The bundled launcher assigns 8 GB to a terminal-only guest. Firmware preparation downloads and alters an IPSW recovery image, while custom programs require Xcode, codesign, a CDHash entry, and a rebuilt trust cache. Those are normal kernel-lab tasks, but they make this a specialist setup rather than a general VM app.

iOS 27.0 reaches a root shell, not a simulated phone

darwin-vm boots Darwin environments for 6 iPhone generations, from A19 through A14, and 5 Apple Silicon Mac generations, from M5 through M1. Its tables cover iOS 27.0 beta 8, iOS 26.6, macOS 27.0 beta 8, and macOS 26.6. A successful boot lands at a root shell for running commands, replacing files, or inspecting the kernel.

The README says there is no screen, Wi-Fi, Bluetooth, graphics, GUI application support, or complete SpringBoard. The run script allocates 8 GB and connects a serial console in -nographic mode. That suits XNU and low-level userspace work, while ruling out ordinary app compatibility checks, interface testing, and daily macOS workloads.

The iOS 27.0 quickstart still depends on a Mac

Preparing the default iOS 27.0 image requires macOS, Python, jq, ipsw, and wget. get_files.sh takes components from an IPSW URL, unwraps the kernel cache and device tree, alters a recovery ramdisk, adds an iOS command-line sysroot, signs binaries, and builds a trust cache. fix_perms.sh mounts the image and asks for sudo before changing ownership to root:wheel.

The README allows a 2-machine arrangement: firmware work happens on a Mac, while the QEMU fork builds and runs elsewhere. The second host still needs QEMU system dependencies and an aarch64-softmmu build. Basic use needs no API key. A development macOS kernel adds Xcode-era tools, a matching Kernel Debug Kit, and an Apple Developer Downloads login.

What happened when we ran it

Our sandbox cloned commit 9044efc with 3 CPUs and 12 GB of RAM. Installation in qemu-sptm/rust/ succeeded in 9 seconds and added 60 packages. The build then failed with exit code 101 after 10 seconds. Tests reached the same exit code after 4 seconds, so our run produced neither a passing build nor a passing test result.

Both failures ended in the util-sys custom build script. It looked for MESON_BUILD_ROOT, did not find it, and panicked. The message directs developers to the make targets, a pyvenv/bin/meson devenv subshell, or an explicit path to the Meson build tree. The log does not show a Rust compiler defect or a missing Debian package, so we cannot assign either cause.

The checkout contained 86,068 files, about 12,618,843 lines of source, and occupied 869.8 MB. Most of that scale comes from the QEMU submodule rather than the small top-level collection of scripts and launch configuration. Our scan found 0 CI workflow files and no Dockerfile, though a tests directory exists. These measurements describe commit 9044efc in the stated unprivileged container.

The 8 GB terminal guest is built for kernel debugging

The run script passes 8 GB of guest memory, a patched boot kernel collection, a device tree, a trust cache, and the recovery ramdisk to qemu-system-aarch64. For SPTM-capable systems it also supplies SPTM and TXM images. Everything appears on the serial console. Adding QEMU's -s option opens a GDB server, and the README connects LLDB with gdb-remote localhost:1234.

The guide explains how to select a macOS build, obtain its matching KDK, combine the kernel with required extensions using kmutil, inspect the result, and replace firmware/bootkc. Its macOS 26.6 example explains the fixed 0x20000000 slide used to translate kernel-cache addresses into VM addresses. An XNU debugger can act on that detail; it proves more than a screenshot of an open shell.

iOS 27.0 support stops before graphics and networking

Booting iOS 27.0 does not provide the device services many people associate with emulation. The README excludes graphics, Wi-Fi, Bluetooth, and a full SpringBoard, and it describes the filesystem as a modified recovery image. There is no claim that App Store software, camera code, push notifications, cellular behavior, or Metal workloads work. A team evaluating an iOS app should use Apple's simulator or physical hardware instead.

Our measured tree had 0 CI workflows despite containing Rust tests, and both direct Rust steps failed outside the expected Meson environment. The documented route is the QEMU route: initialize the submodule, run configure for AArch64 system emulation, then use make. Anyone changing the machine model should build that path on supported hosts and add repeatable checks before trusting a patch.

Seven commits and no release mark an early source project

GitHub returned 7 commits on main, with the last push on September 3, 2026, six days after the repository was created. The page had 1,043 stars and 5 combined open issues and pull requests when fetched on September 6. Four were pull requests, including Linux-host preparation work; the remaining issue asks about Ubuntu support. The activity is current, but the history is short.

No GitHub release has been published, and the main branch is not marked protected. Users clone source and a large pinned submodule instead of choosing a tagged package with release notes. Recent commits changed supported OS images, shell setup, page-table handling, and log suppression within days. A kernel lab should pin the full commit and firmware inputs before attempting reproducible research.

UTM and Darling solve different jobs than iOS 27.0 kernel research

UTM is the better choice for managed virtual machines with graphics and guest operating systems on Apple devices. Darling targets macOS application compatibility on Linux without booting a guest kernel. Aleph Security's xnu-qemu-arm64 is closer in purpose and documents iOS 12.1, TCP tunneling, GDB helpers, and optional KVM, but its last push was in 2021. None replaces darwin-vm's focus on recent A19-to-A14 and M5-to-M1 platforms.

The 10-second build stop keeps darwin-vm out of the easy recommendation column. Kernel researchers with a Mac, legal access to the required Apple files, and patience for QEMU's Meson environment still get a direct route to a recent Darwin root shell. Everyone else will spend effort assembling firmware and toolchains only to find that the project intentionally omits the screen and device behavior they needed.

Alternatives

ProjectWhat it isPick it when
UTMA graphical QEMU-based virtual machine manager for iOS and macOS hosts.pick this instead when you want to run conventional Windows, Linux, or macOS guests with a managed interface rather than study a recent Darwin kernel.
DarlingA compatibility environment for running macOS software directly on Linux without a VM.pick this instead when running macOS command-line applications on Linux matters more than booting and debugging the XNU kernel.
xnu-qemu-arm64An older QEMU fork that boots iOS 12.1 with a shell, debugging tools, and optional KVM support.pick this instead when your research targets the documented iPhone 6S-era iOS 12.1 environment or you need its TCP tunneling and GDB scripts.

What people are saying

  1. [velocity-scout] jprx/darwin-vm

Sources

  1. darwin-vm README
  2. darwin-vm repository facts
  3. Measured darwin-vm commit 9044efc
  4. darwin-vm releases
  5. Linux host support issue
  6. UTM repository
  7. Darling repository
  8. xnu-qemu-arm64 repository

More dev tools reviews

Seelen-UI · sofka · NativeScript · codex-desktop-linux · requests · Recordly · the whole board →