Everything the client
can do.

Install

One small binary, no kernel drama. macOS gets a signed installer or the Homebrew cask; Linux gets a static binary, .deb/.rpm packages, and a container image for pipelines. Stone is in invite-only preview, so the download links arrive with your invite — request access, or see the download page for platform details.

$ brew install --cask stone
==> stone 0.30 installed — a pleasure doing business
$ docker pull ghcr.io/stonestorage/stone
   # for render nodes, CI, and other rooms without windows

Sign in

stone login prints a short code and opens your browser. Approve it at stone.no/signin and the device stays trusted until you say otherwise. No passwords typed into terminals, no tokens pasted into shell history — the browser does the trusting, the client does the working.

$ stone login
→ Your code: WNTR-83KD
→ Approve at https://stone.no/signin?code=WNTR-83KD
… approved. Welcome, mari@fjordframe.no
$ stone logout
✓ device forgotten — it took the news well

Mount

One command and your filespace appears as a real drive — Finder on a Mac, a mount point on Linux. You see everything immediately: every folder, every file, sizes, dates, the lot. Bytes only travel when you open something, so mounting forty terabytes takes about a second and roughly no disk.

Multiple filespaces mount side by side with --space. Unmounting is just as unceremonious — the files stay in the filespace, exactly where they were.

$ stone mount ~/Stone
✓ fjordframe.stone.no mounted at ~/Stone
   61.4 TB visible · 0 bytes downloaded · all of it yours
$ stone mount ~/Stone-archive --space fjordframe-archive
$ stone unmount ~/Stone
✓ unmounted — everything stays exactly where it was

Share

Sharing is a permission, not an upload. Grant a person — or a whole domain — access to a path: read-only if you like, expiring when you say. They see the folder in their own mount the moment you press enter. Revoking is just as instant, and just as global.

Prefer a link? stone share PATH --link mints a capability link with the same scoping. How links, grants and permissions fit together is on Security & sharing.

$ stone share ~/Stone/EP04_Grade --with colorworks.no \
    --read-only --until 2026-09-01
✓ granted — visible in their mount now · revocable · audited
$ stone share ~/Stone/EP04_Grade --revoke --with colorworks.no
✓ revoked — gone from every mount, effective immediately

Watch

Get told the instant a file or folder changes — anywhere in the world, on anyone's machine. Watch from the terminal to see a hand-off land, or hook a command to it and you have a pipeline: ingest on arrival, transcode on delivery, ping the channel on approval. No polling, no cron, no "is it there yet."

$ stone watch ~/Stone/Inbox --exec ./ingest.sh
✓ watching ~/Stone/Inbox
→ 14:02:11  created   Inbox/S02E07_mix_v3.wav   (jon@tonefabrikken.no, Oslo)
→ 14:02:11  exec      ./ingest.sh — exit 0
→ 14:07:48  modified  Inbox/S02E07_mix_v3.wav   (jon again — there is always a v4)

Rewind & history

Every change is kept, stamped to the nanosecond. stone history lists what happened to a path — who, when, precisely. stone rewind restores a file, a folder, or your whole world to any instant you name. Nothing is destroyed by rewinding: forward is still there too. It's time travel with a handbrake, not a delete key.

$ stone history ~/Stone/EP04_Grade/reel_02.mov
→ 2026-07-18 16:41:07.184739226  modified  anna@fjordframe.no
→ 2026-07-18 14:03:52.009114873  modified  anna@fjordframe.no
→ 2026-07-17 11:20:30.551002748  created   anna@fjordframe.no
$ stone rewind ~/Stone/EP04_Grade --to "2026-07-18 14:00"
✓ EP04_Grade as it was at 14:00:00.000000000 — yesterday, faithfully

Tiers

Four temperatures — hot, standard, archive, long-term — in one namespace. Files never move, never change their path, never vanish from the tree; only their economics change. Admins set the policies, anyone with permission can nudge a folder, and reading an archived file simply takes a moment longer. That's the entire user manual for tiering.

$ stone tier ~/Stone/2024_Deliveries --set archive
✓ 18.9 TB drifting to archive — same names, smaller invoice
$ stone tier ~/Stone/2024_Deliveries
→ archive · set 2026-07-19 by mari
   policy: untouched 180 days → archive

Containers

Render nodes, CI runners and cloud machines mount the filespace exactly like a laptop does. The container image carries the client; hand it a token and a mount point, and your pipeline sees the same drive as your artists — same paths, same permissions, same instant. No staging step, no sync job, no copy of the copy.

$ docker run --rm -e STONE_TOKEN ghcr.io/stonestorage/stone \
    stone mount /mnt/stone --space fjordframe
✓ fjordframe.stone.no mounted at /mnt/stone
   # your render farm now sees the same drive as your colorist

Configuration

Configuration is a short file at ~/.stone/stone.conf. Most people never open it. The ones who do usually want three things: which space to mount, how much local cache to spend, and which folders to pin for offline work.

# ~/.stone/stone.conf — the whole file, honestly
space  = fjordframe
mount  = ~/Stone
cache  = 50G
# keep these fully local — planes, cabins, trust issues
pin    = /Projects/Active
pin    = /Fonts

REST API

Everything the client can do, the open REST API can do — it's the same surface, minus the drive letter. Authenticate with a bearer token and speak plain resources over https://api.stone.no/v1/. List folders, mint shares, read history, set tiers, register watches. The full API reference ships with your preview invite.

$ curl -s https://api.stone.no/v1/spaces/fjordframe/list?path=/EP04_Grade \
    -H "Authorization: Bearer $STONE_TOKEN"
{
  "path": "/EP04_Grade",
  "entries": [
    { "name": "reel_02.mov", "size": 48318382080, "tier": "hot" },
    { "name": "stills", "kind": "folder", "items": 214 }
  ]
}

Glossary

Our world, translated into yours. Twenty-three words, no homework.

Filespace

Your organization's one shared drive. Every member mounts the same tree, live — there is no "my copy."

Chunk

A small piece of a file. Files are split into chunks, and chunks are what gets stored — each one exactly once. Around here we sometimes call them pebbles.

Fingerprint

The unique identity of a chunk, derived from its content. Two identical chunks share a fingerprint no matter where, or when, they came from.

Recipe

The list of chunks that makes up a file. Copying a file copies the recipe, not the chunks — which is why copies are instant and free.

The bedrock

Our name for the deduplicated store where every unique chunk lives exactly once — one chunk, one place, however many files point at it.

Content-defined chunking

Splitting files by what's in them rather than at fixed positions, so an edit in the middle only changes the chunks nearby — not everything after it.

Chunkey fanout

How chunks travel: many small transfers in parallel instead of one long one. Big files arrive like rain, not like a pipe.

Deduplication

Storing each unique chunk once. The second copy of anything, anywhere in your filespace, is a bookkeeping entry.

Unique data

What you actually pay for: the chunks nobody in your filespace had stored before. Usually a fraction of what the folder sizes add up to.

Mount

The filespace appearing as a real drive on a machine. Finder, terminal, render node — same tree, same rules.

Streaming

Browsing everything while downloading nothing. Bytes arrive when a file is opened, not before.

Pinning

Telling the client to keep chosen folders fully local — for planes, cabins, and deadlines that outrank the Wi-Fi.

Metadata

Everything about your files except their bytes: names, sizes, dates, permissions. It's what updates instantly on every connected client.

Watch

A standing request to be told the moment something changes, anywhere in the world — as a notification, or as a command that runs.

Rewind

Seeing or restoring any file or folder as it was at any past instant, down to the nanosecond. Forward is never lost.

Tier

The temperature of data — hot, standard, archive, long-term. Same names, same paths, different price per byte.

Share link

A link that is itself a permission: scoped to a path, optionally read-only, optionally expiring, always revocable.

Cross-company grant

Giving people at another organization access to a folder. It appears inside their own mount; nothing is exported and nothing is copied.

ACLs — NFSv4 & Windows DACLs

The access rules on folders and files. Stone speaks NFSv4-style ACLs natively and presents them as Windows DACLs and macOS permissions — one rule, enforced identically on every platform.

Organization

The company or team that owns a filespace — its members, roles, and policies.

BYO bucket

Bring-your-own storage: your bytes live in a storage account you own, in your name and jurisdiction, with Stone running everything above it.

Container mount

The filespace mounted inside a container or cloud machine — the drive your laptop sees, showing up on a render node.

Seat

One person in your organization. Pricing counts seats and unique data; nothing else.