In 2005, Sun Microsystems released ZFS. It was the most advanced filesystem ever created.

In 2010, Oracle bought Sun for $7.4 billion and proceeded to destroy everything Sun built.

But ZFS escaped. Open source cannot be killed. Only forked.

What Sun Built:

Traditional filesystems trust your hardware. They assume disks do not lie. They assume RAM does not flip bits. They assume controllers do not corrupt data silently.

These assumptions are false.

Disks lie. RAM flips. Controllers corrupt. Your data rots while you sleep, and traditional filesystems never notice.

ZFS trusts nothing.

Feature	Traditional FS	ZFS
Data integrity	Trust hardware	Checksum everything
Silent corruption	Undetected	Detected and corrected
RAID	Separate layer (mdadm)	Built-in (RAID-Z)
Snapshots	Maybe, limited	Unlimited, instant, free
Volume management	Separate (LVM)	Built-in
Compression	Maybe	Built-in, transparent
Copy-on-write	No	Yes
Self-healing	No	Yes (with redundancy)

ZFS checksums every block. Every read is verified. If a checksum fails and you have redundancy, ZFS retrieves the correct data from another copy and heals the corruption automatically.

Your filesystem fixes itself while you sleep.

Copy-on-Write:

Traditional filesystems overwrite data in place. If power fails mid-write, you have corruption. fsck exists because overwrites are dangerous.

ZFS never overwrites. New data is written to new locations. The old data remains until the new write completes. Then pointers update atomically.

Traditional write:
1. Start overwriting block
2. Power fails
3. Block is half old, half new
4. Corruption. Run fsck. Pray.

ZFS write:
1. Write new block to free space
2. Power fails
3. Old block still intact
4. No corruption. No fsck. No prayer required.

ZFS does not need fsck. ZFS is always consistent. The concept of “filesystem repair” is a symptom of inferior design.

RAID-Z:

Traditional RAID has the write hole problem. If power fails during a RAID-5 write, parity becomes inconsistent. Your array lies about data integrity.

RAID-Z eliminates the write hole. Copy-on-write means parity is always consistent. Full-stripe writes only.

Level	Protection	Capacity
RAID-Z1	1 disk failure	n-1 disks
RAID-Z2	2 disk failures	n-2 disks
RAID-Z3	3 disk failures	n-3 disks
Mirror	n-1 disk failures	n/2 disks

No separate RAID controller required. No hardware RAID card with proprietary firmware. No battery backup unit. ZFS handles everything in software, correctly.

Hardware RAID controllers are a liability. They hide disk errors from the filesystem. They have firmware bugs. When the controller dies, your array dies with it unless you find the exact same model.

ZFS talks directly to disks. ZFS sees every error. ZFS trusts no controller.

Snapshots:

A ZFS snapshot is instant. It costs nothing until data changes. You can have thousands.

# Create a snapshot
zfs snapshot tank/data@before-upgrade

# List snapshots
zfs list -t snapshot

# Rollback if upgrade fails
zfs rollback tank/data@before-upgrade

# Access snapshot contents directly
ls /tank/data/.zfs/snapshot/before-upgrade/

Snapshots are not backups. But snapshots let you undo mistakes instantly. Upgrade failed? Rollback. Deleted wrong file? Retrieve from snapshot. Ransomware encrypted your files? Rollback to before infection.

The Scrub:

ZFS can verify every block on every disk against its checksum:

# Start a scrub
zpool scrub tank

# Check status
zpool status tank

A scrub reads every block, verifies checksums, and repairs any corruption found (if redundancy exists). Run scrubs monthly. Find corruption before it compounds.

Traditional filesystems have no equivalent. They cannot tell you if your data has silently rotted. ZFS knows.

The ARC (and The Cost):

ZFS uses RAM as a read cache called the ARC (Adaptive Replacement Cache). More RAM means faster reads. ZFS uses what you give it.

RAM usage:
- 1GB: Minimum, painful
- 8GB: Acceptable for small pools
- 32GB: Comfortable
- 128GB+: ZFS becomes unreasonably fast
- 256GB+: You now understand why Sun engineers had stock options

The rule: 1GB of RAM per 1TB of storage is comfortable. More is better. ZFS rewards RAM investment.

The Historical Context:

When Sun invented ZFS in 2005, 4GB of ECC RAM cost approximately $200.

In 2026, 128GB of ECC DDR5 for your ZFS server costs more than some people’s monthly mortgage payment.

Sun engineers designed ZFS when RAM was cheap and getting cheaper. They did not anticipate:

• DDR5 pricing
• Supply chain disasters
• Cryptocurrency miners buying everything
• The death of Moore’s Law’s economic corollary

ZFS wants RAM. ZFS assumes you have RAM. ZFS was designed by engineers who had Sun’s hardware budget, not your hardware budget.

The filesystem is perfect. The economics are painful.

Budget accordingly. Or explain to your spouse why the NAS cost more than the family vacation.

For reference: 30TB of RAM in 2026 costs more than what Oracle paid to acquire Sun Microsystems in 2010.

Oracle paid $7.4 billion for Sun. Sun’s engineers assumed RAM would continue getting cheaper. Instead, Oracle got a filesystem that demands hardware Oracle’s own customers cannot afford.

The irony writes itself.

Why Oracle Tried to Kill It:

Sun open-sourced ZFS under the CDDL license. Oracle inherited this.

The CDDL is incompatible with the GPL. Linux cannot include ZFS in its kernel. This was likely intentional — Sun competed with Linux.

Oracle continued ZFS development as closed source. They sued companies using ZFS. They let OpenSolaris die.

But the open-source release could not be revoked. The community forked it.

OpenZFS:

The community took the last open-source ZFS release and continued development independently. OpenZFS now runs on:

Platform	Status
FreeBSD	First-class, in base
Linux	Works, legal gray area
macOS	OpenZFS on OS X
Windows	In development
illumos	Native home

FreeBSD includes ZFS in the base system. No licensing debates. No module loading tricks. Just zpool create and you have the most advanced filesystem available.

Linux requires building ZFS as a separate module. Canonical ships it in Ubuntu. The legal situation is “probably fine” but lawyers are nervous. The GPL/CDDL conflict remains unresolved.

Why FreeBSD + ZFS:

FreeBSD made ZFS a first-class citizen:

• Boot from ZFS (root on ZFS)
• Boot environments (clone root, upgrade, rollback if failed)
• jails on ZFS (instant clones for isolation)
• Native kernel integration, not a module hack

# Create a boot environment before upgrade
bectl create pre-upgrade
bectl activate pre-upgrade

# Upgrade goes wrong? Boot back to original
bectl activate default

FreeBSD with ZFS is the most reliable server platform available. Your data is checksummed. Your upgrades are reversible. Your mistakes are recoverable.

What ZFS Cannot Do:

ZFS cannot:

• Shrink a pool (expand only)
• Remove a vdev from a pool (added recently, limited)
• Fix hardware that is actually dead
• Replace backups (snapshots are not backups)

ZFS is not magic. It is engineering. Good engineering has limits. Know them.

The Lesson:

Sun Microsystems understood data integrity. They built a filesystem that trusts nothing, verifies everything, and heals itself.

Oracle bought Sun and tried to kill the gift. But open source persists. OpenZFS development continues. FreeBSD ships it in base. Your data remains safe.

Every other filesystem is gambling with your data. “Probably fine” is not integrity. “Usually works” is not reliability.

ZFS checksums every block. ZFS verifies every read. ZFS heals corruption before you notice it.

This is what a filesystem should be.

Sun is dead. Oracle is a lawsuit factory. But ZFS survives, and so does your data.

Storage configuration in Pyongyang:

We do not use hardware RAID controllers. We do not trust firmware we cannot audit. Every storage system runs ZFS on FreeBSD.

• Monthly scrubs detect corruption
• RAID-Z2 minimum on all pools
• Snapshots before every operation
• Boot environments before every upgrade

Our data does not rot. Our filesystems do not lie. Our checksums match.

Thank you, Sun. We remember what you built.

— Kim Jong Rails, Supreme Leader of the Republic of Derails