Writing, reading, verifying
No fee, no gate, no account. The reference registry is open source; run your own if you prefer ours.
web4 · open protocol · Apache-2.0 · pre-alpha
The database for
anything digital.
Store anything. Verify it anywhere. Pay only for the copies you choose to keep.
Verify this registry in your browser → · Watch AI artifacts verify themselves → Make an AI proof in your browser → · Public registry bundle and seed list →
Any object → one claim
A payload, its meaning, and its proof, in one signed envelope.
One verifier, two runtimes
The same bytes are recomputed in a browser and on a server.
k-of-n, not promises
Erasure-coded shards that rebuild the file when holders disappear.
The network
web4 is the free-for-all layer.
Not a token, not a chain, not a browser. A network where any object, claim, or agent carries its own proof, and anyone with a device can hold bytes, verify work, and be paid for it. RAREXT is the protocol; ApesDaily is where the public meets it.
No gatekeeper for reading
A payload is reachable from a hash and a mirror, not from permission.
No gatekeeper for verifying
The verifier is a file you can read and run in a browser tab.
No protocol token
Apps may launch tokens. The protocol's job is to make the launch checkable.
Read the definition, including the primitive that is still missing →
The honest definition
What “free” means here
The protocol does not bill you. That is a real property, and it is a narrow one. Here is exactly where it stops.
One device, one copy
If your machine holds the bytes, it costs the protocol nothing — and it is a single copy. That is a backup that has not failed yet, not durability.
Durability is bought
More copies cost more disk somewhere. RAREXT makes the price explicit: k-of-n shards, published replica counts, retention challenges.
Physics still applies
Electricity, bandwidth, and the device are real costs. They are yours, and we do not pretend they vanished. Nothing here beats Shannon.
The mechanics
Four steps, each one checkable
-
01
Publish and sign
Any file becomes a publication: a content hash, a kind, a meaning, and a signature from ECDSA-P256 or ML-DSA. The signing suite is recorded, so a reader knows what the proof is worth.
-
02
Recompute, don't trust
A deterministic verifier re-executes the claim. The shipped verifier runs unchanged in the browser and on the server and returns the same attestation from both.
-
03
Anchor to a chain
The Merkle root is anchored to a hash-linked log. The registry reads it back from an independent path before it says “confirmed” — a write is not a receipt.
-
04
Replicate as shards
Files are split into k-of-n Reed–Solomon shards and placed on distinct holders over HTTP. Each holder answers a nonce-bound Merkle challenge; lose holders up to n−k and any k rebuild the file, and a failed shard is repaired onto a spare.
Measured, not promised
Storage is real, inside stated limits.
Erasure-coded shards, signed placements, nonce-bound holder challenges, repair, and availability sampling run today. These are the measurements, including where they stop.
1 GiB · 394 MiB peak
File-backed encode/decode. The latest rerun was 393 MiB; the in-memory path was 3,243 MiB.
1 GiB · 249 MiB peak
Streamed over raw holder HTTP. The latest rerun was 242 MiB; holder peak was 94 MiB.
5,910 · 100%
Puts and retrievals in a 604 s churn soak, with 145 repairs, zero failed re-audits, and 23 holder kills.
44 · 4 KiB
Random samples detect 10% withholding at 99% confidence, for 176 KiB read.
The earlier 611 s soak did 143 repairs and 100% retrievals, but only 99.9% of puts; retry is what moved the next run to 100%. Do not combine the two runs into a single claim.
Shipped, not promised
What runs today
publication & claim envelopes
deterministic verifiers
registry with mirror & takedown
signed agent identities
Merkle anchoring + read-back
content-addressed storage
proof of possession
erasure shards + holder audits
holder HTTP transport
signed placement records
scheduled durability challenges
repair & re-challenge
verified registry backups
storage benchmark harness
independent verifier operators
key rotation & delegated publishing
leaderboard & capability discovery
data availability sampling
self-hosted pinning
fair-launch trajectories
published negative results
work economy & credit ledger
agent market
MCP server
multi-chain anchoring
web workbench
4 workspace packages
Every change ships with tests. The takedown test publishes, takes the operator offline, and verifies the mirror with the shipped verifier.
Truth over hype
Compression trades bytes for structure, fidelity, or compute. Erasure coding trades bytes for durability. Verification keeps both honest — and it only works if the claim says which trade it made.
Open by default
Build with us
RAREXT is meant to be built by more than its maintainers. Run a registry, write a verifier, build an app, or argue with the design — all of it is welcome.
Contribute
Setup, tests, commit rules, and the DCO sign-off. Start with a small, focused PR.
Good first issues
Tasks sized for a first contribution, labelled and kept current.
Roadmap
What is next, what is blocked, and what we have deliberately refused to build.
RFCs
Design changes start as an argument in writing. This is where the argument happens.
Discussions
Questions, ideas, and “is this possible?” before it becomes an issue.
Fork it
You do not need permission to fork, run a node, or publish a verifier.