macFUSE

macFUSE is an implementation of the FUSE (Filesystem in Userspace) framework for macOS. It allows for the creation and mounting of unconventional filesystems by running in user space. The software acts as a bridge between the operating system kernel and applications that implement the logic of a filesystem. FUSE-based systems can obtain data from various sources such as the network, memory, or online services. This technology facilitates the development of filesystems without needing to program kernel extensions. macFUSE is used by developers and end-users to extend the file capabilities of macOS.

★★★★★

5.0(1 ratings)

• FUSE Implementation. macFUSE provides a compatibility layer that implements the FUSE interface on macOS. This allows filesystems originally developed for other platforms like Linux to run. The core component is a kernel extension that manages communication between the operating system and user-space drivers. The implementation supports standard file operations: reading, writing, listing, and attribute management.
• Multiple API Compatibility. The package includes support for libfuse2 and libfuse3, which are the reference implementations of the Linux FUSE interface. These libraries allow existing FUSE filesystems to work on macOS with minimal modifications. Additionally, optional extensions are provided for macOS-specific features, improving native integration.
• User-Space Development. Filesystems created with macFUSE run as regular processes in user space. This approach eliminates the need to program kernel extensions, reducing development complexity. Programmers can use standard debugging tools and libraries. Running in user space increases system stability, as a failure in the filesystem does not affect the operating system kernel.
• Development Framework. macFUSE.framework offers an object-oriented API for creating filesystems on macOS. It is designed for use with languages like Swift and Objective-C. The framework abstracts low-level details of the FUSE interface, providing a more straightforward programming model. Developers can implement file operations by overriding methods of specific classes.
• Filesystem Portability. Systems developed with the standard FUSE API maintain a high degree of portability across operating systems. A filesystem created for macFUSE can be adapted to Linux or Windows with minor changes. This feature allows for maintaining a shared codebase for multiple platforms. The core logic of the filesystem, written in a high-level language, remains independent of the operating system.
• Operation Interception. The kernel component of macFUSE intercepts system calls related to file operations. These operations are redirected to a user-space process through a defined communication mechanism. The process responsible for the filesystem responds with the requested data or executes the required action. The interception is transparent to applications, which interact with the FUSE filesystem as if it were a native one.
• Legacy System Compatibility. macFUSE includes an optional compatibility layer for filesystems developed with previous versions of the software. This layer ensures that older projects, based on the original MacFUSE API, continue to function. Developers can progressively migrate their implementations to more modern APIs. Backward compatibility preserves the existing investment in filesystem development.
• Execution Without Kernel Extension. In recent versions of macOS, macFUSE incorporates a new FSKit-based backend that allows filesystems to run entirely in user space. This architecture eliminates the need to enable a kernel extension in recovery mode. Installation and configuration are performed without system restarts. The approach aligns with modern macOS security restrictions on kernel extensions.
• Support for Multiple Data Sources. Filesystems built with macFUSE can present data from non-traditional origins. This includes network connections, databases, cloud services, or even other filesystems. The filesystem logic transforms this data into a standard file and directory hierarchy. Applications access the data through the operating system's normal file interface.
• Command Line Tools. The installation package includes command-line utilities for managing FUSE filesystems. These tools allow mounting and unmounting volumes, diagnosing problems, and obtaining status information. Operations can be integrated into automation scripts and system administration workflows. The tools provide control over mount parameters and specific configuration options.
• Structured Communication Mechanism. Communication between the kernel extension and the user-space process uses a defined message protocol. This protocol serializes file operations and their parameters for transmission between processes. File data is transferred using shared memory buffers or file descriptors. The mechanism ensures adequate performance for input and output operations.
• Permission and Security Management. FUSE filesystems respect the macOS permission and security model. Operations are executed with the privileges of the user who mounted the filesystem. The mechanism prevents unprivileged processes from accessing data outside their permissions. Integration with the security subsystem maintains the operating system's protection guarantees.

The development of macFUSE began as a port of the Linux FUSE software to macOS. The original implementation was created by Benjamin Fleischer in the mid-2000s. The project has been maintained by different contributors over time. The current version is a reimplementation that leverages modern macOS technologies. The code is written primarily in C and Objective-C, with additional components in Swift.