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 APIOpen-source file infrastructure · Rust and Node
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.
Why mount-rs
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.
Call mount-rs from Rust or Node. There is no kernel module, daemon or root permission between your product and its files.
Explore the APIExpose 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 edgesNames and bytes are separate choices. Move either one to a different store and the file API your product uses does not change.
See every providerEach 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 benchmarksA 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 requestBlocks reach storage before metadata refers to them, and every commit carries a writer fence. If ownership is lost, writes fail closed.
See the write pathFlexible by design
Three independent choices: how your application reaches files, where the namespace lives, and where the bytes live. Try a few combinations.
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.
HTTP API guideTiDB metadataRustFS blocks
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
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.
Durable TiDB drive, 100 drives across three servers.
Writeback drive: applied in memory, published afterwards.
Answered from the owner’s in-memory namespace.
Routes cached and refreshed in the background; pinned, pooled QUIC peers.
The storage model
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.pdfnamespace:
path: /reports/q3.pdf
revision: 7
size_bytes: 131072
blocks: [block_01, block_02]
block_01:
key: files/7/block_01
bytes: 65536
immutable: trueMetadata carries inode attributes, directory entries, and block references. It does not carry the file bytes.
Keep inode attributes, directory entries, and block references in the metadata contract. The namespace points to bytes; it does not become the byte store.
Chunk the file according to its layout, write immutable blocks, and wait for the block-store barrier before metadata can refer to them.
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
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.
Give your application file operations without requiring a kernel mount.
Keep namespace and immutable bytes explicit so each provider has one job.
Create a real mount through FUSE, NFS, 9P, or FSKit when the host needs a filesystem; choose HTTP or WebDAV for a network edge.
let fs = Loopback::new(MemoryFs::new(MemoryOptions::default()));
fs.write_file("/hello", b"hello").await?;
let bytes = fs.read_file("/hello").await?;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
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.
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 rolesFUSE, 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 transportsProof, not promises
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.
FsDriver and FileHandle contracts.Make the boundary explicit