# How Apple's Container Architecture Differs from Docker's Isolation Model > Discover the key differences between Apple's container architecture and Docker's isolation model. Learn how Apple uses VM-level isolation versus Docker's kernel-based approach. - Repository: [Apple/container](https://github.com/apple/container) - Tags: deep-dive - Published: 2026-06-29 --- **Apple's container tool provides VM-level isolation by running each container in its own lightweight Linux virtual machine using the Apple Virtualization framework, whereas Docker relies on Linux kernel namespaces and cgroups to share a single host kernel among all containers.** Apple's `container` repository introduces a fundamentally different approach to container isolation on macOS. While traditional Docker containers leverage Linux kernel features to share resources, **Apple's container architecture** spins up individual lightweight virtual machines for every container using native macOS virtualization frameworks. This design prioritizes strong isolation over shared-kernel efficiency, offering distinct security and privacy advantages for macOS users. ## Core Isolation Mechanisms ### Docker's Kernel-Level Approach Docker utilizes Linux kernel namespaces and cgroups to enforce isolation between containers. All containers share the same host kernel, with the kernel's namespace subsystem providing process and network isolation, and cgroups controlling resource allocation. This shared-kernel model minimizes overhead but means that a kernel vulnerability can potentially affect all containers running on the host. ### Apple's VM-Based Approach In contrast, Apple's solution gives each container its **own lightweight virtual machine** that runs on macOS. According to the repository's technical overview, "`container` runs a lightweight VM for each container… Security: Each container has the isolation properties of a full VM" (lines 26-31). Each VM is created using the **Apple Virtualization framework** (`VZVirtualMachine`), providing full hardware-level isolation for CPU, memory, and devices that is independent of the host kernel. ## Security and Privacy Implications ### Security Model Comparison Docker's security relies entirely on the guarantees of the shared host kernel. If the underlying Linux kernel is compromised, all containers on that host are potentially exposed. Apple's architecture reduces the attack surface by isolating each container's OS from the host and from other containers. Security is enforced at the hypervisor level, meaning a compromise within one container's VM does not automatically propagate to the host or other containers. As noted in the technical documentation, this reduces the attack surface to "the VMM and the minimal set of utilities inside the VM." ### Data Mounting and Privacy When using Docker Desktop on macOS, a shared Linux VM hosts all containers, meaning mounted host data is potentially visible to all containers unless explicitly restricted. Apple's `container` tool improves privacy by mounting **only the data you explicitly expose** to each individual VM. The host data is not globally shared across all containers, which prevents cross-container data leakage and provides finer-grained privacy controls. ## Performance and Resource Utilization Despite using separate VMs, Apple's architecture optimizes for resource efficiency. According to the technical overview (lines 26-31), "Containers created using `container` require less memory than full VMs, with boot times that are comparable to containers running in a shared VM." While Docker on Linux offers very low overhead through kernel sharing, Docker Desktop on macOS actually runs a single full Linux VM for *all* containers. Apple's per-container VM approach maintains boot times comparable to Docker Desktop's shared-VM approach while preserving the isolation benefits of complete virtualization. ## Implementation Architecture The VM-based approach is built on several native macOS frameworks. The technical overview (lines 34-40) identifies the key components: Virtualization, vmnet, XPC, Launchd, Keychain, and Unified Logging. ### Key Source Files The implementation spans several critical source files: - **[`MachineCapabilities.swift`](https://github.com/apple/container/blob/main/MachineCapabilities.swift)**: Checks for nested-virtualization support and configures the `VZGenericPlatformConfiguration` used to launch each VM. - **`container-runtime-linux`**: The runtime helper that implements the per-container VM lifecycle and exposes a management API via XPC. - **[`ServiceManager.swift`](https://github.com/apple/container/blob/main/ServiceManager.swift)**: Coordinates the launch of the `container-apiserver` launch agent and its helpers, including the VM-based runtime. - **[`PluginLoader.swift`](https://github.com/apple/container/blob/main/PluginLoader.swift)**: Handles loading of the container runtime plugins. When you execute a command like `container run`, the `container-apiserver` spawns the `container-runtime-linux` helper per container, which then initializes the lightweight Linux VM through the Apple Virtualization framework. ## OCI Compatibility Both architectures maintain compatibility with the Open Container Initiative (OCI) specification. Apple's `container` consumes and produces standard OCI images, meaning images built with Docker run unchanged on Apple's `container` and vice versa. The commands appear identical but trigger different underlying mechanisms: ```bash # Docker (Linux/macOS) docker run -d -p 8080:80 --name my-nginx nginx:alpine ``` ```bash # Apple container (macOS) container run -d -p 8080:80 --name my-nginx nginx:alpine ``` While Docker creates Linux namespaces inside a single VM (in the case of Docker Desktop), Apple's `container` creates a **new lightweight Linux VM** for each container instance. ## Summary - **Apple's container architecture** uses individual lightweight VMs per container via the Apple Virtualization framework, while Docker uses shared kernel namespaces. - Each container runs in isolation using `VZVirtualMachine` instances configured in [`MachineCapabilities.swift`](https://github.com/apple/container/blob/main/MachineCapabilities.swift), rather than sharing the host kernel. - Security is enforced at the hypervisor level, reducing the blast radius of potential compromises compared to shared-kernel models. - Data privacy is enhanced through explicit per-VM mounting rather than global host data sharing. - Despite using VMs, boot times remain comparable to Docker Desktop, with memory usage lower than traditional full VMs. - Full OCI compatibility ensures existing Docker images work without modification. ## Frequently Asked Questions ### Does Apple's container tool use Docker under the hood? No, Apple's `container` is an independent implementation. While Docker Desktop on macOS uses a single Linux VM to host all containers, Apple's tool uses the `container-runtime-linux` helper to create a separate lightweight VM for each container via the Apple Virtualization framework. The commands are similar for user convenience, but the underlying architecture is fundamentally different. ### How does the performance compare to Docker Desktop? According to the technical documentation, containers created using Apple's tool have boot times comparable to containers running in Docker Desktop's shared VM approach. While each container uses its own VM, these are lightweight instances that require less memory than full virtual machines, providing a balance between isolation and performance. ### Is Apple's container tool compatible with existing Docker images? Yes, Apple's `container` is fully OCI-compatible. It consumes and produces standard OCI images, so images built with Docker can run unchanged on Apple's `container` and vice versa. The `container run` command accepts the same image references and options you would use with Docker. ### Why does Apple use a VM per container instead of namespaces? macOS is not a Linux kernel, so it cannot provide native Linux namespaces. While Docker Desktop works around this by running a single Linux VM for all containers, Apple's approach leverages the **Virtualization framework** and **vmnet** to provide stronger isolation. This design gives each container the security properties of a full VM while maintaining the usability of container commands, reducing the risk of cross-container attacks or kernel exploits affecting the host.