# openai/tart: macOS and Linux VMs on Apple Silicon for CI > Tart is a Swift virtualization toolset that runs macOS and Linux VMs on Apple Silicon through Apple's Virtualization.Framework, and stores them in OCI-compatible container registries. It suits CI engineers who need reproducible macOS runners; it is not a general desktop hypervisor. **openai/tart** — macOS and Linux VMs on Apple Silicon to use in CI and other automations - Repository: https://github.com/openai/tart - Website: https://tart.run - Stars: 7,233 · Forks: 385 - Language: Swift - License: NOASSERTION - Published: 2026-09-22 · Updated: 2026-09-22 · Language: en - Canonical page: https://hysenlabs.com/projects/openai-tart ## The problem Tart solves: disposable macOS guests on Apple Silicon Before Apple Silicon, macOS CI usually meant either a pool of physical Mac minis that were never quite identical, or a hosted service you could not inspect. Tart targets the first case. It is a virtualization toolset for building, running and managing macOS and Linux virtual machines on Apple Silicon, and the README frames it as "built by CI engineers for your automation needs". The audience is therefore narrow and specific: people who need to boot a clean macOS guest, run a build, and throw the guest away, without hand-managing a fleet of machines. The README lists ten companies using Tart in internal setups, including Atlassian, Figma, Mullvad, Expo and Cirrus CI. That is a signal about where it gets deployed, not a quality score. What matters more for a decision is the shape of the tool: a command-line binary, not a GUI app, with VM images treated as artefacts you can version and move. If your problem is "our macOS builds are not reproducible across machines", Tart addresses it. If your problem is "I want to run Windows on my Mac", it does not. ## How Tart works: Virtualization.Framework plus OCI registries Two mechanisms define the project. The first is Apple's own Virtualization.Framework, which the README cites for near-native performance; Tart does not ship its own hypervisor. That choice ties Tart to Apple Silicon and to a minimum host OS, and it means VM behaviour follows Apple's framework rather than a portable emulation layer. The second is distribution. Tart can push and pull virtual machines from any OCI-compatible container registry. A VM image is therefore addressed like a container image: in the README example, ghcr.io/cirruslabs/macos-tahoe-base:latest is a registry path with a tag. This is the part that makes CI adoption plausible. You build a golden image once, push it, and every runner pulls the same bytes instead of booting from a locally maintained disk. It also means your registry becomes part of your CI supply chain: access control, retention and transfer cost all move there. Around those two core pieces the project ships supporting tooling. There is a Tart Packer Plugin for automating VM creation, and the README states Tart easily integrates with any CI system. The repository layout reflects that scope: Sources/ for the Swift implementation, integration-tests/, benchmark/, docs/ and a mkdocs.yml for the documentation site at tart.run. ## Installing Tart and running your first VM The README gives a three-command quickstart and warns that it will download a 25 GB image. The install step uses a Homebrew tap rather than a formula in homebrew-core: ```bash brew install openai/tools/tart ``` After that, you clone a base image from a registry and give it a local name. The README uses ghcr.io/cirruslabs/macos-tahoe-base:latest as the source and tahoe-base as the destination: ```bash tart clone ghcr.io/cirruslabs/macos-tahoe-base:latest tahoe-base ``` Expect a long first run, since the image is 25 GB. The clone is what makes the workflow repeatable: the registry copy stays untouched while tahoe-base becomes the VM you boot and modify. Finally, start it: ```bash tart run tahoe-base ``` The README states the host must be an Apple Silicon device running macOS 13.0 (Ventura) or later. It points to tart.run for fuller documentation and to GitHub discussions for open questions, so treat the three commands above as the entry point rather than the full surface of the CLI. ## Where Tart is the wrong tool The README scopes Tart to macOS and Linux VMs on Apple Silicon. That single sentence excludes a lot. There is no x86 guest support, so anything that needs to run Intel binaries under emulation is out of scope here. Windows is not mentioned. And the README never claims a graphical desktop experience: the quickstart is a clone-and-run CLI flow aimed at automation, not at interactive use. If you want a hypervisor to click around in, this is not the framing the project gives itself. There is a second, quieter constraint. Because Tart delegates to Virtualization.Framework, the host OS floor is not negotiable: macOS 13.0 (Ventura) or later, on Apple Silicon. Machines that are otherwise perfectly capable but older, or Intel-based, cannot run it. The documentation is also thin in places a CI engineer would care about. The README covers install, clone and run, and then defers to tart.run. It says nothing about rollback of a bad image, nothing about how a partially completed push is handled, and nothing about concurrent access to the same registry tag from multiple runners. Those are exactly the questions that surface in production, and the README is silent on them. The repository does carry integration-tests/ and a benchmark/ directory, so there is some internal verification, but the README does not describe what either covers. ## Tart compared with UTM UTM is the comparison people reach for, and the difference is architectural rather than cosmetic. UTM is a general-purpose virtualizer with a graphical front end, built for running many operating systems on a Mac, including x86 guests through emulation. Tart is a CLI toolset with no graphical front end in its documented workflow, and it restricts itself to macOS and Linux on Apple Silicon. That changes what each is good at. UTM's breadth is the point: if you need to boot Windows, or an older x86 Linux, or you want to hand a VM to a colleague who will not use a terminal, UTM covers ground Tart does not. Tart gives up that breadth to get two things: a narrower dependency surface (Apple's framework only) and OCI-based image distribution, which is what turns a VM into something a pipeline can pull by tag. UTM is not documented here as having that registry workflow. So the split is not "better or worse". If your requirement is a reproducible macOS guest that a CI job pulls by tag, Tart matches the requirement directly. If your requirement is a desktop hypervisor for mixed operating systems, UTM matches it and Tart does not. ## Licence and the cost of keeping Tart current The repository carries a LICENSE file and the GitHub metadata reports the licence as NOASSERTION, meaning the licence could not be classified automatically. The project's own topics include fair-source. That is worth reading directly rather than inferring: fair-source licences typically place conditions on commercial use that differ from a permissive open source licence, and the terms in LICENSE are the ones that bind you. This is a description of what the repository states, not legal advice; if Tart would sit inside a commercial product or a paid CI service, have someone read LICENSE before you build on it. Upgrade cost looks low on the evidence available. The release history shows 2.35.0 on 2026-08-04, 2.36.0 on 2026-08-25 and 2.37.0 on 2026-09-09, a steady cadence of roughly one minor release every few weeks, and the last push to the repository was on 2026-09-21. There is a .goreleaser.yml at the top level, so releases are produced by an automated pipeline rather than by hand. The practical cost is not upgrading the binary; it is re-cloning or re-pushing base images when you want guests to pick up changes, and that cost scales with image size. A 25 GB base image is not something you want to move casually across a network. ## Conclusion Adopt Tart if your CI needs disposable macOS or Linux guests on Apple Silicon hardware and you already have an OCI registry to store images in. Do not adopt it if you need x86 guests, Windows, or a graphical hypervisor for interactive desktop work, because the README scopes Tart to macOS and Linux on Apple Silicon. Before rolling it into a pipeline, verify three things yourself: that your host runs macOS 13.0 (Ventura) or later, that your registry accepts the image layers Tart pushes, and how the fair-source licence in LICENSE applies to your organisation's use. ## FAQ ### How do I install Tart? The README installs it through a Homebrew tap with brew install openai/tools/tart, on an Apple Silicon device running macOS 13.0 (Ventura) or later. ### What is macOS Tart? Tart is a virtualization toolset for building, running and managing macOS and Linux virtual machines on Apple Silicon, aimed at CI and other automation. It uses Apple's Virtualization.Framework and can push and pull VMs from any OCI-compatible container registry. ### How large is the base image Tart downloads on first run? The README warns that the quickstart will download a 25 GB image when you clone ghcr.io/cirruslabs/macos-tahoe-base:latest. ### Does Tart run on Intel Macs? No. The README scopes Tart to Apple Silicon and requires macOS 13.0 (Ventura) or later on the host, and it builds on Apple's Virtualization.Framework. ### What licence does Tart use? The repository contains a LICENSE file, and GitHub reports the licence as NOASSERTION, meaning it could not be classified automatically. The project topics include fair-source, so the terms in LICENSE are the ones to read. ### Can I use Tart to run Windows or x86 guests? The README describes Tart as running macOS and Linux virtual machines on Apple Silicon and does not mention Windows or x86 guest support. ## Sources - [Issues](https://github.com/openai/tart/issues) - [openai/tart on GitHub](https://github.com/openai/tart) - [Project website](https://tart.run) - [README](https://github.com/openai/tart/blob/main/README.md) - [Releases](https://github.com/openai/tart/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/openai-tart