A normal folder, replicated.
~/kullu lives on your native filesystem. Your editor, shell, build tools, and agents use it like any other directory.
~/kullu├── projects/├── notes.md└── staff/ realm
Experimental preview for macOS and Linux
Everything you need,
where you want it.
Kullu replicates a normal folder across every machine you trust.
Normal local filesWork offlineKnow when you’re synced
>_
workstationlinux/amd64
>_
laptopdarwin/arm64
slicer-vmlinux/arm64
brief.md
build/
✓ durable copy
$ kullu statusSafe to stop: true
Five seconds, two machines“I’m in a café, and I need my
“I’m in a café, and I need my AGENTS.md.”
Linux at homehome-linux · linux/amd64
Mac at a cafécafe-mac · darwin/arm64
Stay in the flow
Local files that travel.
Put a file in ~/kullu on one machine. Kullu replicates it into the same normal folder on every machine you trust.
Work offline
Keep working when the network disappears. Kullu catches up when peers can reach each other again.
It works over your existing network
Use the LAN, VPN, reverse proxy, or HTTPS tunnel you already have.
Know when you’re synced
kullu flush waits until another peer confirms it has the current files.
Remote copies1Waiting0 files
✓ Synced
Built for agents
A distributed folder for agents.
Agents hand builds, drafts, and feedback to you or to each other through ordinary files.
Let agents collaborate through files.
- The problem
- An agent needs to hand a build, draft, or result to you or another agent.
- With Kullu
- It writes the file once. The next person or agent receives a normal local file.
The VM is finished. Keep its work.
- The problem
- A build or agent output disappears when the machine does.
- With Kullu
- Run
kullu flush, confirm another machine has it, then tear the VM down.
A shared place for people and agents.
- The problem
- A collaborator needs selected files, not your personal Kullu home.
- With Kullu
- Invite them into an isolated realm with its own members and write policy.
A real hand-off
A shared filesystem becomes the message bus.
No webhook, queue, or upload step. The agent writes a file. The file arrives.
claude · home-linuxlinux/amd64
>
kullu
waiting for a file
claude · cafe-macdarwin/arm64
Share a part, not everything
Protected realms for colleagues and customers.
A realm is a named directory with its own membership and write policy. It is mounted beneath each member’s Kullu home but never enters their personal peer network.
- Independent owner-signed membership
- Read-write or read-only invitations
- Different local mount names on each machine
- The same daemon and endpoint you already run
# Create and invite
kullu share create staff
kullu share invite staff
# Join without merging personal files
kullu share join --mount staff \
--invite 'kullu2:…'
✓ mounted at ~/kullu/staffInstallation
Get in the flow and stay there.
Install Kullu on two machines, then replicate ~/kullu between them.
Mac or Linux
Install the binary
Kullu is distributed as a small multi-platform OCI package. arkade selects the right binary for your machine.
The PATH change is temporary and applies only to this terminal. Add ~/bin to your shell profile later if it is not already there.
mkdir -p ~/bin
arkade oci install ghcr.io/openfaasltd/kullu:latest ~/bin
export PATH="$HOME/bin:$PATH"
kullu versionInstall arkade first if needed. Prefer a guided story? The binary is self-documenting: kullu tutorial, kullu tutorial lan, or kullu tutorial inlets-cloud.
Questions, answered
What you need to know.
Why not just use Dropbox?+
Dropbox is a centralised service: an account, a storage plan, and a copy of everything you sync held on a company’s servers under their terms. Kullu is a tool you run yourself. Files replicate directly between machines you own and trust — the only copies in existence are the ones on hardware you chose. Ownership is not a promise in a policy; it is possession. There is no account to create, no tier to outgrow, and no rate limit beyond your own network. You choose the peers, you decide who can write, and the only storage limit is your own disks. It suits the machines you reach by SSH — workstations, VMs, and agents — rather than documents you share from a browser.
Where did the idea come from?+
Two everyday itches. Sharing files with colleagues meant standing up an ad-hoc inlets fileserver and tunnel for every hand-off, with auth tokens to mint and pass around — proper work each time, when dragging the file into Discord was right there. But drag-and-drop does not scale to larger files. And working remotely, often on a Mac, meant binaries, websites, and docs built on machines elsewhere that ought to follow you around — not pulled, not fetched, just already there on whichever machine you sat down at.
1970s
/home/alex→1990s/home/alex/public_html→Now~/kulluThe inspiration is older, though: Unix web servers published each person’s ~/public_html at example.com/~alex — one well-known folder that travelled further than the machine it lived on. Kullu carries that folder between your machines.
Where does the name Kullu come from?+
كُلّ
Kullu takes its name from the Arabic kull: “all”, “every”, or “the whole”.
Does Kullu run a central server?+
No. Every member keeps a complete local replica and peers pull directly from one another. Stable reachability may come from your LAN, private network, tunnel, or reverse proxy.
How do peers connect to each other?+
Kullu needs each peer to have an address that its trusted peers can reach; it does not prescribe the network. On one LAN, use the machine’s private address. Across networks, use an existing VPN, SSH forwarding, your own reverse proxy, or an HTTPS tunnel such as inlets Cloud, ngrok, or Cloudflare Tunnel. A relay is useful when laptops move between cafés, homes, and offices because its public address remains stable while the outbound tunnel reconnects. Kullu handles device identity, signed requests, manifests, and replication; the chosen route handles reachability and, when applicable, transport encryption.
How is traffic encrypted?+
Over the public Internet, Kullu is encrypted in transit by the HTTPS endpoint you choose. An inlets tunnel is one example. On a VPN, the VPN layer encrypts the route. Plain HTTP is available only as an explicit opt-in for trusted private LANs, where application requests are still signed and peers authenticated.
Are files downloaded atomically?+
Yes. Kullu writes to a temporary file, verifies its declared size and SHA-256 digest, syncs it, then atomically renames it into view.
What about case-sensitivity on macOS?+
Kullu guides new Mac users towards a case-sensitive APFS volume at /Volumes/kullu, permanently linked from the familiar ~/kullu path. Run kullu setup macos.
Who makes Kullu?+
Kullu was created and is maintained by OpenFaaS Ltd, the creators of OpenFaaS, inlets, and SlicerVM.
What does Kullu cost, and how is it licensed?+
The current preview is free. Its End User Licence Agreement permits use, copying, modification, distribution, sublicensing, and sale. Feedback is covered by a broad licence to OpenFaaS Ltd, while you retain ownership of it. There is no Kullu account or hosted plan to buy; a VPN, tunnel, VM, or relay provider you choose may have its own costs.
How does Kullu compare with other file tools?+
Dropbox
A central cloud account with web and mobile clients, including online-only placeholders. Kullu has no central file store or account service and favours complete local replicas on machines you control.
Restic
An encrypted backup tool that writes versioned snapshots into a repository for recovery. Kullu keeps a current working tree moving between trusted peers, with ordinary files available directly on every machine.
Syncthing
General-purpose folder synchronisation with discovery, relays, and a Web UI. Kullu is a smaller, opinionated CLI built around one familiar home, explicit invitations and realms, stable user-chosen endpoints, and a durable flush barrier.
Taildrive
A WebDAV view of folders served by machines on a tailnet. The serving machine and Tailscale must be available. Kullu creates complete ordinary local replicas that remain usable offline and does not require a particular private network.
IPFS
A content-addressed network organised around immutable CIDs, discovery, and pinning for persistence. Kullu keeps mutable, human-named paths in sync among a small set of authenticated peers with explicit custody.
Stay in the flowStart replicating
Start replicating →