Defragger: a Linux defragmenter built on the quiet art of knowing when to stop

Guillaume Binet posted Defragger to Hacker News this week, a graphical Linux disk defragmenter he built after missing the Windows block map for over 20 years. The project is dual-licensed under MIT or Apache 2.0, written in Rust 1.85 with Qt 6 and KDE Kirigami, and it targets ext4 plus FAT16/FAT32 volumes. The nostalgia hook is real, but the substance is elsewhere: Binet’s tool is a case study in how to build privileged systems software without letting the GUI touch the kernel, and it arrives at a moment when AI infrastructure is rediscovering that storage layout still matters.

The honest lede is that modern Linux filesystems do not need weekly defragging. Binet says so himself in the README. What pushed the project past nostalgia was a concrete problem: he needed a reproducible storage layout while testing a high-throughput logger, and fragmentation plus extent allocation were adding measurable variance even on NVMe. That detail matters. It is the same reason AI training runs and inference servers obsess over data locality, and it is the same reason filesystem behavior shows up in benchmark noise that engineers blame on the model or the framework first.

Defragger is not a wrapper. The README is explicit: it uses FS_IOC_GETFSMAP for allocation maps, FS_IOC_FIEMAP to map individual files, and EXT4_IOC_MOVE_EXT to move extents online. FAT16/FAT32 writes are offline only, with validation of both FAT copies and file chains before redirecting directory metadata. The design constraint that stands out is privilege: the GUI and CLI never run as root. Privileged operations go through a narrow PolicyKit-authorized helper over D-Bus, and that helper accepts validated, opaque operation IDs rather than arbitrary paths or commands.

That is the genuinely novel part of this project. Most filesystem tools, including the venerable e4defrag that Defragger avoids shelling out to, run with full privileges or ask for sudo. Binet’s architecture splits the difference: a root-owned D-Bus helper with a minimal surface, PolicyKit for authorization, and an unprivileged Qt frontend. The README includes a just demo command that decompresses a deliberately fragmented ext4 fixture, attaches it as a temporary loop device, and opens the GUI without touching real volumes. The demo needs sudo only for attaching the loop device; the application itself stays unprivileged.

For AI builders, the lesson is transferable. The same pattern applies to GPU drivers, container runtimes, and model-serving daemons: the component that needs elevated access should be as small as possible, and it should accept opaque tokens rather than free-form instructions. Defragger’s helper validates operation IDs, not paths. That is a design choice worth copying in any system where a user-facing interface talks to a privileged backend.

The project also carries a quiet warning for anyone building on top of filesystem behavior. Binet needed reproducible layouts for a high-throughput logger, and he found that extent allocation added variance even on NVMe. AI workloads are worse. Training checkpoints, sharded datasets, and vector indexes all suffer from fragmentation-induced latency spikes that are invisible in microbenchmarks and brutal in production. The industry has responded with specialized formats like WebDataset and with filesystems tuned for throughput, but the underlying problem is the same one Defragger visualizes: the physical layout of data on disk still shapes performance, even when the disk is flash.

That is the deeper point of the moving-blocks interface Binet missed. The Windows defragmenter was not useful because Windows needed weekly defragging. It was useful because it made the machine legible. You could watch the filesystem reorganize itself, and that visualization built an intuition for how storage actually works. Defragger recreates that legibility for Linux, with an adaptive block map that shows files, free space, and metadata allocation. For a generation of engineers who have only known abstracted cloud storage, that kind of visibility is rare and valuable.

There are limits. The README is upfront that this is alpha filesystem software. The ext4 path has received the most testing; FAT write support is newer and should first be used with disposable volumes. The project targets KDE Plasma and requires systemd, PolicyKit, and an active graphical PolicyKit agent. It is not a drop-in replacement for enterprise storage management. But the scope discipline is itself instructive: Defragger does not try to defrag everything. It analyzes exFAT but does not defragment it. It compacts FAT16/FAT32 offline but leaves ext4 compaction to the kernel’s own mechanisms. Knowing what not to touch is a feature.

The AI angle here is not that Defragger is an AI tool. It is not. It is a systems tool written in Rust, and its relevance to AI is indirect but real. AI infrastructure runs on Linux filesystems, and the performance of those filesystems still depends on allocation behavior that most tools hide. Binet’s logger test is a small example of a large pattern: reproducibility in storage layout is a prerequisite for reproducible performance, and reproducible performance is a prerequisite for meaningful benchmarking of models and serving stacks.

The project also models a healthy attitude toward the relationship between tools and the systems they manage. Defragger does not pretend to be necessary. It is, in Binet’s own words, “occasionally useful but weirdly satisfying.” That honesty is rare in a field where every tool claims to be essential. The tool earns its place by making the machine legible and by doing one narrow thing well, with a privilege boundary that respects the user’s data.

For AI builders, the takeaway is twofold. First, revisit your storage assumptions. If Binet saw measurable variance from extent allocation on NVMe, your training pipeline likely has similar hidden costs. Second, study the architecture. The PolicyKit helper pattern, the opaque operation IDs, the offline-only writes for FAT, the demo that uses a loop device so you can try it without risk: these are the details that separate tools people trust from tools people run once and uninstall.

Defragger is a small project, but it is built like a piece of infrastructure. The README links to architecture notes covering the privilege boundary, validation rules, and update ordering. The code is dual-licensed, the build is reproducible, and the demo is safe by construction. That is the standard AI infrastructure should hold itself to, and it is a standard most tools miss.

The moving blocks are back, and this time they are rendered by a Rust application that never runs as root. That is the quiet achievement: Binet rebuilt the interface he missed, and in doing so he built a template for privileged systems software that the rest of the industry would do well to copy. The next time a training run stalls on an unexplained I/O spike, the fix might not be a bigger model or a faster GPU. It might be a filesystem layout you can finally see.