# Volume Mount Types in Apple Container: Bind, Tmpfs, and Anonymous Mounts Explained

> Explore Apple Container volume mount types: bind, tmpfs, and anonymous mounts. Learn how virtiofs and in-memory mounts work for efficient container management.

- Repository: [Apple/container](https://github.com/apple/container)
- Tags: deep-dive
- Published: 2026-06-19

---

**The Apple Container runtime supports four volume mount types—bind mounts (internally rewritten as virtiofs), direct virtiofs filesystem shares, tmpfs in-memory mounts, and Docker-style volumes that can be either named or anonymous—parsed through the `Parser.mount(_:relativeTo:)` method in [`Parser.swift`](https://github.com/apple/container/blob/main/Parser.swift).**

The `apple/container` runtime provides flexible storage options for containerized workloads through its mount specification parser. Understanding the supported volume mount types is essential for configuring persistent storage, temporary caches, and host filesystem access. This article examines how the runtime handles bind mounts, tmpfs volumes, and anonymous volumes at the code level.

## Supported Volume Mount Types

The mount type whitelist is defined in [`Sources/Services/ContainerAPIService/Client/Parser.swift`](https://github.com/apple/container/blob/main/Sources/Services/ContainerAPIService/Client/Parser.swift) within the `mountTypes` array (lines 24–28). The parser accepts four distinct mount categories, each handled differently during container initialization.

### Bind Mounts (Rewritten to Virtiofs)

When you specify `type=bind`, the parser automatically rewrites the type to `virtiofs` (lines 95–99). This implementation detail means that while the CLI accepts traditional bind mount syntax, the runtime treats all host-directory mounts as **virtiofs** filesystem shares for improved performance and consistency.

```swift
let bindMount = try Parser.mount("type=bind,src=/host/data,dst=/container/data")
// Internally converted to virtiofs

```

### Direct Virtiofs Shares

Explicit `type=virtiofs` mounts bypass the rewriting logic and directly configure a virtiofs share between host and container (lines 99–101). This is the default filesystem-share type used internally by the runtime.

### Tmpfs Mounts

For in-memory temporary storage, the runtime supports `type=tmpfs` (lines 101–103). These mounts create ephemeral filesystems that reside entirely in RAM, useful for sensitive data or high-performance temporary files that should not persist on disk.

```swift
let tmpfs = try Parser.mount("type=tmpfs,dst=/tmp,size=64m,mode=755")
// Creates in-memory filesystem with specified size and permissions

```

### Named and Anonymous Volumes

The parser recognizes `type=volume` for Docker-style volume management (lines 104–106). When you provide a source name, the runtime mounts a named volume. If the source is omitted, `VolumeStorage.generateAnonymousVolumeName()` automatically creates an **anonymous volume** (lines 70–74), setting `isAnonymous: true` in the resulting `ParsedVolume` structure.

```swift
// Named volume
let namedVol = try Parser.mount("type=volume,src=myData,dst=/data")

// Anonymous volume (no source specified)
let anonVol = try Parser.mount("type=volume,dst=/cache")
// Generates automatic volume name via VolumeStorage.generateAnonymousVolumeName()

```

## Technical Implementation in Parser.swift

The `Parser.mount(_:relativeTo:)` method serves as the central validation point for all mount specifications. At lines 30–44, the parser performs directory existence checks for bind mount sources. Volume name validation and anonymous volume generation occur at lines 45–74, where the code determines whether to use the provided name or generate a UUID-based identifier.

The type-switching logic (lines 95–108) handles the transformation of bind mounts to virtiofs, validates tmpfs options, and distinguishes between volume types. This centralized parsing ensures consistent behavior across the CLI and API layers.

## Summary

- **Bind mounts** specified as `type=bind` are automatically rewritten to `virtiofs` in [`Parser.swift`](https://github.com/apple/container/blob/main/Parser.swift) (lines 95–99)
- **Virtiofs** serves as the default filesystem-share type for host-directory access
- **Tmpfs** provides in-memory storage through explicit type specification (lines 101–103)
- **Anonymous volumes** are created automatically when `type=volume` lacks a source name, using `VolumeStorage.generateAnonymousVolumeName()` (lines 70–74)
- All mount types are validated through `Parser.mount(_:relativeTo:)` in [`Sources/Services/ContainerAPIService/Client/Parser.swift`](https://github.com/apple/container/blob/main/Sources/Services/ContainerAPIService/Client/Parser.swift)

## Frequently Asked Questions

### Does Apple Container support traditional Linux bind mounts?

While the CLI accepts `type=bind`, the runtime immediately rewrites this to `virtiofs` according to lines 95–99 in [`Parser.swift`](https://github.com/apple/container/blob/main/Parser.swift). This means all host-directory mounts leverage virtiofs for improved performance rather than traditional kernel bind mounts.

### How does the runtime distinguish between named and anonymous volumes?

When parsing `type=volume`, the parser checks for a source name at lines 104–106. If no source is provided, it invokes `VolumeStorage.generateAnonymousVolumeName()` at lines 70–74 to create a unique identifier, setting the `isAnonymous` flag to true.

### Can I limit the size of a tmpfs mount?

Yes. The parser accepts size options within the mount specification string, such as `size=64m`, which are passed through to the tmpfs configuration (lines 101–103).

### What file contains the mount type whitelist?

The supported mount types are defined in the `mountTypes` constant at lines 24–28 of [`Sources/Services/ContainerAPIService/Client/Parser.swift`](https://github.com/apple/container/blob/main/Sources/Services/ContainerAPIService/Client/Parser.swift), which includes virtiofs, bind, and tmpfs, while volume handling occurs in the subsequent switch statement.