-
Notifications
You must be signed in to change notification settings - Fork 1.2k
Filesystems
If you find outdated information, feel free to correct it. The list is in alphabetical order.
1fichierfs
Author: Alain Bénédetti / alainb06 at free fr
Homepage: https://gitlab.com/BylonAkila/astreamfs
That is an specialisation of astreamfs to your 1fichier cloud storage, using the API provided by 1fichier. So you don't need the script any more, you only need to provide your API key and the mountpoint (other options are at you convenience).
Afuse
Author: Jacob Bower (jacob.bowerNO@SPAMic.ac.uk (remove the caps))
Homepage: http://afuse.sourceforge.net/
Description A FUSE based automounter.
Alluxio-Fuse
Author: Alluxio
Homepage: https://github.com/Alluxio/alluxio
Description: Alluxio is a distributed file system providing data orchestration and caching for cloud storage. Alluxio FUSE enables distributed POSIX access to data cached by Alluxio or resided in cloud storage.
astreamfs
Author: Alain Bénédetti / alainb06 at free fr
Homepage: https://gitlab.com/BylonAkila/astreamfs
A much more powerful way to mount your http(s) files. The core idea is performance when you need to stream, and most actions involve some streaming. httpfs (see above) was not relevant when streaming an https link due to it naively doing one request per read block, incurring each time the https handshake plus network latency. On top of what you could already do with httpfs, it has numerous options borrowed from curl (follow locations, basic authentication, remote name, etc...) and also allows mounting several URLs so that you could for instance unrar a split archive you have on a "cloud" without having to first download the rar-chunks locally... and that also works if your rar-chunks are split on several servers. You can also mount your "cloud storage" locally (1fichier, uptobox, etc...), with the help of a simple script. You have a script example for 1fichier storage. The only requirement is still that the http(s) server handles ranges, and of course it is a read-only mount!
BGZIP
Homepage: https://github.com/sahlberg/fuse-bgzip
Author: Ronnie Sahlberg
Description: An overlay filesystem that uncompresses indexed GZIP files on the fly. This allows to access the content of large GZIP files without first having to uncompress them. Use bgzip -i to create indexed GZIP files.
BindFS
Author: Martin Pärtel
Homepage: https://bindfs.org/
Description Mirrors a directory to another directory (similar to mount --bind). Allows changing the permissions inside the mirrored directory in a fairly flexible way.
BloggerFS
Author: Elizeu Santos-Neto elizeu@lsd.ufcg.edu.br
Homepage: https://pypi.org/project/bloggerfs/
Description BloggerFS is a filesystem that allow Blogger users to manipulate posts on their blogs via a file interface.
ChironFS
Author: Luis Otavio de Colla Furquim / luisfurquim at gmail dot com
Homepage: http://www.furquim.org/chironfs
Description 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.
ChunkFS
Author: Florian Zumbiehl florz@florz.de
Homepage: http://chunkfs.florz.de/
Description 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.
ClamFS
Author: Krzysztof Burghardt <krzysztof (at) burghardt (dot) pl>
Homepage: http://clamfs.sourceforge.net/
Description ClamFS is a FUSE-based user-space file system for Linux with on-access anti-virus file scanning through clamd daemon.
CryFS
Homepage: https://www.cryfs.org
Description CryFS encrypts your files, so you can safely store them in the cloud (e.g. Dropbox).
CurveFS
Author: CNCF Foundation
Homepage: https://github.com/opencurve/curve
Description: Curve is cloud-native, high-performance, and easy to operate. Curve is an open-source distributed storage system for block and shared file storage.
davfs2 https://savannah.nongnu.org/projects/davfs2 Allows you access to WebDAV storages, including cloud ones.
DwarFS
Author: Marcus Holland-Moritz
Homepage: https://github.com/mhx/dwarfs
Description: A fast high compression read-only file system.
DwarFS easily outperforms other read-only file systems like SquashFS when compressing highly redundant data, both in terms of compression speed and compressed size. A typical use case is compressing multiple versions of particular application, where redundancy between the different versions can be exploited. For example, almost 50 gigabytes of Perl installations (close to two million files) can be compressed into a 300 megabyte DwarFS file system image.
ECM
Homepage: https://github.com/sahlberg/fuse-unecm
Author: Ronnie Sahlberg
Description: An overlay filesystem that uncompresses ECM files on the fly. ECM is a compression for disk images commonly used by various game system emulators such as PCSX.
ferrisfuse
Author: Ben Martin
Homepage: http://sourceforge.net/project/showfiles.php?group_id=16036&package_id=191598
Description 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.
fs123
Author: John Salmon
Homepage: https://github.com/DEShawResearch/fs123
fs123 is a scalable, high-performance, caching network filesystem.
A simple web protocol with just 6 request types leverages the entire HTTP ecosystem (load balancers, proxies, redirects, etc.) and makes it easy to implement and debug custom file servers.
fs123 provides consistency guarantees with path-specific, configurable timeouts, which enables aggressive in-kernel, local-disk, and shared http-proxy caching of positive and negative accesses. It accelerates PATH or PYTHONPATH searches, and is WAN/cloud-friendly.
The client and server are written in C++. Each is a single user-space binary that does not require root privileges. The client uses the FUSE low-level API, and can work through network outages (or even offline) once the on-disk cache is primed. The libevent-based server easily delivers data at 40Gbps.
fsfipi & vaves
Author: Václav Jůza / vaclavjuza at gmail dot com
Homepage: http://fsfipi.sourceforge.net (not yet finished), download at http://sourceforge.net/projects/fsfipi
Description 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.
fuse_adfs
Author: David Boddie / david at boddie org uk
Homepage: http://www.boddie.org.uk/david/Projects/Python/FUSE/
Description 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.
fuseflt
Author: Theodoros V. Kalamatianos / nyb at users dot sourceforge dot net
Homepage: http://www.softlab.ece.ntua.gr/~thkala/projects/fuseflt/
Description A read-only FUSE filesystem that transparently applies file conversion filters.
GCSF
Homepage: https://github.com/harababurel/gcsf
Author: Sergiu Pușcaș
Description: a FUSE file system based on Google Drive
GDFS
Homepage: https://github.com/robin-thomas/GDFS
Author: Robin Thomas
Description: GDFS or Google File System allows you to mount your Google Drive account on Linux.
gitfs https://github.com/PressLabs/gitfs
GlusterFS
Author: Gluster. Red Hat, Inc.
Homepage: https://www.gluster.org/
Description GlusterFS is a scale-out network-attached storage file system. It has found applications including cloud computing, streaming media services, and content delivery networks. GlusterFS was developed originally by Gluster, Inc.
ipfs https://github.com/ipfs/ipfs Bit-torrent+Git+blockchain+fs
hierfs
Author: Georges Kesseler
Homepage: http://hierfs.sourceforge.net/
Description 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.
HTTPDirFS
Author: Fufu Fang
Homepage: https://github.com/fangfufu/httpdirfs
Description: HTTP Directory Filesystem with a permanent cache, and Airsonic / Subsonic server support! It allows you to mount a HTTP directory listings and Airsonic / Subsonic servers. It also permanently caches the files you accessed locally, so you don't have to download them again!
httpfs
Homepage: http://httpfs.sourceforge.net
Description ... is a FUSE-based file system. You may think of it, as a downloader with the speed of light. (Does this belong in NetworkFileSystems?)
JuiceFS
Author: Juicedata
Homepage: https://github.com/juicedata/juicefs
Description: JuiceFS is a distributed POSIX file system built on top of Redis and S3.
limit-fs
Author: Danilo Abbasciano / danilo at piumalab.org
Homepage: https://github.com/piuma/limit-fs
Description limit-fs is a filesystem that removes the oldest files whenever the used space reaches the set limit percentage. You can use it in a no empty directory, anything you write in will be written in the underlying filesystem. After unmounting it all files remain in the unmounted directory.
LizardFS
Author: LizardFS
Homepage: https://github.com/lizardfs/lizardfs
Description: Distributed, scalable, fault-tolerant, and highly available file system. Inspired by the GoogleFS.
LoggedFS
Homepage: https://github.com/rflament/loggedfs
Author: rflament
Description: LoggedFS is a fuse-based filesystem which can log every operations that happens in it.
LoggedFS-python
Homepage: https://github.com/pleiszenburg/loggedfs-python
Author: Sebastian M. Ernst
Description: LoggedFS-python is a FUSE-based filesystem which can log every operation that happens in it. It is a pure Python re-implementation of LoggedFS by Rémi Flament maintaining CLI compatibility. The project is heavily inspired by Stavros Korokithakis 2013 blog post entitled "Writing a FUSE filesystem in Python" (source code repository). The filesystem is fully POSIX compliant, passing the pjdfstest test-suite, a descendant of FreeBSD's fstest. It furthermore passes stress tests with fsx-linux based on the fsx-flavor released by the Linux Test Project. It is intended to be suitable for production systems.
mcachefs
Author: Michael Still / mikal at stillhq com
Homepage: http://lists.samba.org/archive/linux/2004-March/010211.html
Description 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.
mergerfs
Homepage: https://github.com/trapexit/mergerfs
Author: trapexit
Description: mergerfs is a union filesystem geared towards simplifying storage and management of files across numerous commodity storage devices. It is similar to mhddfs, unionfs, and aufs.
mfs
Author: Alain Bénédetti / alainb06 at free fr
Homepage: https://gitlab.com/BylonAkila/mfs
Description: mfs (Merge FS) virtually merges several files into a single file (as with a cat command). This is useful to save I/O thus time (and SSD wear) when you need random read access or seek (ex. unrar, vlc, mount an ISO image, etc... from several 'split files') and thus can't use the standard 'named pipes' feature. Also works with block devices, allowing you, for example, to simulate a write to /dev/sdX and test it before doing any harm to your partitions.
MooseFS
Author: Jakub Kruszona-Zawadzki, Core Technology Sp. z o.o.
Homepage: https://github.com/moosefs/moosefs | https://moosefs.com
Description: MooseFS is a Petabyte Open Source Network Distributed File System. It is easy to deploy and maintain, fault tolerant, highly performing, easily scalable, POSIX compliant. MooseFS Client (moosefs-client / mfsmount) uses FUSE to mount Moose File System.
NFS
Homepage: https://github.com/sahlberg/fuse-nfs
Author: Ronnie Sahlberg
Description: A userspace NFSv3 client that allows you to mount a remote NFS share. (Most useful for platforms that do not have native built-in NFS support.)
NHFS - nonhierarchical file system
Author: Robert Freund / rfreund at uos dot de
Homepage: http://rffr.de/nhfs
Description 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.
OutOfOrderFS
Homepage: https://github.com/vi/outoforderfs
Author: Vitaly "_Vi" Shukela
Description: For testing. Single-file "block" filesystem that filters writes to your device. Each write is delayed by random amount of time. Although user of the file does not see it, interrupting OutOfOrderFS throws away some recently written blocks (not preserving order, obviously), intentionally breaking abstraction. Old blocks will remain instead of some random recently written blocks. It is designed to emulate inconsistent removal of storage without proper flushing and test how well are filesystems and databases proofed against it.
Oxfs
Author: oxfs
Homepage: https://oxfs.github.io/oxfs/
Description: A dead simple, fast SFTP file system, sshfs like.
p2p-fs
Homepage: http://p2p-fs.sourceforge.net/ (last update: 2008)
Description 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.
pgdbfs
Author: JR
Homepage: https://github.com/jrz1977/pgdbfs
pgdbfs is file system implemented in Rust using PostgreSQL as backend storage.
Ramfuse
Author: Daniel Fischer <df.code at notabilis dot ort>
Homepage: http://notabilis.org/code/?ramfuse
Description Ramfuse is a dynamically growing RAM file system written in perl. Due to perl's memory handling, it's not dynamically shrinking though. :-)
Ratarmount
Author: Maximilian Knespel
Homepage: https://github.com/mxmlnkn/ratarmount
Description: Ratarmount offers FUSE access to archive files including tar, zip, rar, bz2, gzip, and others with a focus on very large archives or archives containing millions of files.
rclone
Author: Nick Craig-Wood | https://www.craig-wood.com/nick/
Homepage: https://rclone.org/
Github: https://github.com/ncw/rclone
Description
"rsync for cloud storage" - Google Drive, Amazon Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Cloudfiles, Google Cloud Storage, Yandex File. It also allows mounting of the sync target using FUSE.
rofs
Author: Matthew Keller
Homepage: http://mattwork.potsdam.edu/rofs
Description Light and fast, allowing you to mount any folder tree as a read-only filesystem that fully supports reading extended attributes and ACLs.
rofs-filtered
Author: Gabriel Burca (gburca dash fuse at ebixio dot com)
Homepage: https://github.com/gburca/rofs-filtered
Description:
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.
rotatefs
Author: Fábio Roberto Teodoro
Homepage: https://github.com/frt/rotatefs
Description: FUSE filesystem that removes the oldest file whenever there is no space left to do some operation.
s3backer
Author: Archie Cobbs
Homepage: https://github.com/archiecobbs/s3backer
Description: s3backer is a filesystem that contains a single file backed by the Amazon Simple Storage Service (Amazon S3). As a filesystem, it is very simple: it provides a single normal file having a fixed size. Underneath, the file is divided up into blocks, and the content of each block is stored in a unique Amazon S3 object. In other words, what s3backer provides is really more like an S3-backed virtual hard disk device, rather than a filesystem. In typical usage, a normal filesystem is mounted on top of the file exported by the s3backer filesystem using a loopback mount (or disk image mount on Mac OS X).
s3fs-fuse Access to Amazon S3 cloud storage https://github.com/s3fs-fuse/s3fs-fuse
scord
Homepage: http://scord.sourceforge.net/
Description Reduces the disk space used by a subversion working copy with large and/or many files.
ScriptFS
Author: François Hissel / francois dot hissel at gmail com
Homepage: https://github.com/frodonh/scriptfs
Description: ScriptFS is a new file system which merely replicates a local file system, but replaces all files detected as "scripts" by the result of their execution.
TSKmount-Fuse
Author: Jean Diraison / jean dot diraison at ac-versailles dot fr
Homepage: http://tskmount-fuse.sourceforge.net/
Description 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.
UnreliableFS
Author: Sergey Bronnikov
Homepage: https://github.com/ligurio/unreliablefs
Description UnreliableFS is a FUSE-based fault injection filesystem.
Virtual800
Author: Miguel Scapolla / virtual800 at yahoo dot com dot ar
Homepage: http://virtual800.sourceforge.net
Description A virtual filesystem with big files for testing.
vmware-mount
Author: VMware
Homepage: http://www.vmware.com
Description 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. it's part of latest VMware Server 2.0 Beta version.
webfuse
Author: Falk Werner
Homepage: https://github.com/falk-werner/webfuse
Allows to attach a remote filesystem via websockets.
Yacufs
Author: Frank Reerink
Homepage: https://www.uitwisselplatform.nl/projects/yacufs
Description 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.