Batteries Included

May 3, 2026

Try to list the places where you make things in public. GitHub. Bluesky. Maybe Farcaster. Maybe a Notion page someone dropped a link to. Each one is a tenancy. The lineage of your work — who forked what, who reacted, which commit came first — lives in someone else’s database. If they go down, it goes with them. If they change the rules, your work changes too. Export gives you a tarball; the social graph and the attribution stay behind.

The interesting question is not which platform should I publish on? The interesting question is what would a place built for making things actually need?

The maker’s rules

Before any code is touched, a maker would write down a small list:

Provenance. Every action — a commit, a fork, a reaction, a follow — is signed by the actor and verifiable without trusting a host. Identity is cryptographic, not an account row.
Permissionlessness. Anyone can create a project. No allowlist, no application form, no pricing page in the way.
Finality you can feel. Sub-second confirmation that the thing you just made is real and ordered against everyone else’s. Not eventual.
Lineage that survives a fork. When someone remixes your project, the chain remembers the parent. The parent cannot strip the lineage; the fork cannot fake it.
Portable identity. Your owner_address belongs to you, not to the host you happened to publish through. Move hosts, your work and graph come with you.
No tenancy. Storage is a claim you own, not rent paid to a platform.

These are the rules. They are not novel, individually. What is unusual is asking for all of them at once, in one place, where the act of making happens.

How other protocols approached adjacent problems

Each of these is a serious design that does what it set out to do. None of them set out to do exactly this.

atproto was built for posting and following at internet scale. Repos sync over HTTP and WebSockets, identity lives in DIDs (PLC, did:web), and indexing and search are delegated to AppViews. That separation makes posting cheap, portable, and operationally simple — the cost of joining the network is the cost of running a PDS, and the cost of building a feed is the cost of running an AppView. Makers ask a different question: who forked first? Without a single ordered history, that question has no canonical answer. atproto is a great answer to “how do I post anywhere?” — it is a different question from “how does my project’s lineage stay intact across forks I will never see?”

The Farcaster deltagraph was built for social actions delivered through CRDT gossip. The Snapchain whitepaper describes the trade-off candidly: “a node could only detect gossip failures by syncing manually with every other node and comparing all transactions.” Gossip is a sensible choice when you are optimizing for delivery, offline tolerance, and the kind of social action where exact ordering does not matter much — a like is a like whether it landed at 12:00:01 or 12:00:02. It is a different choice from “everyone agrees on the order of every action that touches a project.”

Snapchain is the chain Farcaster built once gossip became the bottleneck. Tendermint-style consensus, ~1s blocks, 9000+ TPS. The whitepaper explicitly scopes the chain: “Snapchain is different from most blockchains because its transactions are not turing complete, are account independent and pruned often… This is important for scaling since it prevents the network from being used for non-social purposes.” That scoping is the right call for Farcaster — narrowing the problem space is exactly what lets Snapchain hit its throughput numbers. Code collaboration sits outside that scope by design, which is a focused choice and a clean one.

Ethereum L1 + L2 was built for finance and settlement, scaled via rollups. Vitalik’s January 2025 piece on the future of L1 and L2 lays out the modularity correctly: the base layer should be boring, L2s should experiment, and modularity lives at the rollup boundary. That model is exceptional for finance, where the cost of a transaction is dwarfed by the value moved. Pushing a commit is a different economic shape — frequent, small-value, latency-sensitive — and the L1+L2 cost curve is not optimized for it. Querying historical state means standing up a third-party indexer, which puts us back in the two-system problem from Provable but Unqueryable.

Each of these protocols answers the question it was built around. A protocol built for making things has to start from the maker’s question.

The map

Across the maker’s axes, the existing landscape looks like this:

System	Built for	Provenance	Permissionless	Finality	Lineage on fork	Portable identity
atproto	Posting	DID-signed	Yes	None (federated)	Not native	Yes (DID)
Farcaster deltagraph	Social via gossip	Signed	Yes	None (CRDT)	Not native	Custody-based
Snapchain	Ordered social	Signed	Open within scope	~1s	Not in scope	Custody-based
Ethereum L1+L2	Finance	Signed	Yes (cost-gated)	L1 ~12s / L2 preconf	Not native	EOA / smart account
Makechain	Making things	Ed25519 + EIP-712 + WebAuthn	Yes	~200ms	Native (`FORK` message)	`owner_address`

And the boundary each system draws is in a different place:

graph TB
    AT["atproto\nPDS — Relay — AppView\nfederation, no global order"]
    ETH["Ethereum L1 + L2\nL1: ordering and DA\nL2: execution\nIndexer: bring your own"]
    MC["Makechain\nSimplex BFT — QMDB\nhandlers today\nIndexer + event-processor in tree"]
    style AT fill:#E84855,color:#fff
    style ETH fill:#3BB273,color:#fff
    style MC fill:#2A40FF,color:#fff

Where Makechain lands

The maker’s rules turn into concrete protocol artifacts. Each rule below maps to a real piece of the chain — not a roadmap item, not a flag in a config file, but something a node enforces today.

Provenance. Every operation on the network is a Message envelope: the operation payload, a BLAKE3 hash of the canonical encoding, an Ed25519 signature over that hash, and the signer’s public key. Verification is local — anyone with the bytes can check the signature, no host required. Project identity is content-addressed: project_id = BLAKE3(PROJECT_CREATE message). The project’s address is a fact you can derive, not a row you depend on.

Permissionlessness. Anyone can publish. There is no registry, no allowlist, no per-account approval. The only economic gate is STORAGE_CLAIM, which buys storage units against settlement on Tempo. That gate is an open market — not a platform decision. The protocol does not know, and does not need to know, who you are.

Finality you can feel. Simplex BFT consensus produces ~200ms blocks with single-round finality. You submit a message, it reaches a validator, a leader proposes a block, two-thirds of validators notarize it, and the block is final. Your client sees the new state through a SubscribeMessages stream over gRPC almost as fast as the local network round trip. The push, the order, and the read happen inside one second.

Lineage that survives a fork. FORK is a first-class message type. The forked project’s project_id is BLAKE3(FORK message) — the lineage is in the address itself, not in a side-channel pointer that a future host could omit. Whoever forked, whoever they forked from, and when, is a permanent fact about the project’s identity.

Portable identity. Under V2AddressNative, owner_address is the canonical 20-byte identifier. SIGNER_ADD and SIGNER_REMOVE bypass the normal delegated-key check and are authorized by EIP-712 custody signatures from the owner — secp256k1, P256, and WebAuthn passkeys all baked into the same signing domain. Move hosts, your address travels. Lose a key, your custody signer rotates it. The address is not an account on a server; it is a public key on the chain.

No tenancy. Storage units come from STORAGE_CLAIM against settlement, not from a hosting plan. Your slot is yours. If a particular host you publish through goes away, your storage and your projects do not.

That bundle is what batteries included means. The phrase comes from Python: the standard library is rich enough that you do not have to assemble a working environment from third-party packages before you can be productive. Makechain wants the same property for makers. Consensus, identity, storage, and queries are all in the box. You do not assemble a chain, an identity provider, an indexer, and a settlement layer to start making — you publish a PROJECT_CREATE and you are in.

How the bundle was built

The bundle did not require us to invent the primitives. It required us to compose them.

Simplex BFT comes from commonware-consensus. QMDB is the merkleized state store, the subject of an earlier post. Authenticated p2p is commonware-p2p. The crypto — Ed25519, BLAKE3, EIP-712 — is commonware-cryptography plus the EIP-712 custody and WebAuthn handling we built on top. The indexer and event-processor are first-class workspace binaries, not third-party services bolted on after the fact. They consume finalized blocks over gRPC, write into Postgres, and publish events to Redis streams. Closing the gap Provable but Unqueryable named was a design goal, not a deferred problem.

The Commonware homepage frames their philosophy this way: “Today’s blockchain stack is designed to be a jack of all trades, but master of none. Modeled after virtual machines and kernels, it exposes a balanced interface through a one-size-fits-all framework instead of molding to the needs of any specific application.” That posture is what let us shape the chain to the maker’s question rather than inheriting someone else’s answers. We are not a fork of an existing L1 with our application bolted on; we are a small set of well-designed primitives composed for one job.

Today, execution is bespoke handlers — PROJECT_CREATE, COMMIT_BUNDLE, REF_UPDATE, FORK, the link and reaction sets. Each is a function over a BatchStore. They are deliberately narrow because the protocol is about making things, not arbitrary computation. The substrate underneath them is execution-agnostic, which means an EVM execution environment for code-adjacent smart contracts, or a RISC-V environment for prover-friendly arbitrary computation in the spirit of Vitalik’s 2025 RISC-V proposal, could be added later as parallel execution paths over the same Simplex consensus and QMDB storage. That is not the pitch. The pitch is the bundle that ships today. The optionality is just the substrate not closing the door.

The hard parts

The choice has costs.

Tracking Commonware versions is one of them. When the underlying primitives advance, Makechain has to follow. That is the tax of composing at the primitive layer rather than inheriting a framework — you do not get to ignore the layer below.

The maker market is also not a category that fits in a one-line pitch. L2 rollup for X is a recognizable shape investors and users can map onto a thesis. A chain built for making things is not. The value is real; the shorthand is not, and explaining the bundle takes more than a tweet.

Identity choices are sticky. Adding any future execution environment, EVM or RISC-V, will require deciding whether new addresses share the V2 namespace or run alongside it. Pick wrong and there is migration work later.

And STORAGE_CLAIM is an unfamiliar mental model. Pricing storage as a yearly claim against Tempo settlement, rather than as gas on every read, takes explaining to anyone arriving from a chain where state lives or dies by the gas market.

Closing

The series so far has worked from the bottom up.

QMDB gave us a storage primitive that does not force a choice between proofs and throughput. Provable but Unqueryable named the gap between consensus-fresh state and rich queries, and pointed at the substrate that closes it.

Batteries Included is the answer to so why a chain? The chain is what fits underneath the maker’s rules. It is not the point. Making things in public, with cryptographic provenance, permissionless publishing, finality you can feel, and lineage that survives a fork — that is the point. We shipped the bundle that delivers it. Everything else is downstream.

The next post is about what the bundle unlocks for the people actually making things on it — building a project, forking it, and watching the lineage hold.