Linux Kernel Formalizes New File System Acceptance Criteria

According to a report by Phoronix, a formal set of guidelines for accepting new file systems into the Linux 7.2 kernel has been merged. This marks a significant step in addressing a long-standing issue among kernel developers regarding the quality control of file systems. Like the optimization reported in the article “Linux 7.2 Kernel Speeds Up /proc/filesystems Reads by Up To 444%,” this move is part of broader efforts to enhance the maintainability of the kernel’s internal structure.

The Background: Proliferation of File Systems

As an open-source ecosystem, Linux has seen numerous file systems proposed over the years. Recently, new file systems like FTRFS and VMUFAT have aimed for kernel integration, while multiple NTFS drivers have also emerged, leading to an ever-growing array of options. However, as Phoronix highlights, many of these new proposals are “insufficiently maintained, have limited users, and lack innovation compared to existing alternatives.”

The core of the problem lies in the increasing burden on Linux’s storage and file system development teams, particularly on Virtual File System (VFS) maintainers. Once a file system is merged into the kernel, its code remains part of the kernel indefinitely, even if maintenance is abandoned. Someone must handle bug fixes and security patches, which has led to a fragmentation of resources among core developers.

Details of the New Guidance

The newly merged document is now available in the Linux 7.2 kernel’s Git tree as Documentation/filesystems/adding-new-filesystems.rst. Initially proposed in early May 2026, it was approved without objections shortly thereafter. According to the Phoronix article, the main requirements are as follows:

First, any new file system must demonstrate sufficient uniqueness compared to existing implementations. Simple rehashes of existing functionality will not be accepted. Second, it is explicitly stated that for niche use cases, a user-space file system implemented via FUSE (Filesystem in Userspace) may be a better option. Before adding code to the kernel space, developers are advised to consider whether implementing the file system with FUSE would suffice.

Moreover, file systems aiming for mainline integration must meet several additional conditions. These include utilizing the latest VFS interfaces, providing necessary user-space utilities like mkfs and fsck, being testable in an accessible way, and including comprehensive documentation.

Implications and Significance for the Industry

The merging of this guidance can be seen as a progression in the governance of Linux kernel development. While the kernel has historically accepted a wide range of code—ranging from drivers to architecture support—the formalization of quality standards has been somewhat fragmented. This initiative is particularly novel in its explicit inclusion of the risks associated with abandoned maintenance as an evaluation criterion.

Unlike concerns surrounding the continuous bloat of NVIDIA’s GPU drivers as kernel modules, file systems have a direct impact on the core functionality of the kernel. By clarifying the criteria for new file system inclusion, the burden on VFS maintainers could be reduced, allowing more resources to be focused on improving the quality of existing file systems.

However, by raising the bar for innovation, this guidance may inadvertently encourage developers to focus more on prototyping file systems using FUSE rather than integrating them into the kernel. While FUSE indeed lowers the barrier to entry for kernel development, it often lags behind kernel space implementations in terms of performance. The acceptable performance trade-offs will likely be a matter of ongoing evaluation as these guidelines are applied in practice.

Editorial Opinion

In the short term, it is highly likely that the number of new file systems merged into the Linux kernel from version 7.2 onward will decrease. This could make it more difficult for prototype file systems or smaller, hobbyist-developed file systems to gain acceptance. While this change is likely to be welcomed by VFS maintainers, it may raise concerns among those who value the diversity of the community. For instance, specialized file systems optimized for specific hardware might face rejection under these stricter criteria.

From a long-term perspective, we anticipate an acceleration in FUSE-based file system development. By implementing file systems in user space rather than kernel space, development cycles can be shortened, and risks reduced. Indeed, even now, advanced features in file systems like btrfs and ZFS are being tested via FUSE. This guidance strongly encourages validation in user space before committing code to the kernel, reducing the risk of locking flawed file system designs into the kernel.

As an editorial team, we pose the following question: How should the balance between “innovation” and “maintenance sustainability” be made more transparent? While this guidance represents progress, it still relies on subjective judgment in some areas. Should objective metrics—such as the number of active users, GitHub stars, or active contributors—be included as part of the criteria? Additionally, should efforts be made to define a clearer “retirement” process for file systems that are no longer maintained within the kernel? These questions await further discussion at forums like the Linux Foundation and the Kernel Maintainers Summit.

References

• Phoronix: Linux Enacts Guidance To Tighten Acceptance Of New File-Systems Into The Kernel — Published on June 16, 2026