ENGINEERING NOTES

OpenMacFUSE: open-source FUSE for NTFS on Mac, with no kernel extension

OpenMacFUSE is an open-source, user-space FUSE layer for macOS, developed by NTFSTool, that lets NTFS, ext, exFAT and BitLocker volumes mount through the NFS client built into macOS instead of a kernel extension. It is released under the MIT license, is the default mount layer in NTFSTool Pro, and needs neither macFUSE nor FUSE-T. This article explains how it is built and compares it with FUSE-T on the same Mac, running the same NTFS engine.

NTFSTool engineering team · November 2026 · Versions tested: OpenMacFUSE c392a69, FUSE-T 1.0.49 · Source on GitHub

SUMMARY

  • Developed in-house. OpenMacFUSE is an NFSv4.0 server linked into the driver process that exposes the FUSE 2.x API. It is about 17,000 lines of C, implemented from RFCs 7530, 5531 and 4506 and released under the MIT license. It is one of a small number of open-source macOS FUSE implementations that need no kernel extension.
  • Speed. The gap is widest on metadata-heavy workloads: checksumming every file on a volume takes 23 s versus 797 s with FUSE-T, and deleting 10,000 small files is 6–9 times faster. Sequential reads and writes of large files on real USB drives show no measurable difference.
  • Memory. The driver process uses 45–51 MB of physical memory, regardless of file count or uptime.
  • Reliability. When USB power is cut during a write, the driver unmounts and exits within 0.5 s. When power returns, the volume mounts normally and no file has corrupted content; the only losses are writes completed in roughly the last second.
  • Maintainability. The protocol layer, the FUSE interface and the NTFS engine live in one codebase, so a problem in the mount layer can be traced and fixed directly, without waiting on a third party's release schedule.
35×Checksum every file on a volume
23 s vs. 797 s
46 MBPeak memory while reading 300 MB
381 MB with FUSE-T
0.45 sFrom power cut mid-write to driver exit
measured on a USB SSD
869automated checks
all passing on macOS 12

1 Background2 Architecture3 Performance4 Memory5 macOS semantics6 Failure handling7 Methodology8 Limitations9 ConclusionFAQ

1Background

Since macOS 11, loading a kernel extension requires the user to start up in macOS Recovery and switch the Mac to Reduced Security. For software aimed at everyday users, that route is no longer practical. There are two main ways to stay out of the kernel: Apple's FSKit (available from macOS 15.4 and used by NTFSTool's "Driver 2"), and the NFS client built into macOS. The second approach runs an NFS server on the local machine, translates file system operations into calls to a user-space driver, and mounts the result with mount_nfs. FUSE-T takes this approach and is its most mature implementation; it is the baseline for every comparison in this article.

We chose to implement this layer ourselves for three engineering reasons:

2Architecture

OpenMacFUSE is linked into the driver as a static library. When the driver starts, it listens on a local endpoint inside its own process and then calls the system's mount_nfs. Each COMPOUND request from the kernel NFS client is decoded, dispatched to the FUSE callbacks and answered within that one process. There is no second process, and no extra copy or context switch along the way.

FUSE-T Apps / Findersystem calls Kernel NFS clientpart of macOS NFS server processseparate process Driver processlibfuse-t + NTFS engine Disk TCPIPC Two user-space processes; each request crosses two process boundaries OpenMacFUSE Apps / Findersystem calls Kernel NFS clientpart of macOS Driver process (one process) OpenMacFUSENFSv4.0 server FUSE 2.xfunction calls NTFS engine Disk socket Guard process (0.3 MB)removes the mount if the driver dies
Figure 1 Request path. The FUSE-T side is drawn from its published design (a driver process plus a separate NFS server process). OpenMacFUSE puts the server inside the driver process, so the protocol layer reaches the file system engine through ordinary function calls.

Transport and mount options

macOS 26 and later use a Unix domain socket (proto=ticotsord). No port is opened, and other users on the machine cannot connect. The kernel client in macOS 12 fails on large writes over that transport, so earlier versions of macOS fall back to TCP on 127.0.0.1, with two server-side checks that the connection comes from the local mount. These are the options the system reported after a mount on macOS 27:

Test log · macOS 27.0.1 / arm64 · paths shortened
$ nfsstat -m <mount point>
NFS parameters: vers=4.0,ticotsord,port=/var/folders/…/openmacfuse.P1wAL0/s,hard,intr,
  noresvport,nocallback,negnamecache,nonamedattr,noacl,noaclonly,locks,noquota,
  rsize=262144,wsize=262144,readahead=16,dsize=32768,nordirplus,nodumbtimer,
  timeo=10,maxgroups=16,…,deadtimeout=60
Figure 2 Mount options. nonamedattr is the system client's default and determines how extended attributes are handled in section 5. nordirplus is our choice; its cost is covered in section 8.

Implementation choices

3Performance

OpenMacFUSE is 6 to 35 times faster than FUSE-T 1.0.49 on metadata-heavy workloads and on par for sequential reads and writes on real USB drives. Method: the same machine, the same volume image and the same NTFS engine source, linked once against OpenMacFUSE and once against FUSE-T 1.0.49. The image sits on the internal SSD and I/O goes through the system page cache, so Figure 3 measures the overhead of the mount layer plus the engine, not the disk. Real-drive results are listed separately in Table 1.

OpenMacFUSEFUSE-T 1.0.49Time; lower is better
First listing of a 40,000-entry directory (default at the time)6.4×
1.36 s
8.69 s
stat + MD5 of every file on the volume35×
22.8 s
796.9 s
Delete 10,000 4 KB files6–9×
1.86–2.26 s
11.2–20.7 s
Create then delete small files, 200,000 operations6.5×
205–218 s
1,365 s
Figure 3 Metadata-heavy workloads on a volume image, Apple M2 / macOS 27. The first-listing result was measured before AppleDouble filtering was enabled; with the current default it is 3.6 s, for the reason given in section 5.
Terminal screenshot: OpenMacFUSE mounts the image, lists a 40,000-file directory and shows driver memoryOpenMacFUSE
Terminal screenshot: FUSE-T mounts the same image, lists a 40,000-file directory and shows driver memoryFUSE-T 1.0.49
Screenshot A The same volume image mounted through each layer in turn on Intel i7 / macOS 12.7.6 (screenshots, with the commands left in frame). The first listing of a 40,000-entry directory takes 4.13 s versus 7.87 s. The second listing, right after, is answered from the system's directory cache and takes 0.53 s on both. Memory after mounting is 44 MB versus 210 MB; the FUSE-T figure is the driver process plus its NFS server process.
Table 1 · Real USB drivesOpenMacFUSEFUSE-T
SSD, sequential write 4.5 GB293–313 MB/s300 MB/s
SSD, cold read245–251 MB/s236–241 MB/s
SSD, directory tree walk0.25–0.30 s4.1–4.6 s
SSD, delete 2,000 small files0.82–0.86 s8.4–9.7 s
Hard drive, sequential write / read70 / 97 MB/s74 / 93 MB/s

SSD measured on Apple M2 / macOS 27; hard drive on Intel i7 / macOS 12.7. Sequential throughput is limited by the USB link and the drive itself; the differences are within measurement noise.

One result left out: small-file creation. After these benchmarks the default flush policy of OpenMacFUSE was made more conservative (section 6), which made small-file creation about twice as slow. The real-drive comparison with FUSE-T has not been repeated under the new policy, and we will not quote the old numbers until it has.

4Memory

OpenMacFUSE stays at 45–51 MB of physical memory regardless of workload or uptime; FUSE-T used 200 MB to 1 GB in the same tests. All values are physical footprint, the same measure as the Memory column in Activity Monitor. For OpenMacFUSE this is the single driver process; for FUSE-T it is the driver process plus its NFS server process. Both include about 35 MB of block cache that belongs to the NTFS engine.

OpenMacFUSEFUSE-T 1.0.49Peak memory; lower is better
Sequential read, 300 MB
46 MB
381 MB
Sequential write, 4 GB
47.5 MB
275.6 MB
Create then delete small files, 200,000 operations
47.5 MB
999.6 MB
Figure 4 Peak memory, Apple M2 / macOS 27, sampled every 0.2 s; all three workloads share one scale. Sixty seconds after the third workload ended, FUSE-T was still at 764 MB and OpenMacFUSE at 46.4 MB.
0 20 40 60 MB 0123456 h Start: 45 MBAfter 6 h: 51 MB
Figure 5 Six-hour run. A mixed load of reads, writes, creates and deletes for six hours on Intel i7 / macOS 12.7, sampled once a minute (one point per 20 minutes is plotted). A linear fit gives +0.27 MB per hour. At the end, every file passed verification and the number of open file descriptors was unchanged.

5macOS semantics

OpenMacFUSE keeps ._ files off the drive and maps NTFS attributes to their macOS equivalents.

Finder screenshot: an NTFS volume mounted through OpenMacFUSE, with no ._ files in the list
Screenshot B An NTFS volume mounted through OpenMacFUSE as it appears in Finder (macOS 12.7.6, screenshot). The volume is writable and the list contains no ._ files.

AppleDouble

By default the macOS NFS client does not use named attributes. It packs a file's extended attributes, resource fork and Finder info into an AppleDouble file named ._filename and sends it to the server with ordinary OPEN and WRITE operations. If the server simply stores what it receives, those files end up on the drive, where they show up as clutter in Windows.

This became more visible with macOS 26: the system attaches a com.apple.provenance attribute to every new file, so every file comes with a ._ companion. Writing one dataset of 40,000 small files through FUSE-T left 40,048 extra ._ files on the drive. A git repository on the volume showed 48 untracked files, and git fsck reported 67 errors.

OpenMacFUSE detects access to ._ files on the server, parses the AppleDouble content and writes each attribute into an NTFS alternate data stream of the main file. On read it rebuilds the AppleDouble file on demand. No separate file is created on disk and none appears in directory listings. On a drive that already contains ._ files, they are hidden, and each one is moved into the data stream the next time its main file is modified.

Two writes from the client photo.jpg._photo.jpg Stored as sent photo.jpg ._photo.jpg visible onWindows OpenMacFUSE photo.jpgmain data stream photo.jpg:<alternate stream>xattrs, Finder info, resource fork one fileon disk
Figure 6 Two outcomes of the same save. Alternate data streams are native to NTFS; Windows Explorer does not show them, and they travel with the main file when it is copied.

The cost is filtering during directory listing: the first listing of a 40,000-entry directory goes from 1.4 s to 3.6 s. We consider that a fair trade.

Other semantics

FeatureOpenMacFUSE behaviorObserved with FUSE-T
File name caseCase-insensitive and case-preserving by default, as on Windows. If the volume already holds names that differ only in case, the mount switches to case-sensitive automaticallyCase-sensitive
Unicode normalizationNFC and NFD forms of a name reach the same file (accented letters, Korean)Not tested
Hidden attributeThe NTFS HIDDEN bit and Finder's hidden flag map both waysNot mapped
Read-only attributeThe NTFS READONLY bit makes the file unwritable on macOSNot reflected
Creation timestat -f %B returns the creation time stored on diskAlways 0
Byte-range locksSupported; SQLite databases can be opened directly on the volumeNot tested

6Failure handling

External drives get unplugged without warning. That is normal use, not an edge case, and OpenMacFUSE has three mechanisms that remove the mount when it happens. An NFS-based mount layer carries one inherent risk: the mount is hard, so once the server stops answering, any process that touches the volume enters an uninterruptible wait and Finder stops responding. The mount layer has to guarantee that something always removes the mount point:

00.10.20.30.40.5 s USB power cut 0.19 swriter gets an error 0.21 smount point gone 0.45 sdriver exits
Figure 7 Timeline after a relay cuts power to a USB SSD during a write (one measured run, matching the log in Figure 8). Across five runs the range is 0.24–0.47 s. When the volume is idle, it depends on the probe interval and is about 1.3 s.
Test log, translated · 120 GB USB SSD · Intel i7 / macOS 12.7.6
== power cut: B-write1 (load: write, after the changes, NTFSTOOL_DRIVER_FSYNC=bounded)
  - after the cut: writer error at 0.19 s; mount point gone at 0.21 s;
    driver exit at 0.45 s; uninterruptible processes: 0
  [pass] power cut to full recovery 0.45 s (limit 10 s)
  - 303 files fsynced; last fsync return to device-loss detection 0.081 s
  [pass] mounts after the cut without ntfsfix (0.33 s)
Figure 8 Excerpt from the log of the same run. "Uninterruptible processes: 0" means no process was left stuck in a wait that signals cannot interrupt.

Consistency after power loss

After a power cut during a write, the volume now mounts without a repair tool in every test run, and no file comes back with wrong content. The mount layer can influence two things: whether the volume mounts without a repair tool once power returns, and how many of the writes already confirmed to the application survive. OpenMacFUSE makes three changes here:

USB SSD, power cut during a writeBefore the changesAfter (default policy)
Mounts without a repair tool after power returns3 of 5 runs failed on a $MFTMirr mismatchEvery run
Confirmed files lost per run12–191–27, all written in roughly the last second
Files with wrong contentSome files came back as all zeros0

"Before the changes" is the engine's behavior before this work; the same engine mounted through FUSE-T gave the same results. No file system can guarantee the last moment's data when a portable drive with no battery backup loses power mid-write. The aim here is to confine the loss to the most recent writes and leave the volume structure intact.

7Methodology

ItemDetails
HardwareMacBook Pro (Intel i7-4770HQ, 16 GB, macOS 12.7.6); Mac (Apple M2, 24 GB, macOS 27.0.1); 120 GB USB SSD, 1 TB USB hard drive, USB flash drive
ComparisonSame machine, same image, same NTFS engine source; only the mount layer changes. FUSE-T version 1.0.49
TimingWrite timings include sync; sequential reads run after an unmount and remount to avoid the client cache
Memoryri_phys_footprint from proc_pid_rusage, at 0.2 s intervals
Unplug and power lossA relay cuts the 5 V USB supply without unmounting first. After power returns, the volume structure is checked read-only, then the volume is mounted without repair and every file is compared
Correctness300 s of randomized read/write comparison (692,000 operations, 0 mismatches); 8 concurrent writers plus 2 recursive listings; volume structure checked after every run
Regression15 script suites with 869 checks covering NTFS read/write, macOS semantics, ext, exFAT and BitLocker volumes, plus fault injection: unplug, kill, hang and mount handshake timeout
Test log, translated · Apple M2 / macOS 27.0.1 · one read-write run (excerpt)
07:29:09   [pass] mounted
07:29:10   [pass] large file written
07:29:12   [pass] small files written
07:29:13   [pass] large file MD5 matches
07:29:13   [pass] all small-file MD5s match
07:29:13   [pass] rename / append / truncate / delete
07:29:13   [pass] case-insensitive open
07:29:13   [pass] no ._ files in the listing
07:29:13   [pass] extended attribute read and write
07:29:15   [pass] normal unmount
07:29:15   [pass] driver exited
07:29:15   [pass] guard process exited
Figure 9 A run counts as complete only when, after unmounting, both the driver and the guard process have exited and the volume structure check reports no errors.

8Limitations

9Conclusion

OpenMacFUSE is the default mount layer for Driver 1 in NTFSTool Pro; NTFS, ext, exFAT and BitLocker volumes are all mounted through it. Keeping the mount layer in our own codebase pays off in four ways:

FAQ

What is OpenMacFUSE?
OpenMacFUSE is the open-source, user-space mount layer developed by NTFSTool and built into NTFSTool Pro. It mounts NTFS, ext, exFAT and BitLocker volumes on macOS. It is an NFSv4.0 server that runs inside the driver process and uses no kernel extension.
Do I need to install macFUSE or FUSE-T to use NTFSTool Pro?
No. OpenMacFUSE, NTFSTool's own mount layer, ships inside NTFSTool Pro. It does not depend on macFUSE, FUSE-T or any kernel extension, and you never have to start up in macOS Recovery and reduce your Mac's security settings.
How does OpenMacFUSE compare with FUSE-T in performance?
On the same Mac with the same NTFS engine, checksumming every file on a volume takes 23 s with OpenMacFUSE versus 797 s with FUSE-T, and deleting 10,000 small files is 6 to 9 times faster. Sequential reads and writes of large files on real USB drives are on par. OpenMacFUSE's memory use stays at 45 to 51 MB, versus 200 MB to 1 GB for FUSE-T.
What happens if I unplug a drive in the middle of a write?
The OpenMacFUSE driver unmounts the volume and exits on its own in about 0.5 s, so Finder and other apps do not hang. The volume mounts normally when you plug the drive back in. Writes completed in roughly the last second before power was lost may be missing; the contents of other files are unaffected.
Why did NTFSTool write its own mount layer instead of using an open-source or third-party component?
The mount layer determines speed, memory use and what happens when something fails. With its own implementation, NTFSTool can trace and fix problems in a single codebase, and NTFS-specific semantics (case sensitivity, the hidden and read-only attributes, extended attributes) are handled alongside the file system engine.
Is OpenMacFUSE open source?
Yes. OpenMacFUSE is open source under the MIT license, and the code is on GitHub at ntfstool/openmacfuse. Any FUSE 2.x file system can link against it.

All data in this article was measured by the NTFSTool engineering team; the methodology is in section 7. FUSE-T is its author's project and is not affiliated with NTFSTool. OpenMacFUSE is an independent project and is not affiliated with macFUSE or its authors.

Need help? Email service@ntfstool.com — a real person replies within 48 hours.
Help center