mount-rsstorage at the boundary

Rust core / Node bindings / mount-free

Put bytes where your process needs them. Keep metadata where your invariants live.

mount-rs is a filesystem contract and storage composition layer for applications that need files without turning a mount into their only boundary.

Explore the APIView source

Apache-2.0 · prerelease · not release-ready

one contract / two planes
01metadatanamespace · revisions · leases
02immutable blocksfixed chunks · bytes · barriers
composed through ChunkedFs

The shape

A filesystem API that keeps the storage decision explicit.

The core stays focused on paths, handles, metadata, and observable behavior. Backends live in separate crates and can be composed independently.

01

Use files without a mount

Call the same loopback and handle contract directly from Rust or the napi-rs Node package when a FUSE, NFS, or FSKit mount is not available.

Rust surface
02

Split metadata from blocks

MetadataStore publishes namespace and revisions; BlockStore owns immutable bytes. The orchestration layer flushes blocks before publishing references.

Composition notes
03

Keep the boundary portable

The API is designed for memory, SQLite, PGlite, R2, and future providers without putting a cloud SDK or database client in the core crate.

Node surface

A small contract

Readable in Rust. Familiar from Node.

Start with the direct API, then choose the transport or provider that belongs at the edge of your deployment.

See the real APIs
Rust / loopback contract
use mount_rs::{Loopback, MemoryFs, MemoryOptions};

let fs = Loopback::new(MemoryFs::new(MemoryOptions::default()));
fs.write_file("/hello", b"hello").await?;
let bytes = fs.read_file("/hello").await?;

Status, in plain language

Useful now. Deliberately not called finished.

This is a prerelease project. The repository is the source of truth for evidence, requirements, and remaining work. It is not release-ready.

✓

In the tree

  • Core Rust FsDriver and FileHandle contracts.
  • Independent metadata and immutable block provider APIs.
  • Node bindings expose memory, SQLite, PGlite, and R2 factories; transport integrations are also present.
→

Still being qualified

  • Windows runtime qualification and revision-matched platform CI.
  • Remaining live Cloudflare R2 lanes and full mounted-SQLite acceptance.
  • FSKit integration, broader API/transport parity, durability, failure-recovery, and benchmark gates.
Read porting evidence Read requirements Follow the tracker