I periodically need to set up a USB hard drive so that its files can be shared between different operating systems.  I recently tried to update my practices.  This is a record of my findings.

The short version of my conclusions is: If you need good portability between Windows, OSX, and Linux (and you’re only writing data from Windows or Linux), use NTFS.  If you don’t need filesystem metadata like ownership or permissions and your files and disks aren’t too large, FAT32 might work for you.

§ FAT32

FAT32 is often the filesystem of choice for flash drives and smaller media.  Windows, OSX, and Linux all have native support for it.  It can span filesystems up to 2TB in its default configuration and up to 16TB or so if you tweak its block size.  It cannot support files larger than 4GB, nor does it include support for file ownership and permissions.  Its support for filenames longer than eight characters plus a three character extension is something of a hack.  It’s not case-sensitive (though it does preserve case).

Basically, FAT32’s biggest strength is its cross-platform support.  In most other areas it falls down when compared to more modern filesystems.


NTFS is a bit nicer than FAT32 in many ways.  It supports filesystems up to 16EB in size, and you can fill all of that space with a single file, if you want.  (In other words, there’s effectively no limit on file size other than the size of the containing filesystem.)  Filenames can be up to 255 characters long, just like other modern filesystems.  NTFS supports POSIX-compatible file ownership and permissions, hard and soft links, case-sensitivity, and sparse files, all of which which make it a lot more interoperable with Unix than FAT32.

Its main drawback is that it’s proprietary and what support exists has been reverse-engineered.  Windows supports NTFS, since it came from Microsoft originally, back to Windows 2000 and Windows NT 3.5.  Max OSX has had native read-only support since 10.3 (Panther).  Linux can read and write NTFS volumes via NTFS-3G, which runs in userspace (via FUSE).  NTFS-3G doesn’t give tremendous performance when accessing SATA or SAS disks, but modern hardware is more than capable of keeping up with USB-attached disks.  (At least for USB 2.0; I haven’t done comparisons with USB 3.0 hosts and disks.)

§ exFAT

exFAT is an attempt to extend the aging FAT family (FAT12/FAT16/FAT32) to support larger files.  Its size limits are somewhat crazy:  maximum recommended filesystem size is 512TB (though it can theoretically go up to 64ZB); maximum file size is 127PB.  Like FAT32, it does not support file ownership or permissions, hard or soft links, or sparse files, and it’s case-preserving but not case-sensitive.  Many of the unsupported features aren’t completely necessary in a lot of USB drive use-cases, so their absence isn’t an immediate strike against it.

The main problem with exFAT is that it’s not just proprietary (like NTFS) but patented.  It’s supported natively from Windows Vista on (and Windows XP can be patched for support) and in OSX 1.6.5 (Snow Leopard) and later, but Linux support is currently very shaky and difficult to distribute because of the patents.  Even if Linux support were not a factor, the fact that only relatively new OSes have support for exFAT would disqualify it from consideration in many situations.


UDF is something of a dark horse in this space.  It was originally designed as a general-purpose, portable filesystem.  It’s only really seen adoption, though, as the filesystem used on DVDs and Blu-Ray disks.  Because it’s used for DVDs, though, it’s natively supported by all three of the major desktop OSes: Windows (back to Windows 95), MacOS (back to OS 9), and Linux (back to kernel 2.2).

Like FAT32, UDF can only have 232 blocks in its filesystem, so it only goes up to 2TB filesystems with 512-byte blocks (which is what hard drives would use; the UDF spec requires that the UDF block size match the disk block size).  Like NTFS, though, its only limit on file size is the size of the containing filesystem.  Also like NTFS, it supports POSIX ownership, permissions, and metadata; ACLs; and hard and soft links, as well as being case-sensitive.  It doesn’t support sparse files.

It would seem that UDF would be the best choice for a portable filesystem:  it’s natively supported in practically every OS and it supports most of the features you’d want in a modern filesystem.  Unfortunately, OS bugs hamper its usefulness.

Although Linux will read UDF filesystems with blocksizes other than 512 bytes (even though that’s outside the official specification), Windows is pickier and will only recognize conforming layouts with 512-byte blocks.  That immediately limits Windows to 2TB disks or smaller when using UDF.  Also, Windows expects UDF to span the entire disk, with no partitions, so you can’t even work around the size limitation by making multiple sub-2TB partitions.

Linux, on the other hand, has had problems with UDF with 512-byte blocks.  It handles filesystems with 2KB blocks just fine, but you need to be running relatively new kernels for the 512-byte blocks (required for Windows compatibility) to work.  (Two problems I’ve run into are disks being reported full when they’re not and Linux not seeing UDF volume labels.)

The Linux problems have been fixed, but only just this year.  Losing compatibility with all older Linux systems knocks out one of the biggest advantages that UDF has over NTFS.  In my case, I have RHEL 5 and 6 systems that aren’t going to get these fixes for a really long time.  (Maybe by RHEL 5’s 2017 EOL, assuming RHEL 7 includes all of the fixes.)

§ ext[234]/HFS+

There are also the native disk formats for Linux (the ext2/3/4 series) and MacOS (HFS/HFS+).  While there’s at least some support for accessing them from other systems, that support is generally less robust than the NTFS-3G project’s work, so if you’re going to require third-party support for cross-platform access you might as well use NTFS.

§ Other filesystems

There are a lot of other filesystems out there.  Linux has native support for quite a lot of them.  OSX and Windows don’t.  In cases where installing third-party drivers on OSX or Windows is an accepted requirement, some other filesystem might be a good choice.  In my opinion, though, NTFS, FAT32, maybe UDF, and possibly exFAT cover the filesystem portability use-cases pretty well by themselves; it would have to be a very specific set of circumstances for a different filesystem to be a better choice than one of those four.