Displaying 1 to 19 from 19 results

goofys - a high-performance, POSIX-ish Amazon S3 file system written in Go

  •    Go

Goofys allows you to mount an S3 bucket as a filey system. It's a Filey System instead of a File System because goofys strives for performance first and POSIX second. Particularly things that are difficult to support on S3 or would translate into more than one round-trip would either fail (random writes) or faked (no per-file permission). Goofys does not have a on disk data cache (checkout catfs), and consistency model is close-to-open.

dungeonfs - A FUSE filesystem and dungeon crawling adventure game engine

  •    Go

DungeonFS is a FUSE filesystem and dungeon crawling adventure game engine. This is a work-in-progress, however, there is a general list of planned features worth checking out, as well as, a little bit of the motivation behind why I started this project. Note: The demo level is included in the <project root>/examples/simplelevel folder, which should be downloaded with the above command. In the future, I will have this included with the static binary so the demo level is accessible without need go installed on the system.

securefs - Filesystem in userspace (FUSE) with transparent authenticated encryption

  •    C++

securefs is a filesystem in userspace (FUSE) with transparent encryption (when writing) and decryption (when reading). securefs mounts a regular directory onto a mount point. The mount point appears as a regular filesystem, where one can read/write/create files, directories and symbolic links. The underlying directory will be automatically updated to contain the encrypted and authenticated contents.




dbxfs - User-space file system for Dropbox

  •    Python

dbxfs has been tested on OpenBSD, Linux, and macOS but it should run on any POSIX system that provides a FUSE-compatible library or has the ability to mount SMB shares. Windows support is coming very soon. It runs on non-x86 architectures like ARM. It doesn't require a specific file system. It is written for Python 3.5+ and is licensed under the GPLv3.

lxcfs - FUSE filesystem for LXC

  •    C

LXCFS is a small FUSE filesystem written with the intention of making Linux containers feel more like a virtual machine. It started as a side-project of LXC but is useable by any runtime. are container aware such that the values displayed (e.g. in /proc/uptime) really reflect how long the container is running and not how long the host is running.

x11fs - A tool for manipulating X windows

  •    C

This is heavily based off wmutils. Check them out. x11fs is a tool for manipulating X windows. It creates a vitual filesystem to represent open windows, similar to what /proc does for processes. This allows windows to be controlled using any language or tool with simple file IO, in a true unix fashion.

minfs - A network filesystem client to connect to Minio and Amazon S3 compatible cloud storage servers

  •    Go

MinFS is a fuse driver for Amazon S3 compatible object storage server. MinFS lets you mount a remote bucket (from a S3 compatible object store), as if it were a local directory. This allows you to read and write from the remote bucket just by operating on the local mount directory.MinFS helps legacy applications use modern object stores with minimal config changes. MinFS uses BoltDB for caching and saving metadata, list of files, permissions, owners etc.


sandboxfs - A virtual file system for sandboxing

  •    Go

sandboxfs is a FUSE file system that exposes a combination of multiple files and directories from the host's file system in the form of a virtual tree with an arbitrary layout. You can think of a sandbox as an arbitrary view into the host's file system with different access privileges per directory.sandboxfs is designed to allow running commands with limited access to the file system by using the virtual tree as their new root, and to do so consistently across a variety of platforms.

execfuse - Turn a bunch of scripts into FUSE filesystem

  •    C

execfuse is a implement FUSE filesystems using a bunch of scripts. Consider it as a "shell FUSE binding".

usbmount - Simple set of scripts to automount removable devices for a Linux system

  •    Shell

The USBmount package automatically mounts USB mass storage devices (e.g., USB pen drives or HDs in USB enclosures) when they are plugged in. The mountpoints (/media/usb[0-7] by default), filesystem types to consider, and mount options are configurable. When multiple devices are plugged in, the first available mountpoint is automatically selected. If the device plugged provides a model name, a symbolic link at /var/run/usbmount/MODELNAME pointing to the mountpoint is automatically created. When the device is not present anymore in the system (e.g., after it has been unplugged), usbmount deletes the symbolic links that were created.

edge-fuse - Edge-X S3 API, mount S3 bucket for full POSIX read/write access

  •    C

High-Performance FUSE library to access Edge-X S3 API. Follow up with our Community! Please join us at the NexentaEdge Devops community site.

catfs - Cache AnyThing filesystem written in Rust

  •    Rust

Catfs is a caching filesystem written in Rust. Catfs allows you to have cached access to another (possibily remote) filesystem. Caching semantic is read-ahead and write-through (see Current Status). Currently it only provides a data cache and all metadata operations hit the source filesystem.

fusenar - A program that mounts a NAR (Nix Archive) archive as a filesystem using FUSE

  •    C++

A program that mounts a NAR (Nix Archive) archive as a filesystem using FUSE. This repo is written in C++; it has now been rewritten in Haskell (https://github.com/taktoa/narfuse).

libprojfs - Linux projected filesystem library

  •    C

A Linux projected filesystem library, similar in concept to the Windows Projected File System and developed in conjunction with the VFSForGit project. While the libprojfs C library may also be used independently of VFSForGit, our primary goal is to enable users to run the VFSForGit client on a Linux system.

fuse-example - A simple FUSE filesystem

  •    Go

A simple example FUSE filesystem that uses Bazil's Go FUSE package. You can read about this project in my blog post "Tinkering with Bazil's Go FUSE package".

muxfys - High performance multiplexed user fuse mounting

  •    Go

muxfys is a pure Go library for temporarily in-process mounting multiple different remote file systems or object stores on to the same mount point as a "filey" system. Currently only support for S3-like systems has been implemented. It has high performance, and is easy to use with nothing else to install, and no root permissions needed (except to initially install/configure fuse: on old linux you may need to install fuse-utils, and for macOS you'll need to install osxfuse; for both you must ensure that 'user_allow_other' is set in /etc/fuse.conf or equivalent).

fusejs - Low level fuse bindings for nodejs

  •    C++

Fusejs are a set of NodeJS bindings for Fuse low level API. It allows you to write filesystems, in userspace, using Javascript and NodeJS. Even though most of the Fuse functions are already binded, this module has not been used in production. Use it at your own risk. Fuse low level API is inherently asynchronous, therefore, there is no need for libuv thread pool.