1. Provable integrity – it checksums all data (and meta-data), which makes it
   possible to detect hardware errors (hard disk corruption, flaky IDE cables..).
   ZFS helped to detect a faulty power supply after only two hours of usage,
   which was previously silently corrupting data for almost a year.

2. Atomic, transactional updates – means that the on-disk state is consistent
   at all times, there’s no need to perform a lengthy filesystem check after
   forced reboots/power failures.

3. Instantaneous snapshots and clones – it makes it possible to have hourly,
   daily and weekly backups efficiently, as well as experiment with new system
   configurations without any risks.

4. Built-in (optional) compression

5. Pooled storage model – creating filesystems is as easy as creating a new
   directory. You can efficiently have thousands of filesystems, each with it’s
   own quotas and reservations, and different properties (compression algorithm,
   checksum algorithm, etc..).

6. Very high scalability. You can have an almost infinite number of snapshots
   and more files / bytes in your filesystems than it is even theoretically
   possible to store with every atom in Earth. Performance scales linearly
   with the number of mirrors you add to your pool.

7. Built-in stripes (RAID-0), mirrors (RAID-1) and RAID-Z (it’s like software
   RAID-5, but without the requirement of uninterruptible power or battery-
   backed power to prevent catastrophes due to sudden power outages.
   It is more efficient in resyncing failed arrays due to ZFS’s copy-on-write
   transactional model.

…and many others (variable sector sizes, adaptive endianness, incremental
backups over the network…)

This project is a port of the ZFS filesystem to FUSE/Linux, done as part of the
Google Summer of Code 2006 initiative.