StudioFS — cloud native file system for VFX

The problem

Stop downloading the whole project to change one shot.

In a classic remote pipeline artists pull hundreds of gigabytes, wait, relink paths by hand, and push changed files back. StudioFS is designed to remove that loop.

Remote pipeline today the loop

01Download hundreds of gigabytes of plates, caches and proxies.
02Wait for every transfer to finish before you can start.
03Relink paths manually so the scene finds its files.
04Upload changed files back and hope nobody else touched them.

With StudioFS mount & work

01Mount the volume as a drive letter or a directory. Same paths for everyone.
02Open files right away. Only the fragments your app reads are fetched from S3.
03Save locally first and keep working. No progress bar in your way.
04Share automatically: uploads and metadata sync run in the background.

How it works

Object storage for the bytes. PostgreSQL for the team. Local-first for speed.

StudioFS separates data from metadata. S3 stores file contents, StudioFS manages the file tree, versions and changes, so ordinary file operations work without asking S3 to do something it was never designed for.

Your workstation

Any app, ordinary paths

Resolve, Nuke, Flame, Houdini, Blender, Explorer or Finder see a regular drive. No plugins.

Z:\/mnt/studio

StudioFS mount · local-first runtime

Local cache keeps active work fast

Filesystem operations use local state first. Metadata lives in an embedded redb database, new writes are readable immediately, and RAM + NVMe caches serve repeated reads.

redb metadata payload cache upload queue readahead

S3-compatible storage

Cloud holds the assets

Immutable, encrypted payload fragments. AWS S3, RustFS, Backblaze B2, Wasabi.

PostgreSQL

Coordinates the team

Orders metadata changes between clients: adds, deletes, renames, snapshots.

On-demand readsFragments or authenticated byte ranges are fetched as your app reads them, with readahead.

Background uploadSaves are accepted locally first, then uploaded to S3 by background workers.

Eventual convergencePeers replay ordered changes from PostgreSQL and see your edits shortly after upload.

Encrypted at restRemote payloads use XChaCha20-Poly1305. Volume keys are managed for you.

Features

Built for heavy media and distributed teams.

Mounted access to heavy media

Work directly with proxies, 4K and RAW footage from the cloud through plain filesystem reads.

One shared workspace

Every client sees the same file tree. Changes converge through ordered PostgreSQL replication.

Works with existing tools

Mounts through the OS filesystem bridge, so applications use normal file paths without a StudioFS plugin.

Encryption at rest

Payload fragments are encrypted before they reach object storage and decrypted only on clients.

Snapshots

Create, schedule and mount whole-volume snapshots read-only with studiofs smount.

Observability built in

Live counters with perf, a fixed mounted benchmark with bench, and fsck for repairs.

Self-hosted and open

GPL-3.0. Your storage, your metadata, your infrastructure. Use it freely for commercial productions.

Built with Rust

A Rust workspace implements the filesystem core, cache, replication and platform bridges.

Cat logo

Because infrastructure is better with a little personality. 🐱

Platforms

Native mounts on every studio desk.

StudioFS uses each operating system's own filesystem bridge. Install the bridge once, StudioFS archives never bundle these drivers.

Windows

Requires WinFsp.
Mounts as a drive letter.

x86-64 x86_64-pc-windows-msvc.zip
ARM64 aarch64-pc-windows-msvc.zip

macOS

Requires macFUSE, installed by you.
Mounts into any directory.

Apple Silicon aarch64-apple-darwin.tar.gz

Linux

Requires fuse3 (libfuse3).
Mounts into any directory.

x86-64 x86_64-unknown-linux-gnu.tar.gz
ARM64 aarch64-unknown-linux-gnu.tar.gz

Install

Up and running in a few commands.

You need S3-compatible storage for the files and PostgreSQL for metadata, reachable from every workstation (a private network such as Tailscale or NetBird is a good idea).

01Install the filesystem bridge

WinFsp on Windows, macFUSE on macOS, or fuse3 on Linux.

02Download a release

Grab the archive for your machine from GitHub Releases, verify its .sha256 file and extract it.

03Create a volume and mount it

Run init once. Other clients join with discover.

# 1. install WinFsp: https://github.com/winfsp/winfsp/releases

# 2. extract the release zip, open the folder, then
> .\studiofs.exe --version

# 3. join an existing volume
> .\studiofs.exe discover myvolume `
    --meta postgres://user:pass@db:5432

# 4. mount it as a drive letter
> .\studiofs.exe mount myvolume Z:

# 1. install macFUSE yourself: https://macfuse.github.io

# 2. extract the release and check it
$ shasum -a 256 -c studiofs-*-aarch64-apple-darwin.tar.gz.sha256
$ tar xzf studiofs-*-aarch64-apple-darwin.tar.gz
$ cd studiofs-*-aarch64-apple-darwin && ./studiofs --version

# 3. join an existing volume
$ ./studiofs discover myvolume \
    --meta postgres://user:pass@db:5432

# 4. mount it
$ ./studiofs mount myvolume ~/Studio

# 1. bridge + runtime libraries (Ubuntu 24.04)
$ sudo apt-get install fuse3 libgtk-3-0t64 libxdo3 libayatana-appindicator3-1

# 2. extract the release and check it
$ sha256sum -c studiofs-*-x86_64-unknown-linux-gnu.tar.gz.sha256
$ tar xzf studiofs-*-x86_64-unknown-linux-gnu.tar.gz
$ cd studiofs-*-x86_64-unknown-linux-gnu && ./studiofs --version

# 3. create a volume
$ ./studiofs init myvolume \
    --endpoint https://s3.example.com --bucket studio \
    --access-key … --secret-key … \
    --meta postgres://user:pass@db:5432

# 4. mount it
$ ./studiofs mount myvolume /mnt/studio

Pricing

Simple, transparent pricing.

We spent weeks on this. After careful market research, we came up with one plan.

Only option

Free

$0 / forever

per seat · per studio · per petabyte

Unlimited workstations
Unlimited volumes and snapshots
All platforms: Windows, Linux, macOS
Full source code, GPL-3.0
No sales calls. Ever.
Cat included

Get it for free

* You still pay your own S3 and PostgreSQL bills. Support is a GitHub issue and a lot of goodwill.

Your studio's media,
mounted like a local drive.