# How Apple’s Container Architecture Differs from Docker’s Shared‑Kernel Model

> Discover how Apple's container architecture uses per-container VMs for hardware isolation, unlike Docker's shared kernel model. Learn the key differences.

- Repository: [Apple/container](https://github.com/apple/container)
- Tags: architecture
- Published: 2026-07-08

---

**Apple’s container platform implements a per‑container lightweight virtual machine architecture that provides hardware‑level isolation, contrasting sharply with Docker’s shared‑kernel approach that relies on Linux namespaces and cgroups.**

Apple’s open‑source `apple/container` repository introduces a fundamentally different container strategy than traditional Linux container runtimes. Instead of sharing the host kernel between containers, Apple’s solution spins up individual micro‑VMs for each workload using the Apple Virtualization framework. This architectural choice impacts everything from image building to network isolation, offering stronger security boundaries at the cost of slightly higher startup overhead.

## Isolation Model: Shared‑Kernel vs. Per‑Container VM

The primary distinction lies in how each platform isolates workloads from the host system and from each other.

### Docker’s Shared‑Kernel Approach

Docker containers run directly on the host operating system, sharing the same kernel while using **namespaces**, **cgroups**, and **SELinux/AppArmor** for isolation. All containers access the host kernel through system calls, meaning a kernel‑level vulnerability potentially compromises every running container simultaneously.

### Apple’s Micro‑VM Architecture

In `apple/container`, each container executes inside its **own lightweight virtual machine** created by Apple’s Virtualization framework. As implemented in [`ContainerPlugin/ServiceManager.swift`](https://github.com/apple/container/blob/main/ContainerPlugin/ServiceManager.swift), the runtime launches a separate VM per container, ensuring complete kernel separation. A compromise within one container remains confined to its specific micro‑VM, leaving the host kernel untouched.

## Technical Implementation in the Apple Container Codebase

The repository’s Swift‑based architecture replaces Docker’s daemon‑centric design with a modular VM orchestration pipeline.

### Image Resolution and Disk Image Creation

Unlike Docker’s layered tar archives, Apple’s builder converts container images into VM‑compatible disk images. In [`ContainerBuild/BuildImageResolver.swift`](https://github.com/apple/container/blob/main/ContainerBuild/BuildImageResolver.swift), the system resolves image references and prepares the filesystem, while [`ContainerBuild/Builder.swift`](https://github.com/apple/container/blob/main/ContainerBuild/Builder.swift) constructs the final disk image used for boot:

```swift
// ContainerBuild/Builder.swift – simplified build flow
let resolver = BuildImageResolver()
let image = try resolver.resolveImage(named: "my-app:latest")
let builder = Builder(image: image)
try builder.build(to: "/tmp/my-app.img")

```

This disk image mounts as the root filesystem for the micro‑VM, providing true filesystem isolation rather than Docker’s union‑fs overlay approach.

### VM Lifecycle Management

The **`container-runtime`** binary (installed via [`scripts/install-init.sh`](https://github.com/apple/container/blob/main/scripts/install-init.sh)) handles VM orchestration instead of a long‑running daemon. The [`ServiceManager.swift`](https://github.com/apple/container/blob/main/ServiceManager.swift) file manages the creation and teardown of individual VMs:

```swift
// ContainerPlugin/ServiceManager.swift – VM launch sequence
let vm = try VirtualMachineConfiguration()
vm.bootLoader = try BootLoader()
vm.storageDevice = try DiskImage(path: "/tmp/my-app.img")
try vm.start()

```

Each invocation spins up a fresh VM, boots the disk image, and establishes an isolated execution environment.

### Command Execution Inside Containers

Once the VM is running, commands execute within that isolated environment through [`ContainerBuild/TerminalCommand.swift`](https://github.com/apple/container/blob/main/ContainerBuild/TerminalCommand.swift):

```swift
// ContainerBuild/TerminalCommand.swift – exec inside the VM
let command = TerminalCommand(arguments: ["ls", "-la"])
let output = try command.run(in: vm)
print(output)

```

### Networking and Security Entitlements

Apple containers eschew Docker’s shared bridge (`docker0`) in favor of dedicated virtual network interfaces. The repository uses **`container-network-vmnet`** entitlements defined in `signing/container-network-vmnet.entitlements` to grant each VM privileged network access without sharing bridges between containers.

Additional entitlements in `signing/container-runtime-linux.entitlements` grant the VM necessary privileges while maintaining the security boundary between guest and host.

## Filesystem and Performance Characteristics

**Docker** shares the host filesystem through layered union‑fs mounts, enabling near‑native I/O performance but sharing the same kernel page cache. **Apple’s containers** utilize read‑only or copy‑on‑write disk images (as seen in [`BuildImageResolver.swift`](https://github.com/apple/container/blob/main/BuildImageResolver.swift)), ensuring each micro‑VM owns its filesystem state.

This design introduces slightly higher startup latency due to VM boot time, but leverages Apple‑optimized hypervisors to minimize overhead. The result is **hardware‑level isolation** with performance characteristics suitable for development workloads.

## Developer Experience and Tooling

While Docker uses `docker build` and `docker run` commands against a persistent daemon, Apple provides a Swift‑based build pipeline through [`ContainerBuild/Builder.swift`](https://github.com/apple/container/blob/main/ContainerBuild/Builder.swift) and [`ContainerBuild/BuildPipelineHandler.swift`](https://github.com/apple/container/blob/main/ContainerBuild/BuildPipelineHandler.swift). The repository includes Docker‑compatible syntax examples in `examples/container-machine-vscode/Dockerfile`:

```dockerfile

# examples/container-machine-vscode/Dockerfile

FROM apple/container:latest
COPY . /app
RUN swift build -c release
CMD ["swift", "run"]

```

This allows developers to leverage familiar Dockerfile patterns while targeting Apple’s VM‑based runtime.

## Summary

- Apple’s container architecture uses **per‑container micro‑VMs** rather than shared‑kernel isolation, leveraging the Apple Virtualization framework.
- **[`ContainerBuild/Builder.swift`](https://github.com/apple/container/blob/main/ContainerBuild/Builder.swift)** and **[`BuildImageResolver.swift`](https://github.com/apple/container/blob/main/BuildImageResolver.swift)** convert Docker‑style images into bootable VM disk images instead of layered tar archives.
- **[`ContainerPlugin/ServiceManager.swift`](https://github.com/apple/container/blob/main/ContainerPlugin/ServiceManager.swift)** orchestrates individual VM lifecycles without requiring a persistent daemon like `dockerd`.
- Network isolation uses **dedicated virtual NICs** and **`container-network-vmnet`** entitlements rather than shared bridges.
- The approach trades minimal startup overhead for **stronger security boundaries** and true kernel separation between containers.

## Frequently Asked Questions

### Does Apple’s container architecture support Docker images?

Yes. According to the `apple/container` source code, the build system can resolve and convert Docker‑compatible images into VM‑ready disk images. The repository includes example Dockerfiles in `examples/container-machine-vscode/Dockerfile` demonstrating that existing container definitions work with Apple’s toolchain, though the runtime execution differs significantly.

### What are the security advantages of per‑container VMs over Docker’s shared kernel?

Because each Apple container runs in its own micro‑VM with a separate kernel instance, a kernel‑level exploit within one container cannot affect the host or other containers. Docker’s shared‑kernel model means all containers rely on the same host kernel; a vulnerability there compromises the entire container fleet.

### How does networking differ between Apple containers and Docker?

Docker containers typically communicate through a shared bridge interface (`docker0`). Apple containers use the **`container-network-vmnet`** entitlement defined in `signing/container-network-vmnet.entitlements` to establish dedicated virtual network interfaces per VM. This prevents network traffic leakage between containers without complex bridge policies.

### Is there a performance penalty for using micro‑VMs instead of shared‑kernel containers?

Apple’s architecture incurs slightly higher startup costs due to VM boot time compared to Docker’s near‑instantaneous namespace creation. However, the implementation leverages Apple‑specific hypervisor optimizations to minimize runtime overhead, making the per‑container VM approach suitable for development environments where isolation outweighs boot latency.