Two Heights, Three Weeks Apart
Block 481,824, mined 24 August 2017. Block 478,559, mined 1 August 2017.
Twenty-three days apart. Same chain, same hash function, same ten-minute heartbeat.
One of them is a line in an upgrade log. The other created a new coin: new codebase, new wallets, new block explorer, and a grievance archive that people are still adding to.
The gap between them isn’t “one changed more code”. Not charisma, not hashrate, not who had the better conference. It’s something more boring, which is why I want to take this machine apart: the consensus rules, who validates them, the block itself, and the switch that turns a change on. Pull each part out, see how it moves under a soft fork versus a hard fork, bolt it back together.
THE ONLY TEST THAT DECIDES WHICH ONE YOU ARE IN
- old node accepts the new blockSOFT FORK
- old node rejects the new blockHARD FORK
- activated 24 Aug 2017 · block 481,824SEGWIT
- first block of its own 1 Aug 2017 · 478,559BITCOIN CASH
Everything about forks — whether you wake up owning one coin or two, whether your wallet still works on Monday — falls out of a single evaluation done by the most neglected node on the network. Bolt-by-bolt below.
The Only Question That Matters
Most fork explainers start at the outcome and work backwards: soft fork means no split, hard fork means split. True, and useless — by the time you can observe the outcome, the decision that produced it was made months earlier, in a thread almost nobody read.
The dividing line is not how much code changed. A soft fork can rewrite transaction serialization top to bottom. A hard fork can be one constant: MAX_BLOCK_SIZE = 8000000. Diff size tells you nothing.
One question does:
old_node.is_valid(new_block) == TRUE → SOFT FORK | old_node.is_valid(new_block) == FALSE → HARD FORK
An old node — nobody upgraded it, it runs in a spare room on a two-year-old tag — receives a block produced by brand-new software. Yes or no?
- Yes → soft fork. The new rules are a subset of the old ones. The old node can’t see the new features, but it also can’t see anything forbidden. It shrugs and follows along.
- No → hard fork. The new rules relax or add to the old ones. The old node sees a violation of a rule it still enforces, and rejects. Two chains, sharing history up to the split and nothing after it.
Notice the asymmetry, because every practical consequence falls out of it: a soft fork needs the validators to upgrade. A hard fork needs everybody. Not a majority — everybody, including the guy with the spare-room node. If a meaningful minority keeps enforcing the old rules, you get two chains, permanently.
Part 1 — The Rule Set: What Counts as Legal
People say “the protocol” as if it were a document. It’s an if-statement chain in a specific function, run in the same order on every block, by every node, forever. Proof of work valid? Coinbase within subsidy plus fees? Inputs unspent? Scripts true? If that third question is fuzzy, UTXO vs Account Model is worth ten minutes — the whole fork fight is downstream of it.
The useful framing: the rules form a set, and forks are set operations.
- Soft fork = intersection. Remove blocks from the legal set.
new_legal ⊂ old_legal. - Hard fork = union, or replacement. Admit blocks that weren’t legal before.
new_legal ⊄ old_legal.
Third-grade set theory, and I won’t dress it up. Coordination cost, who must upgrade, whether you wake up owning one asset or two — all of it falls out of that subset relation.
What trips people up: “tightening” and “adding a feature” feel like the same activity from outside. They aren’t. Tightening is subtractive and backward-compatible; adding is additive and backward-incompatible. You can add enormous functionality while remaining strictly subtractive about which blocks are legal — exactly the trick SegWit pulled.
Part 2 — The Validators: Miners Produce, Nodes Judge
Miners do not decide what is valid. Nodes do. Miners decide what to attempt. They burn electricity guessing nonces; when one hits, they broadcast. Then every full node independently re-runs the rule set against that block and either accepts it or discards it. A block no node accepts isn’t a block — it’s a header plus a large power bill. (How Bitcoin Mining Works covers the guessing.)
Three distinct kinds of power here, and conflating them is how the entire 2017 discourse derailed:
- Miners hold proposal power — they choose what goes into the block they try.
- Full nodes hold judgment power — they decide whether that block is legal.
- Exchanges, custodians and processors hold economic power — inherited wholesale from whatever node binary they happen to run.
Now re-read “miners blocked SegWit” in machine terms: miners controlled a few spare bits in the headers they proposed, and one activation mechanism happened to count those bits. That’s a fact about switch design, not about consensus. The bits are a polling mechanism wearing a consensus costume.
Which matters, because if the switch is the only place miners have leverage, then you can build a switch that doesn’t use their bits at all. Someone did.

Part 3 — The Block: How to Make It Bigger Without Making It Bigger
1 MB cap. Everyone agreed it was tight. One camp wanted to raise the number; the other refused, correctly observing that raising it is a hard fork — old node sees a 2 MB block, its rule says 1 MB, reject, two chains.
SegWit (BIP141, proposed by Pieter Wuille in late 2015) declined that fight. Its answer: don’t change the limit, change the unit.
weight = base_bytes × 4 + witness_bytes × 1
The 1 MB ceiling becomes a ceiling of 4,000,000 weight units. Witness data — signatures, the proof that you may spend — counts at one quarter rate; everything else counts full rate. Result: a block carrying roughly 1.7–2 MB of raw bytes that still weighs under 4M.
And here is the part that makes it a soft fork rather than a hard fork: old nodes never see the witness data at all. It’s relocated into a structure the old deserializer skips without parsing. To a pre-SegWit node, a SegWit block is a normal block full of odd-looking anyone-can-spend outputs. Strange. Legal. Under 1 MB, as far as it can tell.
The block got physically bigger while becoming no less legal from the old node’s point of view. Not a bigger box — the same box, with some contents packed in a material the inspector is blind to.
Two side effects, both of which mattered more than the capacity did:
- Malleability got fixed. Signatures moved out of the data that computes the transaction ID, so a third party can no longer mutate a transaction cosmetically and change its hash. That unblocked Lightning — channels reference unconfirmed transactions by ID, and a mutable ID makes that a nightmare.
- Script versioning got introduced. A version byte means future script upgrades can ship as new versions that old nodes treat as “always valid” — as soft forks. Taproot is the direct descendant of this decision.
The underrated lesson: the most valuable thing a soft fork can do is make the next soft fork cheaper. SegWit’s lasting contribution isn’t throughput. It’s recursion.
Part 4 — The Switch: Who Presses It, and When
Here’s what surprises people arriving from normal software: the change can be written, reviewed, merged and shipped, and still not be live. A consensus rule change needs a trigger. Without one you’re requiring every node operator on earth to upgrade on the same Tuesday — a hard fork wearing a soft fork’s hat.
BIP9, the mechanism SegWit shipped with:
- A signaling window opens; miners set a bit to indicate readiness.
- Bits are tallied over one difficulty period — 2,016 blocks.
- At 95%, the change locks in, then activates at a fixed height after a grace period.
- Below threshold by the timeout, the deployment expires dead.
SegWit’s window opened 15 November 2016 with a timeout of 15 November 2017, and stalled: through May–June 2017, roughly 30% of blocks signaled. Not 95%. Not trending there. Stuck, while everyone argued in public.
Then three things happened in order, and the order is the story:
BIP148 (UASF) — published 12 March 2017 by an anonymous developer, flag day 1 August 2017. Nodes running it would reject blocks that didn’t signal SegWit. Look where the leverage sits: it asks miners for nothing. It changes what nodes accept. Miners propose; nodes judge.
BIP91 — a compromise running a separate deployment on bit 4 at 80% over a shorter 336-block window (269 blocks). Locked in 23 July 2017 at block 477,120.
SegWit itself — cleared its own 95% threshold at 2,016 / 2,016. Locked in 9 August 2017. Activated 24 August 2017 at block 481,824.
2,016 / 2,016 — SegWit cleared its own 95% threshold; locked in 9 August 2017
269 / 336 — BIP91’s 80% threshold on bit 4; effective 23 July 2017 at block 477,120
Read those together: SegWit was never blocked by its own threshold. It was blocked by miner politics. Once refusing to signal became expensive, the technical bar cleared in one difficulty period, unanimously. The 95% was never the wall.
And BIP148? Never used. The flag day passed quietly because BIP91 got there first. But the credible threat is what dragged everyone to the table. UASF’s output wasn’t activation; it was leverage — a different product entirely.
- 15 Nov 2016SegWit’s BIP9 window opens: 95% of a 2,016-block period, timeout 15 Nov 2017
- 12 Mar 2017BIP148 (UASF) published anonymously; flag day set for 1 August
- 23 May 2017New York Agreement: SegWit first, then a 2 MB hard fork within six months
- May–Jun 2017signaling stuck near 30%; the 95% threshold looks unreachable
- 23 Jul 2017BIP91 locks in at block 477,120; all blocks signal SegWit afterward
- 1 Aug 2017BIP148 flag day passes quietly; Bitcoin Cash splits at block 478,559
- 9 Aug 2017SegWit locks in at 2,016 / 2,016
- 24 Aug 2017SegWit activates at block 481,824
- 8 Nov 2017SegWit2x cancelled for lack of consensus
- 14 Nov 2021Taproot activates at block 709,632
Here is the switch component side by side:
| Mechanism | What it counts | Threshold | What happened |
|---|---|---|---|
| BIP9 (SegWit) | Miner bits over a difficulty period, 1-year timeout | 95% of 2,016 blocks | Stalled near 30% for months; cleared 2,016/2,016 after BIP91 |
| BIP91 | Miner bits on bit 4, short window | 80% of 336 blocks (269) | Locked in 23 Jul 2017 at block 477,120; worked as designed |
| BIP148 (UASF) | Node-enforced flag day, no miner input | Calendar date, 1 Aug 2017 | Never triggered; its value was leverage, not activation |
| Speedy Trial (Taproot) | Miner bits on bit 2, short bounded window | 90% of 2,016 blocks (1,815) | Met in the period ending 12 Jun 2021; live at 709,632 on 14 Nov 2021 |
1,815 / 2,016 — Taproot’s Speedy Trial threshold, met in the period ending 12 June 2021
The difference between SegWit’s BIP9 and Taproot’s Speedy Trial isn’t the threshold. It’s the timeout. A year-long window is a year of positioning and press releases. Speedy Trial ran 24 April 2021 to 11 August 2021, and failure was cheap because you find out fast.
A short window converts “we might win eventually” into “we win now, or we go build something else.” Same lesson as short release cycles versus a two-year waterfall plan: long feedback loops don’t make hard problems tractable, they make them political.
Honest caveat: Taproot was far less contested than SegWit, which is exactly why a short window was easy to agree to. Mechanism design and political context are tangled here; I can’t cleanly separate them, and anyone who claims otherwise is selling something.

When the Answer Is No: 478,558 and 478,559
478,558 was the last block both chains agreed on. From 478,559 onward each chain produced its own block with that number, and those two blocks are not the same block and never will be.
The rule change was an 8 MB limit. Run it through the model: old node, 1 MB in its code, receives an 8 MB block. Reject. Definitively a hard fork, and because a large minority never upgraded, definitively two chains.
What’s worth internalizing has nothing to do with who was right: Bitcoin Cash didn’t fork off because it lost an argument. It forked off because its rule change was a superset, and supersets require unanimity. Mechanics, not politics. Any superset change, by anyone, with any industry backing, produces the same structure if adoption isn’t complete.
Which is what killed SegWit2x. The New York Agreement of 23 May 2017 had a room full of companies committing to SegWit first and a 2 MB hard fork within six months. The 2x half was scheduled for November 2017, around block 494,784. Cancelled 8 November 2017 for lack of consensus — because a signature is not the same object as every operator upgrading their binary.
Put that next to SegWit: SegWit shipped. Not because the room agreed, but because the change was a subset, so the people who disagreed validated it anyway. A soft fork doesn’t need consensus. It needs the absence of a veto — and an old node has no veto over a rule that merely forbids more than it used to.
One cross-chain note, because people reach for it as the canonical example and then generalize it wrong. Ethereum’s DAO hard fork happened in July 2016 at block 1,920,000. Same category of event, different resolution: it settled as a community choice about which chain to follow, not as a question of whether old clients accept new blocks. Ethereum meters block space differently too — via gas, not a byte cap (What Is Gas on Ethereum). “The community picked a chain” and “old clients reject new blocks” are different failure surfaces.
What This Means If You Just Hold the Thing
You don’t need to run a node, but you do need to know which parts of this machine touch you:
- Before a fork, find out which side your custodian is on. Your coins live where your keys live; if your keys live with someone else, their node binary is your consensus rule set.
- In a non-technical hard fork your balance exists on both chains — but “you have coins” is not “you can move coins.” Keys, custodian support and replay protection each decide whether that second balance is spendable or ornamental.
- Watch the activation mechanism, not the manifesto. A roadmap costs nothing to publish. Who presses the switch, at what threshold, with what timeout, and what happens on failure — that’s the real spec, buried in a BIP nobody reads.
- Grudge narratives are entertainment, not a technical basis. Especially on low-stakes chains, where the drama-to-engineering ratio is inverted.
The Boolean Under Everything
Strip away the personalities and the flame wars, and every upgrade here reduces to one evaluation — performed by the most neglected computer on the network, unpatched, running stale code, dutifully checking blocks it will never fully understand.
subset(new_rules, old_rules) == TRUE → one chain | subset(new_rules, old_rules) == FALSE → two chains
SegWit’s authors understood this, which is why they spent their effort not on winning the argument but on making their change invisible to the machines that disagreed with it. The authors of the 8 MB change understood it too, and accepted the split as the price of the rule they wanted.
So the next time someone tells you a fork is “just a software update”, ask the only question that pays: when the oldest, stubbornest, least-maintained node on the network receives the first new block — does it say yes? Whether you wake up with one asset or two, whether your wallet still works on Monday, whether the thing you own is still the thing you thought you owned — all of it sits downstream of that one boolean, decided months earlier by people arguing about a bit in a header.
(The End)


