Platform Architecture

An HDD-native distributed filesystem, designed from the block layer up.

Leil treats SMR drives as first-class citizens, not as an afterthought to flash-optimized storage systems.

Application Layer
PyTorch / JAX / HuggingFace / any POSIX tool
VFS
Leil Coordination Layer
Consistent hashing, metadata replication (3 nodes)
coordinator
SMR Write Scheduler
Band-pointer coalescing, sequential flush per band
write-sched
Drive Pool
16TB to 20TB SMR drives, erasure-coded 4+2 or 8+2
HDD pool
Architecture Overview

Three layers, each with a single job.

POSIX VFS interface

Leil mounts like any Linux filesystem. Directories, inodes, file permissions, rename atomicity, and fsync semantics all work exactly as expected. Your training code does not need modification.

Coordination layer

Data is distributed across nodes using consistent hashing. Metadata is replicated on 3 nodes for durability. The coordination layer handles node membership, failure detection, and rebalancing transparently.

SMR write scheduler

The write scheduler converts the random write pattern of a general-purpose filesystem into the sequential band-ordered writes that SMR drives require. It maintains per-band write pointers and a coalescing buffer that aggregates concurrent writes before issuing them as a single sequential stream.

Kernel-level integrationLeil operates in the Linux VFS layer, not as a FUSE userspace filesystem. Full kernel-path performance, no IPC overhead.
No application changesMount a path, point your training script at it. No S3 SDK, no custom data loader, no checkpoint format changes.
Linear scalingAdd nodes to increase both capacity and aggregate throughput. Rebalancing happens online with no cluster downtime.
Standard Linux toolingdu, find, rsync, inotify, and standard backup tools all work. No proprietary management plane required for basic operations.
SMR Write Alignment

The engineering problem at the core of SMR adoption.

SMR drives use shingled magnetic recording: each track is written so it overlaps the outer edge of the track below it. This increases track density by 25 to 30 percent compared to conventional magnetic recording, which is where the 2.5x capacity advantage originates.

The catch: each track belongs to a write band, and writes within that band must be sequential. If your filesystem issues a random small write anywhere in a band, the drive must read the entire band into a cache buffer, modify it, and rewrite the whole band sequentially. This is called the "read-modify-write" penalty, and it reduces effective throughput by 60 to 80 percent compared to the drive's rated sequential write speed.

Generic filesystems (ext4, XFS, Btrfs) were designed for random-write capable drives. They issue writes wherever their allocation maps point, constantly triggering band-level read-modify-write cycles on SMR drives. The drives run at a fraction of their rated speed, making SMR look slower than conventional drives.

Leil's approach The write scheduler maintains per-band write pointers for every drive in the pool. All concurrent writes targeting a band are coalesced in a memory-mapped buffer. When the buffer reaches band-size (or a flush timer fires), the scheduler issues a single sequential write stream to the drive. SMR drives then operate at their rated 200 to 240MB/s sequential write throughput, not the 20 to 40MB/s random-write fallback.
Data Layout and Redundancy

Erasure coding over replication for maximum capacity.

Leil uses Reed-Solomon erasure coding (configurable 4+2 or 8+2) rather than replication to maximize usable capacity per drive. A 4+2 configuration means 6 drives hold what was originally 4 drives worth of data, with any 2 drives able to fail simultaneously without data loss. This yields 66% storage efficiency vs 33% for triple replication.

Stripe width is tuned to SMR band size to maximize both write efficiency and rebuild throughput after a drive failure. Metadata is separately replicated on 3 nodes for durability, keeping metadata operations fast even when data nodes are being rebuilt.

Failure domains are drive-bay-level by default, meaning a bay backplane failure or power supply failure counts as one failure event, not multiple simultaneous drive failures.

Reed-Solomon 4+266% storage efficiency. Any 2 drives can fail. Standard for production deployments below 200TB.
Reed-Solomon 8+280% storage efficiency. Optimized for large clusters above 500TB where rebuild time matters.
Online drive replacementFailed drives are replaced without cluster downtime. Rebuild uses spare bandwidth, not burst I/O.
Metadata replication (3x)Metadata operations do not go through the erasure coding path. Always 3x replicated for low-latency inode access.
POSIX Compatibility

Full POSIX semantics. Your tools work unchanged.

Directories and inodes

Full hierarchical namespace. Symlinks, hardlinks, extended attributes, directory permissions all work.

Rename atomicity

Atomic rename across the cluster. Safe for checkpoint write patterns that use temp file + rename.

fsync semantics

fsync() guarantees data durability to the cluster. Required for safe checkpoint commits.

Lock-free sequential reads

Sequential read paths are lock-free. Large read-ahead buffers saturate SMR sequential read bandwidth for training data access.

Framework compatibility

PyTorch DataLoader, HuggingFace Datasets, TensorFlow tf.data, and standard UNIX checkpoint paths work without code changes.

Standard VFS path

The mount point appears as a standard Linux VFS path. Mounts automatically on node restart, survives kernel upgrades.

Performance Characteristics

Numbers from an actual pilot cluster.

12-node pilot, 8 drives per node, 16TB SMR per drive. Internal benchmark, March 2026.

2.8 GB/s
Sequential read / node
aggregate throughput
1.4 GB/s
Sequential write / node
band-aligned path
~72s
Checkpoint write latency
100GB checkpoint
~60%
Cost savings vs NVMe
at 200TB usable

Source: internal benchmark on 12-node pilot configuration, 8x 16TB SMR drives per node, March 2026. Sequential read throughput is network-limited at high node counts. Checkpoint latency measured with torch.save() on a 100GB model state dict.

Ready to benchmark your workload?

We run pilot clusters with early-access partners to validate performance on your specific dataset and checkpoint sizes.