Features

Everything hard about remote storage, handled where you cannot see it.

Mountit is a Rust core with a SwiftUI app on top. The interesting parts — caching, prefetching, write-back, byte-exact filename handling — live in the core, are covered by tests and fuzzers, and are shared identically between the Mac and iPad builds.

The cache layer is the product

A remote filesystem is a latency problem wearing a filesystem costume. Finder will happily fire hundreds of stat calls to draw one window; at 100 ms round trip that is a beachball. Mountit answers from a local metadata cache and goes to the network only when it must.

  • Metadata cache so directory listings are instant on second view
  • Read-ahead on macOS that fetches the next block before you ask for it
  • Write-back queue so saving a file does not block on the upload
  • Offline pinning for the directories you actually work in
  • An encrypted chunk store — the cache on your disk is not plaintext
macOS 14+

In Finder, with no kernel extension

The mount is served by a File Provider extension: your storage appears in Finder under Locations, and every app that opens a file can open one there. No kernel extension is installed, System Integrity Protection stays on, and there is no third-party driver to break on the next OS update.

  • Appears in Finder under Locations, and in every Open dialog
  • Works with rsync, git, Xcode, Logic — anything that opens a file
  • No macFUSE, no kext, no reduced security mode
  • Ejects cleanly; a dropped connection does not wedge the Finder
iPadOS · visionOS

Files app on iPad and Vision Pro

iOS has no FSKit and no FUSE — that is not an oversight we can work around, the symbols are declared unavailable in the SDK. The File Provider extension is the supported integration point, and it is what Mountit uses, so your storage is a real location in the Files app.

  • Browse, open and save straight from the Files app
  • Works inside other apps’ document pickers
  • The same Rust core as the Mac — the same protocols, cache and crypt
  • Token refresh happens inside the extension, not just in the app
  • Opening a file fetches all of it: iOS has no partial-fetch API at all

Secrets stay on your device

Mountit connects your machine directly to your server. There is no relay, no proxy and no account required to mount anything — which means there is nothing in the middle that could read your files even if we wanted it to.

  • Passwords and private keys in the Keychain, protected by the Secure Enclave
  • OAuth through the system browser — your provider password never enters our app
  • The Rust core receives short-lived tokens and stores none of them
  • Host key verification on first connect, with a real trust prompt
Mountit Pro only

Block protocols, for the people who need them

iSCSI and NVMe-oF attach a remote device and let macOS put its own filesystem on it. This cannot be done from inside the App Sandbox, so it exists only in Mountit Pro — which is the entire reason two editions exist.

  • A Rust iSCSI initiator, already validated against real targets
  • NVMe-oF for low-latency fabrics
  • The device is attached and mounted, not emulated over a file tree

Licensing that stays out of the way

Your licence is a signed lease the app verifies on your own Mac, against a public key compiled into the binary. Opening a volume never consults the network. The lease is renewed quietly in the background about once a month, which is what makes the device limit real rather than decorative.

  • Devices moved between machines by you, from the app or the web
  • Deactivate a Mac you no longer have, without emailing support
  • Three weeks of slack — our servers can be down and you would not notice
  • No telemetry and no usage reporting: renewal sends the key, a device id and a name

How a read actually goes

Four steps, and only one of them touches the network.

  1. 1

    Finder asks

    A window opens. Finder stats every entry and asks for an icon for each one.

  2. 2

    The cache answers

    Metadata already seen is returned from local storage in microseconds, not over the wire.

  3. 3

    Read-ahead runs

    On macOS, while you read the front of a file the next blocks are already in flight. Where a ranged read is not on offer, the file is fetched whole.

  4. 4

    Writes queue

    A save returns as soon as it is durable locally; the upload drains behind you, and survives a disconnect.

Where Mountit runs

PlatformRequirementHow it mountsWhat you get
macOS macOS 14 or laterFile Provider (both editions) · an FSKit module ships in Mountit Pro, not yet mountingA location in Finder, under Locations
iPadOS & iOS iOS 17 or laterFile ProviderA location in the Files app
visionOS visionOS 2 or laterFile ProviderA location in the Files app
Download Mountit See every protocol