Open-source file infrastructure · Rust and Node

A real filesystem for your app. Any storage underneath.

mount-rs gives your product paths, handles and directories through one small contract. Use it in-process, mount it with FUSE or NFS, or serve it over HTTP. Keep names and file bytes in the stores you choose, and change them later without rewriting the product.

0.72 ms
p99 metadata read, forwarded between servers
7
ways in: two APIs, three mounts, HTTP and WebDAV
10
storage providers, from memory to S3
Apache-2.0
open source, prerelease, evidence-led

Why mount-rs

File features, without the infrastructure lock-in.

A mount can work on one laptop and still be the wrong boundary for a container, a serverless process or a desktop app. mount-rs keeps the file contract in your code and makes everything behind it a choice.

No mount required

File semantics inside your process.

Call mount-rs from Rust or Node. There is no kernel module, daemon or root permission between your product and its files.

Explore the API
Mount it when you want one

The same drive, as a real directory.

Expose a drive through FUSE or NFS for tools that expect a path, or over HTTP and WebDAV when the edge is a network.

Compare the edges
Storage you can swap

SQLite today. TiDB and S3 later.

Names and bytes are separate choices. Move either one to a different store and the file API your product uses does not change.

See every provider
Fast where it counts

Metadata in well under a millisecond.

Each drive’s namespace is served from memory by its owner. The numbers come from a benchmark that runs in CI, not from estimates.

Read the benchmarks
Scale out simply

Any server can take any request.

A plain load balancer is enough. A node that does not own the drive forwards the request once, over HTTP/3, to the node that does. With failover on, a standby takes over the drives of a node that stops.

Watch a request
Safe by construction

Bytes first, then the name.

Blocks reach storage before metadata refers to them, and every commit carries a writer fence. If ownership is lost, writes fail closed.

See the write path

Flexible by design

Compose the stack you need today. Change it tomorrow.

Three independent choices: how your application reaches files, where the namespace lives, and where the bytes live. Try a few combinations.

Start from
1 · How your app reaches files
2 · Where names and structure live
3 · Where file bytes live
Your applicationpaths · handles · directories
EdgeHTTP APIValidated
mount-rsone file contract
MetadataTiDBValidated
BlocksRustFSValidated

You serve many drives over HTTP from one or more servers. Names, sizes and revisions are kept in distributed SQL shared by many servers. File bytes are stored as immutable blocks as objects in a self-hosted S3-compatible service.

Change any one choice and the other two stay put. Not every pairing has been qualified together: the badges show each part’s own maturity, and the provider guide lists the evidence.

Fast by design

Sub-millisecond metadata, even one server away.

Each drive has one owner that keeps its namespace in memory. Any server can take a request and forward it in one HTTP/3 hop, so a load balancer never needs to know where a drive lives. If an owner stops, a standby can take the drive over once it holds the storage writer lease.

0.72 ms

Forwarded read p99

Durable TiDB drive, 100 drives across three servers.

0.81 ms

Forwarded rename p99

Writeback drive: applied in memory, published afterwards.

0.26 ms

Local read p99

Answered from the owner’s in-memory namespace.

1 hop

Any node, any drive

Routes cached and refreshed in the background; pinned, pooled QUIC peers.

The storage model

See what happens to one file.

The same file operation crosses a namespace plane and an immutable block plane. This conceptual view makes the ordering visible without pretending every provider uses the same physical schema.

Illustrative provider view

/reports/q3.pdf
schemas vary by provider
Conceptual file record
namespace:
  path: /reports/q3.pdf
  revision: 7
  size_bytes: 131072
  blocks: [block_01, block_02]

block_01:
  key: files/7/block_01
  bytes: 65536
  immutable: true

Metadata carries inode attributes, directory entries, and block references. It does not carry the file bytes.

  1. 01

    Namespace / metadata

    Describe the file before publishing it.

    Keep inode attributes, directory entries, and block references in the metadata contract. The namespace points to bytes; it does not become the byte store.

  2. 02

    Immutable blocks

    Write fixed-size chunks and finish the block barrier.

    Chunk the file according to its layout, write immutable blocks, and wait for the block-store barrier before metadata can refer to them.

  3. 03

    Publish

    Commit the reference with a fence.

    Publish with revision CAS and a monotonic writer fence, then complete the metadata barrier before the write is acknowledged.

Operational boundary: ownership loss fails closed. An uncertain commit can leave unreferenced blocks; automatic GC and copy-on-write are not implemented yet.

How to use it

Start local. Keep the boundary when the deployment changes.

Begin with a direct loopback contract, choose the storage planes your workload needs, then either create a real mount for the host or expose a network transport. The application contract stays the same while the edge changes.

01

Define the file contract

Give your application file operations without requiring a kernel mount.

02

Select the planes

Keep namespace and immutable bytes explicit so each provider has one job.

03

Mount or transport it

Create a real mount through FUSE, NFS, 9P, or FSKit when the host needs a filesystem; choose HTTP or WebDAV for a network edge.

Rust / direct contract
let fs = Loopback::new(MemoryFs::new(MemoryOptions::default()));
fs.write_file("/hello", b"hello").await?;
let bytes = fs.read_file("/hello").await?;
Node / split-store factory
const fs = await createChunkedDriver({
  metadata: { kind: 'sqlite', uri: './metadata.sqlite' },
  blocks: { kind: 'sqlite', uri: './blocks.sqlite' },
  chunkSize: 65536,
});
await fs.writeFile('/hello', Buffer.from('hello'));

Choose the boundary

Use the storage model that fits the workload.

mount-rs is a choice for teams that want file semantics without making a platform mount or one storage service the product API. It is not the right abstraction for every workload.

Choose mount-rs when

Your product needs files, but infrastructure still needs to move.

  • Paths, handles, directory operations, and sync semantics belong in the product.
  • Metadata and immutable blocks need separate operational roles.
  • Rust, Node, and edge transports should share one contract.
Read the adoption guide
Use direct object APIs when

The application is object-native.

If callers already work in buckets, keys, immutable objects, and provider-native lifecycle rules, adding filesystem semantics may create more surface area than it removes.

Review the storage roles
Use a real mount when

Existing tools expect a mounted path.

FUSE, NFS, 9P, and FSKit put the filesystem surface back into a host when users or existing software expect a mounted path. Platform permissions, daemon lifecycle, and qualification remain part of that choice.

Compare transports

Proof, not promises

Know what is usable now—and what still needs qualification.

mount-rs is a prerelease project. The docs separate repository implementation, local tests, and live provider evidence so you can make an informed adoption decision.

✓

In the tree

  • Core Rust FsDriver and FileHandle contracts.
  • Independent metadata and immutable block provider APIs.
  • Rust and Node entry points plus transport integrations.
→

Still being qualified

  • Windows runtime qualification and revision-matched platform CI.
  • Durability, failure recovery, broader provider lanes, and native mount gates.
  • Production operations, release coverage, and deployment-specific guarantees.

Make the boundary explicit

Build the file feature. Keep your infrastructure options open.