Skip to content

Try Eight.ly OS in a VM on your Mac

Want to see Eight.ly OS — the appliance operating system — without dedicating a whole machine to it, or without any other way to run it on a Mac at all? Run it in a virtual machine. Apple Silicon Macs run an ARM build of Eight.ly OS inside a free virtualizer, and nothing on your Mac changes: macOS keeps running, your files stay put, and you can throw the VM away when you're done.

This is the evaluation path. It's the fastest way to click through the installer, walk the setup wizard, build a storage pool, and deploy real apps — so you know exactly what Eight.ly OS is before you put it on hardware.

There is no other way to run Eight.ly OS on a Mac

Eight.ly OS has no native macOS build. A VM is how you run it on a Mac at all. See Eight.ly OS on your Mac for what a VM can and can't show you, and why a dedicated x86-64 box is the path for a production install.

Apple Silicon, and hardware coverage

This guide is for Apple Silicon Macs (M1-M4). Check Hardware compatibility and the download page for the current state of arm64 real-hardware validation before you rely on the ARM build outside a VM. (Intel Macs can run the amd64 OS image the same way; the settings differ only in the architecture you pick.)

What you'll end up with

  • A window on your Mac showing Eight.ly OS booting and running
  • The full 7-step installer and the 8-step setup wizard, start to finish
  • A real MergerFS + SnapRAID storage pool built from virtual disks
  • Traefik and Authelia deployed by the one-click step, plus an app you pick from the catalog
  • Nova, the built-in AI assistant, running on the CPU (no GPU passthrough in a VM)

The whole thing lives in a folder you can delete to reclaim the space.

Before you start

  • An Apple Silicon Mac with ~30 GB free for the VM's disks and the image
  • UTM — a free, open-source virtualizer for the Mac. Install it from mac.getutm.app or the Mac App Store, then open it once so it finishes setting up.
  • The Eight.ly OS ARM (arm64) installer image and its checksum — see the next section.

Give the VM real resources

Eight.ly OS is a full operating system running Docker, a storage stack, and a local AI assistant. Give the VM at least 4 CPU cores and 8 GB of RAM. On an 8 GB Mac, close other heavy apps first.

Step 1: Download the image and verify it

The ARM installer image is a .iso named like eightly-<version>-arm64.iso, published on the download page alongside the amd64 image. Paste your license key and the page lists the build for your machine.

The public arm64 download lands with the next release

The ARM image is brand-new. It's attached to the next tagged release on the download page — until that release is cut, the arm64 .iso and its checksum may not be listed yet. If you don't see an arm64 build, you're early; check back after the next release, or ask in Discord.

Verify the download before you use it. Every release ships a signed SHA256SUMS file next to the images. Compare your download's checksum against it:

# From the folder where you saved the .iso and SHA256SUMS
shasum -a 256 eightly-<version>-arm64.iso
grep arm64 SHA256SUMS

The two hashes must match. If they don't, delete the file and download it again — never install from an image that fails its checksum.

Step 2: Create the VM in UTM

Open UTM and click Create a New Virtual Machine, then:

  1. Choose Virtualize (not Emulate) — on Apple Silicon this runs the ARM guest with hardware acceleration, at native ARM speed.
  2. Pick Linux as the operating system.
  3. On the Linux settings screen, leave Use Apple Virtualization unchecked — UTM itself recommends QEMU here. Then, under Boot ISO Image, click Browse and select the eightly-<version>-arm64.iso you verified.
  4. Memory: set 8192 MB (8 GB). Cores: set 4 or more.
  5. Storage: set the drive size to 40 GB — this is the system disk Eight.ly OS installs onto.
  6. Skip the shared-folder step (you don't need it).
  7. On the Summary screen, give the VM a name like Eightly OS and click Save.

The defaults are close — these are the settings that matter

UTM's Linux template already targets ARM with UEFI boot. The four things to get right are Virtualize (not Emulate), Use Apple Virtualization unchecked, 8 GB Memory / 4+ Cores, and a 40 GB system disk.

Add three data disks for the storage pool

Eight.ly OS's setup wizard can build a real storage pool — but only if the VM has spare disks to build it from. Add three:

  1. Select your new VM and click Edit (the settings sliders icon).
  2. In the settings sidebar, scroll to the drive list and use the New Drive… control at the bottom to add a drive.
  3. Add a disk of 20 GB (leave the interface on its default). Repeat until you have three 20 GB data disks in addition to the 40 GB system disk.
  4. Save.

You'll end up with four virtual disks: one 40 GB system disk and three 20 GB data disks. That's enough for the wizard to create a pool with two data drives and one parity drive.

Virtual disks aren't drive bays

These are files on your Mac, not physical drives. That's fine for evaluation — but see Honest limitations for what a VM can't show you.

Check the network

Leave the VM's network on its default Shared mode (UTM's Edit → Network screen). That gives the guest outbound internet (it needs it to pull app images) and lets your Mac reach the dashboard. You don't need to change anything.

Step 3: Boot the installer

Select the VM and click the ▶ Play button. A window opens and the VM boots from the ISO:

  1. It lands on a GRUB menu — leave the default entry highlighted (it boots on its own after a few seconds), or press Enter.
  2. The live installer comes up and prints the address of its web installer on the console, like http://<ip>:8080/install.

You drive the installer from that web page. You can use the browser inside the VM window, or — because the VM is on your Mac's network — open the same http://<ip>:8080 address in Safari or Chrome on your Mac. Either works.

Step 4: Run the 7-step installer

The installer is a clean, keyboard-friendly wizard. Walk all seven steps in order:

  1. Get started — the welcome screen. Click through.
  2. Select the install disk — pick the 40 GB disk as the target. Leave the rest for the pool. Keep the root filesystem on ext4 (the tested default) and leave the size blank to use the whole disk.
  3. Name this machine — give it a hostname, e.g. eightly-vm, or leave it blank to auto-generate one.
  4. Network — DHCP is the simplest choice in a VM and works out of the box.
  5. Remote access — leave SSH on and create a sudo admin (username and password). Root login stays disabled by design; this named admin is how you get a shell.
  6. Confirm — review the summary (disk, filesystem, hostname, network, SSH), then type the confirmation word shown on screen to arm the wipe. This deliberate friction is there so you can't erase the wrong disk.
  7. Install — it partitions the disk, copies the system, stages Nova's AI models, and installs the bootloader. When it finishes, you'll see Installation complete.

Don't skip a step

Run every step, in order, to the end — even the ones that look obvious. The installer only writes to disk after you confirm on step 6; nothing before that touches your Mac or the virtual disks.

When it's done, shut the VM down, remove the ISO from the VM's drive list in Edit (so it boots from the disk, not the installer again), and start the VM. It boots into the installed Eight.ly OS and prints the dashboard address on the console.

Step 5: First login and the setup wizard

Open the dashboard address in your browser. On first visit Eight.ly OS asks you to create the admin account — set a username and password. (This is the dashboard admin; the SSH admin from the installer is separate.)

You're then dropped into the setup wizard — eight steps that bring the node online. Walk all of them:

  1. Choose your theme — pick a light or dark theme and apply it. The dashboard changes immediately.
  2. Configure storage — choose Media Server Storage (SnapRAID + MergerFS), then open the array builder. Name the array (e.g. tank), pick two of your 20 GB disks as data drives and the third as a parity drive, skip the cache step (a VM has no cache-capable disk to offer), review, and type the array name to confirm. The wizard formats the disks, builds the union mount at /mnt/<name>, and writes the SnapRAID config — a real pool, not a mock-up.
  3. Cache drive — in a VM there's no SSD to use as a cache, so this step tells you there's nothing to configure and resolves itself.
  4. Network — for an evaluation box, leave the reverse proxy on Direct Access (port-based).
  5. Security & Auth — your SSH admin is already set up from the installer; there's nothing to redo. Review and continue.
  6. Backup — leave the local backup defaults.
  7. Monitoring — optional. You can enable the Grafana/Prometheus stack here, or skip it to keep the VM light.
  8. One-Click Deploy — this is the one worth watching. Enter a domain (any name works for an evaluation box, e.g. home.example.com) and click Deploy Now. Eight.ly OS pulls Traefik (the reverse proxy) and Authelia (the login gateway) as ARM images and starts them. When both report healthy, click Done.

Watch the pool and the containers actually appear

After the wizard, the Storage page shows your tank pool with its real free space, and the Docker page lists Traefik and Authelia running. If they're there, the wizard did the real thing — it didn't just advance a progress bar.

Step 6: Deploy an app from the catalog

Open the App Store, search for an app, and click Deploy. Pick something that publishes an ARM image — most popular apps do. On the install wizard you can set the host port, environment variables, and volumes; some apps (anything that manages Docker) will ask you to type a short confirmation before they can mount the Docker socket. Finish the wizard and the app starts as a container on the VM, its port shown on the card.

That's the full loop: install the OS, build storage, deploy the bundled stack, and install an app — all inside a window on your Mac.

Alternative: Parallels Desktop (paid)

If you already own Parallels Desktop, it runs the same ARM image. The steps mirror the UTM flow above — the only differences are Parallels' own dialogs:

  1. File → New → Install Windows or another OS from a DVD or image file, then pick the eightly-<version>-arm64.iso.
  2. When Parallels can't auto-detect the OS, choose Other Linux and continue.
  3. Before first boot, open Configure and set CPU & Memory to at least 4 processors and 8 GB, then under Hardware → Hard Disk set the boot disk to 40 GB and add three more 20 GB hard disks for the storage pool.
  4. Leave networking on the default Shared Network.
  5. Boot, and from the GRUB menu on, follow the installer and setup wizard exactly as above.

Parallels steps are not independently validated

UTM is the free path this guide was written and tested against. The Parallels steps mirror the UTM flow but were not independently validated — field and menu names may differ by Parallels version. UTM is the recommended (and free) way to do this.

Honest limitations

A VM shows you the software honestly, but it is not hardware. Know what it can't show you:

  • Virtual disks aren't real drive bays. You can build and test a storage pool, but you're testing the software, not real drives, cabling, or a hot-swap backplane.
  • No SMART, no real disk health. The disks are files, so drive-health features and SMART tests have nothing physical to report.
  • No GPU passthrough. Nova, the built-in AI assistant, runs CPU-only in the VM. Answers work but are slower than on a box with a GPU. Hardware transcoding in media apps is likewise unavailable.
  • arm64 hardware coverage varies. Check Hardware compatibility and the download page for where real-hardware validation of the ARM build currently stands — so a VM is a safe place to evaluate it, and the wrong place to run anything you can't lose if hardware coverage isn't there yet.
  • Self-update works, but the stakes are low here. Eight.ly OS can update itself in place — a swap that verifies, health-checks, and rolls back if anything's wrong (we call it Featherfall). That works in a VM too, but since you can rebuild a VM in minutes anyway, there's little at stake either way.

If you want the real thing — real drives, SMART, and a GPU it can see directly — that's Eight.ly OS on an x86-64 machine. There is no everyday, daily-driver path on the Mac itself; see Eight.ly OS on your Mac for the full picture.

Cleaning up

Done evaluating? In UTM, select the VM, and either stop it to keep it around for later, or delete it to reclaim all the disk space. Deleting the VM removes its virtual disks with it — nothing is left on your Mac.

See also