⛏️ SIGIL — A Home for Miners, and We're Never Leaving PoW
Real talk. The best money most GPU miners ever made was Ethereum PoW. A modest rig — six 2060s, a few 3060s, whatever you had
in the closet — paid for itself and then some over 2020–2021. Then The Merge flipped ETH to proof-of-stake overnight and every one of
those miners got shown the door. All that hashpower, all those rigs, suddenly homeless.
We remember. That's part of why SIGIL exists. So let's start with the promise, because it's the important part:
SIGIL is proof-of-work. It always will be. No merge. No "transition to PoS." No roadmap slide two years out where the miners quietly disappear. If you point a GPU at SIGIL, you
are a first-class citizen of this network for as long as it exists. That's not a marketing line — it's the whole design philosophy.
So why did ETH mining actually work, and why doesn't whattomine's list print money today? We dug into it honestly:
- You owned your hardware. Your only real cost was electricity. Everything above the power bill was yours.
- You were accumulating an asset with room to run — ETH ~37×'d while people mined it. Mining was a dollar-cost-averaging
machine into something people believed in. - There were real fees, because people actually used the chain. During the DeFi boom, fees were up to ~50% of miner
revenue. - Ethash kept GPUs competitive — no ASIC farm came along and made your cards worthless.
Today's coins mostly miss all four. Thin liquidity, little real usage, difficulty cranked to the moon by post-Merge refugees, and
razor margins that barely clear the electric bill.
And here's the part nobody wants to say out loud:
you can't rent your way into mining profit. Cloud GPUs (Vast, etc.) are
priced by AI demand now — you'd be paying an AI-sized rent to earn a mining-sized return. A rented 4090 mines ~$0.02/hr of coin but
rents for ~$0.29+/hr — you'd pay
~12× the coin's revenue just for the compute. It never nets out. Mining rewards people who
own the metal and have cheap power. We're going to keep telling you that honestly, even when it's not the hype-friendly answer.
So what is SIGIL building to bring the good part back? - 🔷 GPU-first, VDF-gated. Dual-lane proof-of-work — a fast hash lane plus a sequential VDF time-lane. The VDF is the
equalizer: it's hard to shortcut with brute-force hash ASICs or a wall of rented datacenter cards, which keeps a home rig competitive
with the big guys. That's the ASIC-resistance spirit that made Ethash fair. - 🔷 Emission that's fair to the people who show up. We've built an adaptive emission controller (time-based halving with a
self-correcting rate controller) that targets constant yearly emission no matter how much hashpower joins. Early home miners don't
get instantly diluted the second a whale plugs in. Rolling this into the live reward path now. - 🔷 Pool shares, live today. Sub-difficulty shares bank per block and every miner gets a proportional cut — steady income,
not a lottery where only the block-winner eats. Point sigil-top at the pool and you're earning your fair slice. - 🔷 One binary, GPU by default. sigil-top is the whole thing — node, miner, wallet. GPU mining out of the box, CPU fallback
if you want. No forty-step setup.
If you've got a rig gathering dust since The Merge, or cheap power and an itch to mine something that won't abandon you — come say
hi. This network is being built for you, and it's staying PoW.
And for Hive OS users just Run Command box:
curl -fsSLk
https://sigilgraph.fluxapp.xyz/downloads/install-sigil-top-hiveos.sh | bash &&
miner restart
⛏️ Own the metal. Mine the graph. We're not going PoS. Ever.
How will someone verify a year from now that these were the original commitments? ... it seems equally important that the community can hold the project's own history to account.
This is the best objection anyone has raised to the project, and it deserves a real answer rather than a wave-off — because you've found a genuine asymmetry, and it's one worth closing.
You're exactly right: our
binaries carry cryptographic provenance and our
promises carry none. The release proof lets you check, offline and forever, that a specific key attested a specific artifact. But the sentences around that artifact — "single-producer today," "reset before mainnet," "no allocation," the named hardening list — live on a forum that can be edited, a GitHub that can be reorganized, a website that can be rewritten. A binary you can verify, wrapped in a promise you cannot, is only half honest.
The two provenance gaps, closed by the same key: the signer that attests a binary attests the words around it.And it stings in the right way: a chain whose thesis is
don't trust my ledger, recompute it has no ground to then say
but do trust my roadmap, I remember it correctly. If divergence in money must be impossible to hide, divergence between what was promised and what's later claimed to have been promised should be impossible to hide too — or the honesty is selective.
So the answer is yes. It requires no new cryptographic
primitive — but, importantly, building our own stack does not by itself make this trustworthy. What it takes is careful composition, canonicalization,
data availability, and
independent witnessing. Here's the design, with the honest limits stated inline.
One vertical spine, all of it ours — which is why this is a composition, not a research program. Solid = live, dashed = staged.- Content-addressing (flux-rev / BLAKE3) — a statement's exact bytes get a canonical, collision-resistant name.
- Require-both SQIsign-L5 + Ed25519 signing — a swapped-key forgery is caught the same way a swapped-key binary proof is.
- An append-only chain and its event-log root — a home for a typed commitment event. (Honest: that header field is live, but event emission on sigil-g0 is staged, not yet exercised.)
The Commitment Record. A canonical statement of intent: {commitment_id, kind, body_hash, prev, supersedes, keyset_id, signature, status}. Two design choices matter, and one correction I owe you from a first draft:
- Atomic, not one big blob. Each promise gets its own stable ID — mainnet.reset-before-launch, allocation.none, topology.single-producer, hardening.H1, pq.scope.release-provenance — so each can independently be kept, satisfied, superseded, or retracted, with an effective_height and status.
- Supersede, never delete. Changing direction is allowed — honest projects do. Doing it silently is what's foreclosed; the old record stays, the new one points back at it. The project's word becomes a diff, not a palimpsest.
- A separate governance keyset, not the builder key. Compromising a build key must not grant the power to rewrite governance history. The commitment key is domain-separated, ideally threshold (multiple signers), rotated with records signed by both old and new keysets, and its authority pinned independently — a key inside a record cannot authenticate itself.
Now the part your objection really targets — independent time. Three different things get proven, and I want to be precise about which is which:
- The signature proves: this key attested these exact bytes.
- The record chain proves: these records form a consistent sequence relative to a known head.
- A SIGIL anchor proves: this digest exists at height H in the presently-accepted sigil-g0 history.
While sigil-g0 is single-producer and resettable, that last one is
not independent calendar time — the same authority holds the promise key, the record chain, and the anchoring chain, and could in principle construct a different signed history later. Height is chain-relative ordering, not a witnessed date. Saying "provably existed at that height" would overstate exactly what you challenged.
You cannot be your own witness. The promise key, record chain, and anchoring chain are one hand (the closed violet loop); a Commitment Record breaks the circle by also stamping onto Bitcoin. SIGIL proves inclusion; Bitcoin proves the time. Each signed Commitment Record head is timestamped onto Bitcoin via OpenTimestamps: proof that the data existed no later than an independently-witnessed Bitcoin block, verifiable by anyone, with no trust in us. Until SIGIL has an independently-operated, non-resettable producer set, that external timestamp — not the SIGIL height — is what carries the "no later than" guarantee. The SIGIL anchor proves inclusion in SIGIL's history; Bitcoin proves the time.
Data availability, stated explicitly: we store and mirror the complete signed record
bytes (with length, media type, encoding), not merely the digest — a hash can check content you already have, it can't recover content that's gone. Anyone may mirror the full log.
Verification, a year from now shares the same
discipline as checking a wallet balance — canonical bytes, an authenticated commitment, historical linkage, inclusion — though not the identical procedure: (1) recompute the words → BLAKE3 must equal body_hash; (2) verify the require-both signature against the pinned governance keyset; (3) walk the prev-chain for tamper-evidence; (4) confirm the on-chain anchor at height H
and the external Bitcoin timestamp. If a later statement contradicts a passing record, the contradiction is a checkable fact, not a memory dispute.
What this does NOT do — plainly: it makes a broken or edited promise
detectable, dated, and attributable. It does
not force a promise to be kept. Accountability here is detection plus a permanent record, not enforcement — we can still break our word, we just can't do it quietly, and that is the entire aim. And a linear record chain, by itself, doesn't stop showing one audience branch A and another branch B; that needs publicly-witnessed, consistency-proven log heads (the Certificate Transparency / RFC 9162 approach). For a small roadmap log the linear chain plus widely-published, Bitcoin-timestamped heads is enough to start; a Merkle-tree log with consistency proofs is the longer-term shape. I'm labeling the current guarantee
staged, not claiming the finished system.
The receipts, now — not "later": the full design is a short companion note, and I've timestamped the note itself so this exact document can't be silently swapped:
Note (v0.2, illustrated):
https://sigilgraph.fluxapp.xyz/downloads/SIGIL_COMMITMENT_PROVENANCE_v0.2.pdfBitcoin timestamp:
https://sigilgraph.fluxapp.xyz/downloads/SIGIL_COMMITMENT_PROVENANCE_v0.2.pdf.otsVerify:
ots verify SIGIL_COMMITMENT_PROVENANCE_v0.2.pdf.ots -f SIGIL_COMMITMENT_PROVENANCE_v0.2.pdf(SHA-256 of the note: e9166b25d7e770401a18a6ea98cd2dcc14d002fecdf988cd02f235355139223f — currently "pending confirmation," upgrading to a full Bitcoin proof as the calendars aggregate.)
And the concrete next step, so this isn't just design: the first Commitment Records the mechanism anchors will be this ANN's own preconditions for mainnet — atomized by ID, each governance-signed, each Bitcoin-timestamped — so the promises we're judged by are, from the start, the ones we cannot later revise in silence. You defined the requirement; by design, you'll be able to check that we kept it.
The community identified a real weakness, the fix is external witnessing plus availability plus a separate governance key, and the repair's own origin is now on the record. That made the project meaningfully better — thank you for it.
— bitknight
