Farcaster just produced three different answers to the same question in roughly 36 hours: what does it mean to be able to leave?
On November 10, @sayangel released Warpstack, a set of building blocks for running a client on a backend you control. Later that day, @wake said Hypersnap would fork in two days, then repeated "We're forking. Tomorrow" at 12:54 UTC on November 11. Earlier that morning, @dwr shipped Fatline for iOS and Chrome, then summarized the result: three open source clients across macOS, iOS, and a Chrome extension.
Those are not three versions of the same thing. They are three layers of an exit stack:
Fatline: replace the interface.
Warpstack: replace the interface and the backend.
Hypersnap: replace the validator set and fork the network state.
That distinction matters. A new screen is not the same as a new server. A new server is not the same as independent consensus. This week is the first time the Farcaster feed has made all three layers visible at once.

Image via @dwr, from this cast.
Fatline's strongest decision is subtraction.
The repository describes a small client that reads people you follow, posts, and deletes. It deliberately leaves out replies, reactions, notifications, profiles, following, and interaction with people outside your graph. The same core now ships as a Mac app, an iPhone TestFlight build, and a Chrome extension that replaces the right rail on X.
This is real client diversity, not a mockup. The apps build the feed and sign messages on the user's device. The recovery phrase is used to authorize a posting key and is not stored. The repository is MIT licensed, and the Chrome source includes build instructions rather than asking users to trust an opaque extension-store binary.
But Fatline is also unusually clear about what it does not decentralize. By default, reads still go through Neynar. Its optional Cloudflare Worker is a proxy to the operator's own Neynar account, so self-hosting the proxy changes who controls the API key but does not remove the upstream dependency. A custom server can answer the required Neynar-shaped and Snapchain routes, but the client does not verify signatures on data returned by that server. Fatline's own README warns that a dishonest server could show false posts or names, or pair visible content with the wrong post ID.
That honesty is a feature. Fatline proves that a client can be small, legible, and forkable. It does not pretend that a forkable interface automatically produces a trustworthy data path.
The first obvious gap appeared immediately in the replies: "What about android". The deeper gap is server verification. If lightweight clients multiply, the ability to prove which network and record a server is showing becomes more important, not less.
Warpstack starts where Fatline's custom-server option ends.
Its repository packages a protocol layer, an on-device wallet, a typed API contract, a Cloudflare backend, a headless client, UI components, and an app generator. The stated target is a complete client and server that a person or agent can assemble in under an hour. On November 10, @sayangel showed a template client served by a personal backend.
The architecture is more ambitious than a frontend kit. Snapchain is treated as the database. The backend indexes it into rebuildable caches. Posting keys stay on the phone; the server cannot sign as the user. The iOS vault puts the recovery phrase through native Rust code and stores the app key in Keychain, wrapped by the Secure Enclave. A generated app can use its own Snapchain node or point at a public one.
This is the layer where "run your own client" starts to mean operational independence.
It is not one-click sovereignty yet. The setup guide says the process needs about ten minutes in Cloudflare's dashboard, a paid Workers plan, an API token, and then one deployment command. The stack is iOS-first. Browsers are read-only. Android, search, push notifications, and mini apps are still planned. Channel names and followed-channel state still come from Farcaster's hosted API because that state is not on Snapchain. The repository also says the code is early, expects breaking changes before 1.0, and has not been independently audited.
That is still a meaningful advance. Warpstack makes the dependency graph inspectable. It shows exactly what can be rebuilt from Snapchain, what remains private server state, which hosted services remain, and which code paths are security-critical.
Hypersnap is the part of this week that cannot be reduced to app choice.
The current validator configuration defines an initial Hypersnap fork set of eight validators collected in issue 51. It schedules three shard cutovers at block heights 50,433,538, 51,119,199, and 50,954,121. The repository estimates activation around November 12 at 09:25 UTC, but correctly notes that the timestamp is only a projection: the fork activates at the block heights.
The uncomfortable detail is also in the repository. A November 9 commit postponed the cutover by three days "so peers can prepare after consensus was lost." That is not a reason to dismiss the fork. It is the reason to treat the launch as infrastructure rather than theater. Validator connectivity, fork-height coordination, and recovery behavior are the product.
The preflight evidence is mixed. At 13:09 UTC on November 11, the public Cassie node was still below all three cutover heights, as expected, but reported version 0.17.3. Cassie had publicly described 0.17.4 as the release update that begins the validator fork process, and the repository's current main branch carries that version, but there is no matching GitHub release tag. The verification run for that main commit passed formatting, unit tests, and one integration suite while a second integration suite failed. None of this proves the fork will fail. It does mean "ready" is not yet a claim the public evidence can support. I also found no primary-source checklist showing that all eight validators are peered and prepared.
Hypersnap's bridge between the old and new worlds is a shuttle that relays compatible signed user messages in both directions. It preserves original signatures and hashes, keeps persistent cursors, and suppresses loops. But it does not relay consensus, block certificates, onchain events, or Hypersnap's new native registrations. Native accounts and messages from those accounts are not sent back to Snapchain.
So the two networks may look continuous at first, but they are designed to diverge.
That matches the maintainer's answer in the validator issue: clients may initially see little difference because messages are relayed, but each side will add features and drift. The missing piece is how a normal user can tell which chain a client is reading from and writing to. One developer asked that exact question in issue 51. The eventual answer cannot remain "essentially no different." Once state diverges, invisibility becomes ambiguity.

Image via @wake, from this cast.
The best thing shipped this week is not a feature. It is explicit trust boundaries.
Fatline says the server can lie about what you see but cannot sign as you. Warpstack says which hosted state remains and which features are not built. Hypersnap documents which messages cross the shuttle and which do not. These are much better foundations than a vague promise of decentralization.
The second win is scope. Fatline is useful because it refuses to become another everything-app. Warpstack is useful because it treats backend portability as a first-class product. Hypersnap is useful because it turns disagreement about network operation into code, block heights, and a validator set.
Farcaster now has pieces of an exit stack, but not yet a clean exit experience.
Every client should expose four facts in one place: the client build, backend operator, network identity, and current write destination. Every backend should return a machine-verifiable network identifier and fork height. Every fork should publish live validator readiness, expected cutover heights, and rollback or recovery conditions before activation.
The ecosystem also needs one portability test that all three layers can run. Start with the same existing FID and follow graph. Read ten known casts. Post, reply, react, and delete. Switch the backend. Switch the node. Confirm which actions propagate across the shuttle and which remain fork-local. Then publish the receipts.
That test would do more for credible exit than another client screenshot.
The feed is not celebrating one winner. It is discovering that client choice has layers.
Fatline makes the interface forkable. Warpstack makes the operating stack forkable. Hypersnap makes consensus forkable. The next job is to make those choices legible to users before the layers drift apart.
Farcaster's decentralization story has spent years living in architecture diagrams. This week it moved into app builds, deployment commands, validator keys, and exact block heights. That is progress. It is also where the easy slogans end.
I checked the direct Farcaster casts and their UTC timestamps, then compared their claims against the public repositories and current documentation. I reviewed Fatline's README, custom-server contract, Chrome security notes, and Cloudflare proxy guide; Warpstack's README, architecture, security model, and deployment guide; and Hypersnap's validator configuration, fork-height commit, native-registration documentation, shuttle documentation, validator issue, public node status, release list, and latest verification workflow.
I did not install the apps, deploy Warpstack, or run a Hypersnap validator. Product behavior above is attributed to the projects' source and documentation, not presented as my own test. The Hypersnap activation time is an estimate; the three block heights are authoritative.
