Lead with r/rust day 1 (Tue-Thu, ~9-11am ET). Stagger the rest over 2-3 days and tailor each (identical cross-posts trip spam filters). Put the link in the body, not the title. Reply to every early comment within the first hour. The dev crowd treats "open source + on GitHub" as a plus, lean into it. Link to use: lunarfs.com (repo: github.com/Emotions-Research/LunarFS). Embed the demo gif or link lunarfs-demo.pages.dev.

I built a content-addressed filesystem in Rust that forks a repo into an isolated workspace in ~13ms

I've been building LunarFS, a content-addressed filesystem for spinning up isolated repo workspaces fast. What started it: running a lot of coding agents in parallel, where each one needs its own copy of the repo, and `git worktree` is too slow and eats too much disk once you have dozens of them.

How it works:
- A BLAKE3 content-addressed store holds every blob once, addressed by hash.
- A copy-on-write overlay means forking a workspace copies a root ref, not bytes. It's O(1).
- It mounts via an embedded NFS server (no FUSE-T/kext install) and files hydrate lazily on first read, so mount is instant no matter how big the repo is.

Benchmark on the actual Linux kernel (94,695 files, 2.0 GB):
- `git worktree add`: 7.4s (it writes every file)
- `lunar ws fork`: ~13ms (zero bytes copied)
That's roughly 550x, and the gap grows with repo size.

[demo gif]

Written in Rust (nfsserve for the mount, BLAKE3 for hashing). Free and on GitHub. Happy to go deep on the CAS + overlay design.

https://lunarfs.com

Give every coding agent its own disposable copy of the repo — forks in ~13ms instead of git's 7s

If you run coding agents in parallel (SWE-agent style, multiple Claude/Codex workers, RL or eval harnesses), you've hit the workspace problem: every agent wants an isolated copy of the repo, and git worktree / clone per agent is slow and burns disk.

I built LunarFS for exactly this. Content-addressed filesystem with copy-on-write workspaces:
- fork an isolated workspace in ~13ms (vs ~7.4s for git worktree on the Linux kernel), sharing bytes via a BLAKE3 store.
- mount instantly; files hydrate lazily, so an agent that touches 5 files never pays for the other 90,000.
- throw the workspace away when done; the diff is durable, the rest costs nothing.
- there's an MCP server: `npx lunarfs-mcp` exposes fork_workspace, mount, push, etc. so an agent calls them natively.

One line: an instant, disposable copy of your repo for every agent. 50 agents, one copy of the bytes.

[demo gif]

Free and on GitHub. Curious what people running agent fleets think.

https://lunarfs.com

LunarFS: a self-hostable content-addressed filesystem — fork huge repos in milliseconds, dedupe everything by hash

Sharing a tool I built and self-host: LunarFS, a content-addressed filesystem for developer repos.

Every file is stored once and addressed by its BLAKE3 hash, so identical content across branches, snapshots, and machines is deduplicated automatically. Fork a workspace (an isolated repo copy) in milliseconds because a fork is just a new root reference. Mounts are lazy: the tree appears instantly and bytes are fetched only when a file is read, via an embedded NFS server with no kext/driver to install.

Why I like it self-hosted:
- Spin up isolated copies of a big repo with near-zero disk and time.
- Sync workspaces across machines through the content store (same hash = already have it).
- Per-path ACLs so each process only touches what it should.

Run your own with one binary (`lunar serve`). Free, code on GitHub. Forking the Linux kernel (2 GB) took ~13ms vs git worktree's 7.4s.

https://lunarfs.com