File systems using FUSE.
This list is being split into categories
- ArchiveFileSystems - accessing files inside archives (tar, cpio, zip, etc.) or generating archives
- CompressedFileSystems - accessing files in a compressed image (gz, zlib, LiveCDs, etc.)
- DatabaseFileSystems - storing files in a relational database (MySQL, BerkeleyDB, etc.) or ones allowing searching using tags or SQL queries
- EncryptedFileSystems - storing files in a more secure way by using a secret key
- MediaFileSystems - storing files on media devices such as cameras and music players or accessing and categorizing media files
- HardwareFileSystems - provide access to weird hardware
- MonitoringFileSystems - provide notification when a file changes
- NetworkFileSystems - storing files on remote computers, including file servers and web sites
- NonNativeFileSystems - traditional disk-based file systems that aren't standard on Linux (NTFS, ZFS, etc.)
- UnionFileSystems - merging multiple file systems into a single tree
- VersioningFileSystems - file systems that remember old versions of files and ones which provide access to version control systems
If you find outdated information, feel free to correct it.
PLEASE READ THIS BEFORE ADDING A NEW ENTRY
- put your entry in a category if possible
- new entries go at the *end*
- keep the descriptions short and sweet, a couple of lines is perfectly adequate. Details can go on the homepage or a separate article in this Wiki
- no new tags please, preferably only Author, Homepage, Description
Author: Bob Smith / bsmith at linuxtoys org
RTA is a specialized memory resident interface to the internal data of your application. It is not a stand-alone server but a library which attaches to your program and offers up your program's internal structures and arrays as tables in a database and as files in a virtual file system.
KIO Fuse Gateway
Author: Alexander Neundorf / neundorf at kde org
This gateway makes it possible to mount ioslaves or a general ioslave-gateway via fuse and make them this way available to all linux apps.
Author: Miklos Szeredi / miklos at szeredi hu
This is a modified LUFS daemon, which uses the FUSE kernel module. It is binary compatible with existing LUFS filesystems, so no recompilation is needed.
Author: Started by Michael Still / mikal at stillhq com, continued by Francois Barre
mcachefs is a simple caching filesystem for Linux using FUSE. It works by copying the file that you asked for when the file is opened, and then using that copy for all subsequent requests for the file. This is really a fairly naive approach to caching, and will be improved in the future.
Logic File System
Author: Yoann padioleau (firstname.lastname@example.org)
It's something like Spotlight from Apple and WinFS from Microsoft, just better. For details see LfsDetails.
Author: Christian Pellegrin (chripell at gmail dot com)
Gateway between FUSE and Gnome VFS2. Allows you to mount everything that Nautilus can and looks like a directory.
Author: Jacob Bower (jacob.bowerNO@SPAMic.ac.uk (remove the caps))
A FUSE based automounter.
Author: Miklos Szeredi / miklos at szeredi hu
Loopback mount filesystem- or disk-images without root privileges. All filesystems present in the Linux kernel are supported. It works by mounting the image inside a User Mode Linux instance and exporing it with FUSE. Despite the crude approach it's reasonably fast.
Author: David Boddie / david at boddie org uk
The fuse_adfs module uses FUSE to present the contents of ADFS reading facilities. The filesystem translates ADFS-style filenames to Unix-friendly ones and adds suffixes to filenames to help applications recognize certain types of files.
Author: Victor Porton
Simply mirrors a directory, just like a directory hardlink. Intended mainly for testing and example.
Author: Victor Porton
Dereferences all symlinks (symbolic links) in a directory. When a symlink is moved, it is automatically updated to continue to point to the same file.
fsfipi & vaves
Author: Václav Jůza / vaclavjuza at gmail dot com
Homepage: http://fsfipi.sourceforge.net (not yet finished)
fsfipi: A framework supporting a cascade of filters, which modify the behaviour of a filesystem. Each filter uses the same interface for the higher level (i. e. the requests, what operations this filesystem shall do) and for the lower level interface (performing the file operations). Only the lowest level filter uses actual system calls to store files on the real file system (localfs) or there is a possibility of making sshfs-like lowest level filter. The only highest level filter now is fuse_interface, which implements a fuse filesystem daemon and sends the requests to the lower level filter. vaves: a filter for this framework, implementing a very configurable versioning file system.
Author: Georges Kesseler
a simple way of managing a vast amount of data over multiple CD-R media by simulating all files on the CDs as if they were online on the harddisk. When a file is accessed, a dialog box asks for the correct CD. So any program can be used to acces the data without needing to know the files are on CD. Scripts are included for migrating data to CD (which was the more difficult work). Note that this project has not been updated since 3 years.
Author: David Collett
Maintainer: Kristofer Henriksson
MP3FS is a read-only FUSE filesystem which transcodes FLAC audio files to MP3 on the fly when opened and read.
Author: Frank Reerink
Yacufs is a virtual file system that is able to convert your files on-the-fly. It allows you to access various file types as a single file type. For instance you can access your music library containing .ogg, .flac and .mp3 files, but see them all as if being .mp3 files.
Author: Ben Martin
libferris is a virtual filesystem that exposes various hierarchical data including: native (kernel disk IO with fam), XML (mount an XML file as a filesystem), DB4, xmldb, Evolution, Firefox, Emacs, LDAP, HTTP, FTP, eet, sockets, RDF/XML, RDF/bdb, and mbox.
Author: Matthew Keller
Light and fast, allowing you to mount any folder tree as a read-only filesystem that fully supports reading extended attributes and ACLs.
Author: Elizeu Santos-Neto <email@example.com>
BloggerFS is a filesystem that allow Blogger users to manipulate posts on their blogs via a file interface.
... is a FUSE-based file system. You may think of it, as a downloader with the speed of light. (Does this belong in NetworkFileSystems?)
Author: Martin Pärtel <martin dot partel at gmail dot com>
Mirrors a directory to another directory (similar to mount --bind). Allows changing the permissions inside the mirrored directory in a fairly flexible way.
Author: Krzysztof Burghardt <krzysztof (at) burghardt (dot) pl>
ClamFS is a FUSE-based user-space file system for Linux with on-access anti-virus file scanning through clamd daemon.
Author: Daniel Fischer <df.code at notabilis dot ort>
Ramfuse is a dynamically growing RAM file system written in perl. Due to perl's memory handling, it's not dynamically shrinking though. :-)
Author: Gregor Zurowski
Author: Kristofer Henriksson
FilterFS (Filter File System) is a FUSE-based virtual filesystem that allows filtering existing filesystems. Filters consist of include/exclude rules which are stored in a filter chain, similar to the way iptables stores IP filtering rules for network packets. The virtual filesystem can be accessed through a specified mount point where all files are included and excluded according to the rules found in the filter chain. Rules can be provided with command line parameters or options in the system's fstab file.
Author: Gabriel Burca (gburca dash fuse at ebixio dot com)
This FUSE file system allows the user to mount a directory read-only and filter the files shown in the read-only directory based on regular expressions found in the optional /etc/rofs-filtered.rc configuration file.
Author: Miguel Scapolla / virtual800 at yahoo dot com dot ar
A virtual filesystem with big files for testing.
Author: Theodoros V. Kalamatianos / nyb at users dot sourceforge dot net
A read-only FUSE filesystem that transparently applies file conversion filters.
Author: Florian Zumbiehl <firstname.lastname@example.org>
ChunkFS is a filesystem that allows you to mount an arbitrary file or block device as a directory tree of files that each represent a chunk of user-specified size of the mounted file. ChunkFS was written for making space-efficient incremental backups of encrypted filesystem images using rsync.
NHFS - nonhierarchical file system
Author: Robert Freund / rfreund at uos dot de
NHFS allows you to file any file into any number of directories. Likewise, you may place any directory into as many directories as you like. NHFS therefore allows you to create a nonhierarchical directory structure with polyhierarchically connected files. This is a proof-of-concept.
Author: Jean Diraison / jean dot diraison at ac-versailles dot fr
TSKmount, is a free Fuse filesystem written in perl and based on The Sleuth Kit tools. It is intended to provide an easy way to recover deleted files over ext2, fat and ntfs filesystems.
Author: Luis Otavio de Colla Furquim / luisfurquim at gmail dot com
Chiron FS implements replication at the filesystem level like RAID 1 does at the device level. The replicated filesystem may be of any kind you want; the only requisite is that you mount it.
vmware-mount is a utility to mount partitions of a VMware virtual disk (.vmdk) . for a long time vmware-mount was sort of a hack which worked in combination with vmdk-loop and NBD. it seems the new version is build around fuse and it looks much better. vmware-mount is proprietary software being included in latest VMware Server 2.0 Beta.
Reduces the disk space used by a subversion working copy with large and/or many files.
A read-only peer-2-peer file system that allows sharing of files from different machines. Features include fault tolerance, load balancing, and providing a unified file view.
Author: Vitaly "_Vi" Shukela
Read output of "ls -lR" or "LIST -R" on FTP servers and converts it to filesystem based on parsed information. May be used for offline FTP browsing or similar tasks.
Author: Bob Carroll
TracFS is a mountable POSIX virtual file system that allows you to read a Subversion repository through the Trac web interface.
Author: Thanassis Tsiodras
A simple Python/FUSE-based filesystem, that shields files against data corruption (bad sectors, faulty IDE cabling, bad power supplies, etc).
Authors: Markus Pielmeier and Peter Prohaska
tagfs is used to organize your documents using tags. To see how it works read the demo
Author: Stef Bon
fuse-workspace, actually an overlay fs, is a copy of fusexmp, part of the FUSE source. Fuse-workspace does not mirror the root (/) under the mountpoint, but the contents of the parameter --bind-directory=DIR, which defaults to /. It has the ability to continue -like a symlink- somewhere else, while the user does not notice this. This is very useful to make use of the automounter, while the user does not notices this at all. Through this cooperation with the automounter it's possible to offer the user a directory with access to all kinds of resources, like local devices as USB sticks and remote resources like SMB (=Windows and/or Samba) shares, FTP, SSH. This fuse fs is part of a bigger construction (mount.md5key) which creates a powerfull, intuitive GoboLinux like environment for the common user. It's simular as Gnome VFS, but fuse-workspace works on the filesystem level, and as such does not depend on the (graphical) environment. It offers the same functionality on the text console.
Author: Sebastian Pipping / sebastian at pipping org
Bind-mounts a folder in read-only mode and hides all files and folders that do not have the extended file system attribute (xattr) "user.public" set. Can be used to reveal a subset of files to the public while keeping both internal and public documents together in the same tree. Written in Python, licensed under GPL 3 or later. See also: rofs-filtered.
Author: Vitaly "_Vi" Shukela
Description: Mount one file to another (with offset and append_only support)
Examples: # Simplest mode echo qqq > source touch mountpoint fusefile source mountpoint # 1KB random file (frandom is a fast urandom) fusefile /dev/frandom mountpoint -r -S 1024 -M 0100666 # Instead of "losetup -r -o" fusefile /dev/sda sda1_readonly -r -S 1024 -O $((63*512)) -S $((626535*512)) -M 0100600 # Append-only public log using FUSE fusefile /var/log/mylog publiclog -a -M 0100777 -o allow_other # Force a file to be "regular" fusefile /dev/uba1 mountpoint -w -M 0100600 -S `blockdev --getsize64 /dev/uba1`
Author: Vitaly "_Vi" Shukela
Description: Copy-on-write using FUSE and sparse files
fusecow original_file mountpoint_file copyup_file
Originally mountpoint_file is the same as original_file, but when changed changes are redirected to copyup_file and copyup_file.map (and original_file is kept intact).
Mount reiserfs in really-read-only mode Safer whole-HDD-access for virtual machines
Author: Multiple, including "h2o" on VirtualBox forums, and Terry Ellison
Mounts any virtual hard disk format understood by VirtualBox, including VDI, VMDK and VHD. Each partition of the virtual disk is exposed as a file, as is the disk as a whole. There is no primary maintainer, but several versions exist on GitHub, and the version in Debian's 'virtualbox-fuse' package is well-maintained.
Author: GNU GRUB
Mounts any filesystem format understood by GRUB 2, including: Amiga FFS & SFS; Be FS; HFS & HFS+; FAT, exFAT & NTFS; Minix; UFS; btrfs; ext2/3/4; JFS; NILFS2; Reiser 3; ISO 9660 & UFS; romfs; squashfs 4; cpio & tar.
Filesystems are read-only, and features such as permissions and modification dates are not supported. Although many formats are supported, speed is rather poor. Versions that compile on Mac OS X are available here and here.
Author: Dave Vasilevsky / dave at vasilevsky ca
Exposes a block special device as a regular file, for the benefit of utilities that treat them differently.
Author: François Hissel / francois dot hissel at gmail
Mirrors a folder but may replace executable files by their output, or pass some files through an executable filter.
Rules in the command line tell which files should be processed this way. Dynamically-generated files are marked as read-only.
Author: Jonny Tyers
pCacheFS provides a simple caching layer for other filesystems, which can make slow, remote filesystems seem very fast to access. The cache does not disappear when you start/stop pCacheFS or reboot - it is persistent.
It is designed for caching large amounts of data on remote filesystems that don't change very much, such as movie/music libraries.
Any filesystem can be cached, however, and the cache itself can be stored on any other filesystem, enabling a variety of more novel uses.
Stores the audio and ID3 data of MP3 files separately. The MP3 file is stored as ID3 data only, with a reference pointing to the audio data. The audio data is merged in at run-time. The original use case is for keeping ID3-only data in version control - versioning whole MP3s is slow and uses too much disk space (VCSs are optimised for small text files).
Author: Vitaly "_Vi" Shukela <email@example.com>
Allows implementing simple FUSE filesystems using a bunch of shell (or whatever) scripts. Useful for prototyping some FUSE filesystems (you can change implementation of FUSE functions without remounting the filesystem) or where the speed is not needed. "video_frames" - example using execfuse that "mounts" video file using ffmpeg to access its frames as image files.