Filesystem

X-Plane loads thousands of texture files during flight — filesystem choice and SSD configuration directly affect loading times and in-flight texture streaming. This page covers SSD hardware recommendations, filesystem comparison (Ext4, Btrfs, XFS), mount options, a step-by-step RAID-0 setup, and backup strategies.

Hardware Recommendations

SSD Types and Sizes

For optimal performance, an NVMe SSD (PCIe 3.0 or better 4.0) with at least 1 TB capacity is recommended. NVMe SSDs offer significantly higher read and write speeds — up to ~3500 MB/s (PCIe 3.0) or ~7000 MB/s (PCIe 4.0) — compared to SATA SSDs, which reach a maximum of 550 MB/s. The higher speed is achieved through a direct connection to the PCIe bus, bypassing the slower SATA interface.

The minimum size of 1 TB is recommended because X-Plane 12 with full global scenery requires approximately 80–100 GB, and third-party scenery and add-ons can quickly add several hundred GB more. Additionally, at least 10–15% free storage space is recommended for optimal performance, as SSDs use this headroom for wear leveling and garbage collection.

Multi-Drive Configurations

A combination of SSD and HDD provides a practical solution for storing X-Plane data. The main program and frequently used scenery should be stored on the SSD, while rarely needed scenery or backups can be stored on the HDD. Distributing X-Plane data across different SSDs enables load balancing through parallel operation of the drives. However, this configuration increases complexity in file management and may result in slightly longer loading times.

Multi-SSD Configurations with RAID

For users seeking maximum performance, combining multiple SSDs in a RAID array (Redundant Array of Independent Disks) offers interesting possibilities. The most common configurations are RAID-0 and RAID-1, each with its own advantages and disadvantages.

RAID-0 (Striping) distributes data across all SSDs and offers the highest throughput for sequential operations. With three SSDs, sequential read/write speeds can approach triple that of a single drive — random I/O improvements are smaller. However, RAID-0 offers no redundancy — failure of one SSD leads to loss of all data.

RAID-0: No redundancy

Any single drive failure destroys all data in the array. A backup strategy is essential — see Backup Strategies.

RAID-1 (Mirroring) stores data redundantly. In standard RAID-1, data is mirrored across two drives, providing 50% usable capacity. Btrfs RAID-1 stores two copies regardless of drive count, so with three SSDs, approximately half the total capacity is available. Read performance improves (reads can be distributed), but write speed corresponds to a single drive.

When planning a RAID setup, the following aspects should be considered:

All SSDs should be identical (same capacity and speed)
Total capacity must be sufficient for X-Plane and all scenery
Choice of filesystem (Btrfs, ZFS) can affect RAID functionality

A detailed guide for setting up a RAID-0 configuration can be found in the section Practical Example: RAID-0 with Three SSDs.

Filesystem Types

Feature	Ext4	Btrfs	XFS
Type	Journaling	Copy-on-Write	Journaling
Default on	Most distributions	openSUSE, Fedora	RHEL
Write performance	Fast	Slightly slower under heavy writes	Fast
Read performance	Good	Good	Excellent for large files
Snapshots	No	Yes	No
Checksums	No (metadata only)	Yes (data + metadata)	No
Built-in RAID	No	Yes	No
Compression	No	Yes (zstd, lzo)	No
Complexity	Low	Medium	Low

Ext4 is the safe default — well-tested, fast, and simple. Btrfs adds snapshots, checksums, and built-in RAID at the cost of slightly more complexity. XFS excels at sequential reads of large files, making it a strong choice for scenery-heavy installations.

Optimizations

Using a single partition on an SSD simplifies management and allows X-Plane quick access to all data. Modern SSDs, especially NVMe models, suffer no significant performance degradation from fragmentation. With multiple partitions on an SSD, there is minimal overhead from partition switching. This impact is usually negligible with high-performance SSDs. Nevertheless, it is recommended to store X-Plane and related data on a single partition.

The right mount options can reduce unnecessary I/O overhead:

Option	Effect	Recommended for
`noatime`	Skips access time updates on reads	All filesystems on SSDs
`discard=async`	Asynchronous TRIM (Btrfs default since kernel 6.2)	Btrfs — usually not needed in fstab
`fstrim.timer`	Periodic TRIM via systemd timer	Ext4, XFS — preferred over `discard` mount option

Quick recommendation

For most users: NVMe SSD, Ext4 with noatime, enable fstrim.timer. That covers the essentials.

Ext4 example (/etc/fstab):

UUID=<ext4-uuid> /mnt/xplane ext4 defaults,noatime 0 2

Enable periodic TRIM:

sudo systemctl enable --now fstrim.timer

Practical Example: RAID-0 with Three SSDs

A user running X-Plane on a Linux system with three SSDs can set up a RAID-0 array with the Btrfs filesystem to maximize read and write speeds.

Important Note: Not all Linux distributions support Btrfs RAID-0 equally well. Ubuntu, Fedora, and openSUSE are particularly well-tested.

Prerequisites

Setting up a RAID-0 array requires three identical SSDs (same capacity and speed), ideally NVMe SSDs. The system should use a current Linux distribution such as Debian 13 (Trixie) and have the btrfs-progs package installed. Root or sudo privileges are required. It is important to note that all data on the SSDs will be deleted – backups should therefore be created beforehand.

Step-by-Step Guide

Identify SSDs
```
lsblk
```
Assuming the SSDs are /dev/sda, /dev/sdb, and /dev/sdc. Ensure there are no partitions or data on these drives.

Delete Partitions (if present)

sudo wipefs -a /dev/sda
sudo wipefs -a /dev/sdb
sudo wipefs -a /dev/sdc

This removes all existing filesystems and partitions.

Create RAID-0 with Btrfs
```
sudo mkfs.btrfs -d raid0 -m raid1 /dev/sda /dev/sdb /dev/sdc
```
- -d raid0: Data is striped across all three SSDs in RAID-0 mode
- -m raid1: Metadata is stored in RAID-1 mode (for additional filesystem metadata security)
- /dev/sda /dev/sdb /dev/sdc: The three SSDs forming the array
Create Mount Point and Mount Filesystem
```
sudo mkdir /mnt/xplane
sudo mount /dev/sda /mnt/xplane
```
Since Btrfs is a multi-device filesystem, mounting one device is sufficient – Btrfs automatically recognizes the other array devices.
Check Btrfs Status
```
sudo btrfs filesystem show /mnt/xplane
```
The output shows the three SSDs and confirms that data is striped in RAID-0 mode.

Enable TRIM Add the following line to /etc/fstab:

UUID=<btrfs-uuid> /mnt/xplane btrfs defaults,noatime 0 0

The UUID is determined with:

sudo blkid /dev/sda

Adjust Permissions
```
sudo chown $USER:$USER /mnt/xplane
```
Install X-Plane
```
cp -r /path/to/xplane /mnt/xplane/
```
Verify TRIM Btrfs enables discard=async by default on SSDs since kernel 6.2. Verify:
```
findmnt -o FSTYPE,OPTIONS /mnt/xplane | grep discard
```
Restart System and Test
```
sudo reboot
```
After restart, check mount status:
```
df -h /mnt/xplane
```

Performance Benefits and Important Notes

The RAID-0 setup with three SSDs can approach triple sequential throughput compared to a single SSD. For X-Plane's scenery loading (many small texture files), the improvement is smaller but still noticeable — shorter loading times and smoother texture streaming in complex environments.

All three SSDs must be identical, both in capacity and speed. The condition of the SSDs should be regularly checked, for example with the command sudo smartctl -a /dev/sda.

Backup Strategies

Backing up X-Plane data is a critical aspect of system configuration, especially with RAID-0 setups without redundancy. An effective backup strategy includes regular backups of important configuration files and settings (daily), complete backups of all X-Plane data including scenery and add-ons (weekly), and archiving of weekly backups for long-term storage (monthly).

Suitable backup media include external SSDs for fast backups and restores, NAS/RAID systems for redundant storage and network access, and cloud storage for additional security and access from various locations. The most important backup contents include the X-Plane main program and configuration files, scenery and add-ons, user data and settings, and log files for error analysis.

Tools like rsync or borg are used for automated backups:

# Example for daily backup with rsync
rsync -av --delete /mnt/xplane/ /backup/xplane/daily/

# Example for weekly backup with borg (Borg 2.x syntax)
borg -r /backup/xplane/weekly create $(date +%Y-%m-%d) /mnt/xplane/

Regular recovery tests are performed to verify backup integrity. The recovery process is documented and necessary tools are kept ready.

Topic	Page	Focus
Kernel Tuning	Kernel Tuning	NVMe power saving, writeback parameters
Monitoring	Monitoring	iotop, iostat, ioping for disk latency analysis
Load Dimensions	Load Dimensions	IO as a performance dimension
Configuration	Configuration	X-Plane file paths and data locations
Scenery Components	Scenery Components	What files X-Plane reads from disk