Today is April 19, Bicycle Day, which feels like a fitting time to take a new decentralized architecture for a spin. The EFS Devnet alpha is now live.

This is a public testing environment for the EFS protocol and client end-to-end. It is live enough to use, but early enough to break. For now, the devnet runs on a pinned Sepolia fork rather than public Sepolia, because the system is still changing quickly. Connect a wallet and it will be auto-funded on first contact, so you do not need to worry about gas costs or finding a faucet.

In other words, this is a low-friction way to start exploring EFS before the shape of the system hardens.

Try it here

https://app.efs.eth.limo (https://app.efs.eth.link works too)

What you can do today

The interface is still basic, but right now you can already:

• upload files to the devnet

• browse parts of the EFS client and explorer

• inspect tagged and seeded content paths

• test early social/file workflows

• break things and tell me what feels wrong

Data onchain by default

One of the most distinctive features of this alpha is that files go onchain by default. This alpha is not just about interface testing - it is about exploring the limits of what native Ethereum storage can actually support. The intended launch architecture uses IPFS as the main file transport, alongside Arweave, but for now, you get an onchain-first experience.

Important caveats

This is a playground, not a permanent home for important data. If you do not mind sharp edges, I would love for you to try it.

Please assume:

• devnet files will be deleted weekly

• things may crash

• things may change at any time

• parts of the architecture are still evolving

• some explorer views and seeded content are still under active iteration

Why release now

I would rather get EFS into people's hands early than wait for a false sense of completeness.

The architecture is solidifying, but it isn't fully there yet. Getting real usage and real feedback right now will shape the product, the architecture, and the user experience much more effectively than keeping it private for another few weeks.

Feedback wanted

The best time to get feedback is before the shape of the system hardens. I would love for you to try the system with free devnet gas and report what feels broken or confusing.

I am especially interested in:

• bugs and crashes

• confusing UX

• what feels intuitive

• what doesn't make sense yet

• what you expected to be able to do next

Best places to send feedback:

• EFS Discord: https://discord.gg/Erp3ZYDQBh

• GitHub issues for technical bugs and problems: https://github.com/efs-project/contracts

• @JamesCarnley on X/Twitter

• replies in the devnet launch thread

A bigger story post unpacking the full vision is coming later, along with a presentation on May 8. But for now, this is the beginning, not the finished form.

Enter the Ethereum File System (EFS), an open source public good for organizing and using onchain data.

Ethereum is the first global computer without a global folder structure. We can verify, we can compute, we can settle value, but we can’t organize anything. EFS fills that missing primitive: a shared namespace the whole world can extend.

What is EFS? Anchors and Editions

The core of EFS revolves around two simple but powerful concepts: Topics (Anchors) and Editions.

1. Topics (Anchors)

Think of a Topic as a shared folder in the cloud. It is a namespace for a specific idea. If you want to see the world's collection of memes, you simply navigate to /memes/. This is a collaborative space where data regarding that topic aggregates.

2. Editions

Everyone can share their own version or edition of the data. This is where the Web of Trust comes in. On the legacy web, you see what the server admin wants you to see. In EFS, you see data from those you trust.

An Edition is simply a view of a Topic from a specific person's perspective (address).

• Navigate to /pets/bestpet.jpg@vitalik.eth and you might see a photo of an adorable cat.

• Navigate to /pets/bestpet.jpg@jamescarnley.eth and you'll see a photo of a dog providing unconditional love.

Instead of one canonical feed (like Twitter or Reddit), every Topic has infinite user-curated Editions. You see the world through the people you trust.

Why EFS? Reclaiming the Commons

The web is the best platform humanity has ever created for sharing information, but it is currently leased to us by gatekeepers. On the World Computer, we don't need gatekeepers. We need a credibly neutral space where everyone is treated equally, data is reliable, and working together strengthens the system for all.

EFS provides the tools smart contracts and users need to create and share data with dedicated file paths and systems that work entirely onchain. It is about creating a namespace that everyone shares but nobody owns: a Schelling Point, or natural gathering place, for ideas.

In the early days of the web, digital sovereignty meant running your own server in a closet. Today, the World Computer is that server. It is always on, it never crashes, and it creates a space where a non-technical user can "homestead" a corner of the digital universe that belongs only to them. EFS brings back that early Geocities energy, a place to experiment and express yourself, without the need for sysadmin skills or fear of a platform shutting down.

We aren't trying to replace the web. We are trying to rescue it. EFS is designed to weave the blockchain back into the fabric of the internet. Through standardized URIs, EFS allows for native cross-linking. An onchain blog post can link to an IPFS image, an Arweave video, or a contract on Optimism seamlessly. It breaks down the wall between crypto and the web, returning us to a state where navigation is fluid and data is agnostic to where it lives.

We are building EFS because we believe in the cypherpunk dream: a world where users are sovereign, data is uncensorable, and the commons belongs to everyone. EFS is an attempt to extend the best parts of the web like sharing, browsing, and discovery directly into the blockchain, aligned strictly with the values of the Trustless Manifesto.

Use Cases: What Can We Build?

Because EFS is a general-purpose information system, the possibilities are vast. Here are some I am most excited about:

• The Credibly Neutral App Store: A universal registry for decentralized apps. No Apple or Google to ban your app because it competes with them or a government demands it. Your list only shows apps and versions attested to by your web of trust. Easily extendible to decentralized package registries as an onchain version of NPM or PyPI.

• Web3 MySpace: A dedicated space for expression. Configure your own background theme, your top 10 memes, or the music that plays when people visit /JamesCarnley.eth. It is social media with soul, where you own the platform.

• Usenet 2.0: Long-running, uncensored discussion threads. Imagine /science/physics as a place for Markdown-based posts that live forever onchain, immune to the memory-holing of centralized forums.

• Universal Media Library: Crowd-sourced lists of all text, images, and videos that can be used to research topics or create tagged community datasets like meme databases and boorus. EFS could also serve as a credibly neutral home for useful community data like GitHub’s Awesome Lists.

• Decentralized Internet Archive: The Internet Archive is a civilizational achievement and treasure but is funded and influenced by powerful organizations like governments. We can crowd-source metadata and IPFS hosted files and let data hoarders ensure that no web content is ever lost again.

The Shell: An OS for the Open Web

To easily browse and create this data users can use the EFS Client. This is a static HTML/JS/CSS web app hosted on IPFS. It is built like an operating system:

• Kernel: Controls the wallet, RPC calls, and sensitive data.

• Shell: Handles the UI and user interaction.

• Apps: Sandboxed code that developers can build to view specific data types.

Crucially, these Apps are sandboxed by default. They can read attestations but have zero network access unless you explicitly grant it. This protects your privacy and ensures that the software serves you, not an advertiser.

User Sovereignty: Users Are Always in Control

This is the golden rule of EFS. There are no forced upgrades. Every setting is overridable.

The system reads settings data in a configurable hierarchy:

1. User (You)

2. Trusted Maintainers (Group you choose to configure your system)

3. EFS Core Defaults

4. Public (Optional)

If you browse to a folder like /ethereum/ and it has a background image set by the public consensus, you can override it. If you want a specific look, a specific filter, or a specific data source, your config wins. Always.

Onchain Software Configuration Layer

This is a killer use case for smart contract devs. Named, shared settings allow for standard options to be developed, read, and written to by different developers working in the same ecosystem. Because the data is live on-chain, it acts as a Windows Registry (for lookup), Mac App Groups (for shared state), and Linux D-Bus (for signaling) all in one trustless layer.

EFS becomes the shared config layer for:

• Wallets (RPC endpoints, token lists)

• L2s (Chain IDs, bridge contracts)

• Apps (Theming, feature flags)

• IoT devices (User preferences, automation rules)

Example 1: The Trustless UI A lending protocol stores recommended parameters under /protocol/lending/config. Users or interfaces can choose which Edition to trust (e.g., the "Official Dev" edition vs. the "Auditor Verified" edition). If the DAO votes to update a parameter, every subscribing UI updates instantly.

Example 2: The Sovereign Device A thermostat uses a light client to read the user’s preferred climate settings at /devices/hvac/temperature. It sets itself accordingly, requiring no third-party cloud, no login servers, and no corporate API keys.

This radically improves app composability, allowing us to upgrade from fragile "money legos" to robust "money monuments" that stand the test of time.

Under the Hood

For the technical minds, EFS is built on the Ethereum Attestation Service (EAS). We use the following core schemas to link everything together efficiently.

• Anchors: Schelling Point topic names

• Properties: Simple onchain Unix-like string data easily usable by contracts and humans allowing EFS to act as a configuration layer for other protocols

• Data: File system functionality for files, shortcuts, and hardlinks

• BLOBs: Stored on and off chain data pointers with associated MIME types

• Tags: Simple strings used to categorize data as being related to a topic

Is this expensive? Think of EFS as the Directory, not the Hard Drive (yet). While it is capable of storing full files onchain (especially valuable on low-cost L2s and L3s), it primarily stores metadata, pointers to where your data lives. Whether you use IPFS, Arweave, or BitTorrent Magnet links, EFS acts as the immutable link that ensures your content is always findable.

Who controls the protocol? Nobody. EFS is a Hyperstructure, a protocol that runs for free and forever, without maintenance. The contracts are immutable at launch. There is no DAO, no admin key, and no "team" that can shut it down.

It is designed to work onchain with no external dependencies for core logic, while being extensible via GraphQL for complex app interfaces.

EFS also includes a URI which allows for cross-chain data references and native web hyperlinks to onchain data. You can link a friend directly to a resource, like https://efs.eth/#arbitrum/memes/vitalikclapping.gif, and it will load easily in their EFS Shell.

There are way too many technical details to include in a high level blog post like this but future entries will contain deeper dives into various components.

Join the Community

If Ethereum is the World Computer, a global file system with user freedom at its core is not optional, it’s inevitable. Someone has to build it. We chose to.

Read more, join the Discord, and more at https://efs.eth

Let's build the commons together 🖖 -JamesCarnley.eth

Special thanks to Kinchasa.eth, AMIIC.eth, Tom Peterson, and Zach Ketterhagen for their help reviewing this blog post