Hey.xyz: the archived open source snapshot of a Lens Protocol social app

What the Hey.xyz snapshot actually is

Hey.xyz is a social media application built on Lens Protocol, where profiles, posts and interactions live on chain rather than in a single company's database. The repository carries a notice that is unusual for a project of this size: it is the last publicly available open source version of Hey.xyz before May 15, 2026. Everything after that date is closed, and the README states plainly that no claim is made that this code represents the current implementation running on hey.xyz.

That framing matters more than any feature list. You are not looking at a maintained product you can fork and ship. You are looking at a preserved codebase, published for archival, educational and research purposes, per the disclaimer. The audience is developers who want to read how a production-grade decentralized social client was put together, or who want a base for their own Lens application and accept that they are starting from a frozen point.

The stack is TypeScript, React, Next.js, Tailwind CSS, GraphQL, Wagmi and Viem, with PostgreSQL and pnpm underneath. The repository is a monorepo-style layout, and the README notes that the exact structure may vary between historical commits and branches.

How a permissionless feed is assembled: GraphQL, Lens SDK and wallet state

The mechanism visible in the repository is a client that reads social data from a Lens indexer over GraphQL and writes actions through wallet-signed transactions. The package manifest makes the split concrete. Apollo Client handles GraphQL queries, the Lens chain SDK and the Lens storage client handle protocol-level operations, and Wagmi and Viem sit under the wallet layer. A codegen script points at a GraphQL config under the indexer directory, which means the query types are generated from a schema rather than hand-written.

Data flow runs in two directions. Reads go out through Apollo against the configured indexer endpoint and land in React components through TanStack Query and Apollo's cache. Writes, such as publishing a post or following an account, are composed into metadata, uploaded to a storage provider, and then submitted as a transaction the user signs in their wallet. The presence of the Lens metadata package and the storage client in the dependency list is what ties those steps together.

This architecture is the reason the README warns that a successful local build does not guarantee a deployable application. Every one of those layers points at external infrastructure: indexer GraphQL endpoints, RPC endpoints, storage providers, authentication systems and blockchain networks. The README lists all of them as things that may have changed since this version was published. A build that compiles tells you the TypeScript is consistent. It tells you nothing about whether the endpoints still answer.

Installing Hey.xyz locally and getting the dev server up

The README gives a straightforward path. You need Node.js v22 or later, pnpm, PostgreSQL and Git. NVM is recommended for managing the Node version, and the repository includes an .nvmrc file, so the version install command works from the root.

Clone the repository and move into it first:

git clone https://github.com/slymnoyann/hey.xyz.git
cd hey.xyz

If you are working from a fork, the README says to replace the URL accordingly. Then install the Node version pinned by the repository and confirm it:

nvm install
nvm use
node -v

The expected result is a version at or above v22. Next, install pnpm globally if you do not have it, and verify both the package manager and the project dependencies:

npm install -g pnpm
pnpm -v
pnpm install

Before starting anything, copy the environment file. The README shows this example and notes that additional configuration may be required depending on which package or application you are running:

cp .env.example .env

Typical configuration covers Lens settings, the database connection, Redis, API authentication, wallet or private key values, storage and general application settings. The README is explicit that private keys, API secrets and database credentials must never be committed. Once the environment is populated, start the development server:

pnpm dev

Open the local URL printed in the terminal. Note that the package manifest defines the dev script as a Vite dev server on port 4783, and the start script serves a preview build on the same port bound to 0.0.0.0. If you plan to type check or lint before committing, the repository exposes pnpm typecheck, pnpm biome:check and pnpm biome:fix, plus maintenance scripts under the script directory for cleaning generated files and updating dependencies.

The build succeeds, the app does not: the snapshot's central failure mode

The most honest thing in this README is the development note. Because the code targets external services that have moved on, the realistic failure mode is not a compile error. It is an application that builds cleanly, starts, and then shows empty feeds, failed authentication or rejected transactions because a GraphQL endpoint, an RPC provider or a storage API no longer behaves the way this version expects.

That is a different debugging experience from a normal dependency upgrade. The failure surfaces at runtime, often as a silent empty state rather than an exception, and the fix may require rewriting the query layer against a schema that did not exist when this code was written. The README names the moving parts directly: Lens Protocol APIs, GraphQL endpoints, RPC endpoints, third party APIs, database schemas, authentication systems, storage providers, blockchain networks and wallet infrastructure.

There is a second, quieter limitation. Contributions are accepted through forks and pull requests, but the README states that this repository does not represent the current private development codebase. Any fix you make lands in a snapshot, not in the product. If your goal is to run a live Lens client, this repository is a starting reference and not an operational base, and treating it as the latter will cost you more than starting from the current protocol documentation.

Hey.xyz compared with building directly on the Lens SDK

The real alternative is not another social app. It is writing your own client against the Lens SDK and the indexer GraphQL API without inheriting this codebase. The difference is one of scope and obligation.

Starting from the SDK gives you the same primitives Hey uses: the Lens chain SDK, the metadata package, the storage client, Wagmi for wallet connection. You write your own routing, your own component library, your own caching strategy. You carry no historical assumptions about endpoint shapes, and you pick your own React version and build tool. The cost is that you rebuild the parts of a social client that are tedious rather than interesting: feeds, pagination, optimistic updates, media handling, moderation surfaces.

Taking the Hey.xyz snapshot inverts that trade. You inherit a complete, opinionated application with a working information architecture, and you inherit its age. The dependency list shows React 19, Vite, Biome and a React Router based setup, which is a modern baseline, but the protocol integration points are the ones that date fastest. If your interest is learning how a permissionless social client is structured, the snapshot is richer than the SDK documentation. If your interest is shipping, the SDK is the shorter path, because you will end up rewriting the integration layer either way.

Licence, maintenance and what upgrading this snapshot costs

The project is released under the GNU Affero General Public License v3.0, and the package manifest confirms AGPL-3.0 as the package licence. The AGPL's network clause is the part that matters for a social application: if you modify the code and let users interact with it over a network, the licence's source disclosure obligations extend to that deployment. Whether that fits your plans is a question for your own counsel, not something this article can settle.

The maintenance picture is unusual. The repository is not archived, and the last push was on 2026-09-06, so it is recent enough that the snapshot is not abandoned in the ordinary sense. But the README defines the project's own boundary: development after May 15, 2026 is not open source. Activity on this repository therefore does not imply that the code is being developed toward the production application. Upgrading it means upgrading a frozen integration layer against live infrastructure, and the README's own warning about external services is the upgrade guide you get. There are no retrieved releases to pin against, so versioning discipline falls entirely on you.

Editorial conclusion

Adopt this repository if you want a working reference for Lens Protocol client architecture in React and Next.js, or if you are studying how a permissionless social feed is assembled from GraphQL indexers, wallet connectors and storage clients. Do not adopt it if you need the code that currently runs on hey.xyz, because the README states that development after May 15, 2026 is not open source and that the production version may differ substantially. Before you invest time, verify that the pinned Lens and indexer endpoints in the environment files still resolve, and check whether the AGPL-3.0 obligations fit how you intend to deploy any modified version.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-3.0
3. Project website
4. README
5. slymnoyann/hey.xyz on GitHub