Composefs

Composefs is a Linux filesystem and userspace tooling project that provides a read-only, content-addressed, composable filesystem layer for container images and other immutable content delivery use cases (storage and filesystems).

• Read-only, content-addressed filesystem format for immutable trees (storage and filesystems).
• Composition of multiple content trees into a single mounted view, with support for container image layering (container runtime storage).
• Deduplication of file content across images by addressing data by cryptographic hash (storage optimization).
• Kernel filesystem implementation with associated userspace tools for creating and managing composefs images (systems software).
• Integration focus for container ecosystems where reproducible, verifiable root filesystems are required (cloud-native infrastructure).

More About Composefs

Composefs is a Linux filesystem and toolset that targets content-addressed, read-only filesystem trees, with an emphasis on container image storage and other immutable deployment models (storage and filesystems). It is designed to represent a filesystem as a manifest of content-addressed objects, enabling reproducible and verifiable mounts from a shared content store. This model aligns with container image layering patterns, where multiple layers of content are combined to form a final root filesystem.

The project provides a kernel filesystem implementation that can mount a composefs image, which is essentially a manifest describing files and directories along with references to the underlying content objects (systems software). File data is addressed by cryptographic hash, allowing deduplication across multiple images and reuse of objects that are already present in the content store (storage optimization). Because composefs is read-only, it supports deployment scenarios where immutability and predictable state are required, such as container root filesystems and system images.

Composefs also includes userspace tools that build and manipulate composefs images from existing directory trees or from container image metadata (developer tooling). These tools generate the manifest and link it to the content-addressed object store, which can be shared across many images. By decoupling the manifest from the actual file data, composefs allows operators and platform teams to manage many filesystem views over a single pool of content.

In enterprise environments, composefs is relevant for container runtime storage, immutable infrastructure, and image distribution workflows (cloud-native infrastructure). It can be used to mount container root filesystems in a way that reduces storage overhead, because different images that share file content will point to the same underlying objects. The read-only nature of the filesystem supports security and compliance goals related to immutability, auditability, and predictable rollback behavior, since the composed view is defined by the manifest and underlying content hashes.

From an architectural perspective, composefs fits alongside container runtimes, image registries, and content stores that already work with content-addressed blobs (cloud-native infrastructure). It does not replace orchestration or scheduling components; instead, it operates at the storage and filesystem layer, exposing a mounted view that higher-level platforms can use as a root filesystem or base image. In directory taxonomies, composefs is best categorized under Linux filesystems, container storage, and immutable image delivery tooling.