From a cypherpunk email to an indestructible protocol — a complete technical and historical guide
Satoshi Nakamoto introduced Bitcoin on the metzdowd.com mailing list — the legendary cryptography list where the sharpest minds of the Cypherpunk movement gathered. The announcement was initially met with skepticism by veterans who had watched dozens of previous digital-cash attempts fail.
"I've been working on a new electronic cash system that's fully peer-to-peer, with no trusted third party."
— Satoshi Nakamoto, November 1, 2008
Prominent figures such as Adam Back (Hashcash), Hal Finney (RPOW) and Wei Dai (b-money) were contacted directly to refine the conceptual foundations. It was not a shout into the void — it was a deliberate act of technical validation.
Bitcoin was not a solitary Big Bang. There were real humans who validated, debugged and sustained the project in its most fragile days.
v0.1.0 version.Satoshi wrote the initial 31,000 lines of code in C++ for its extreme predictability in memory usage, direct low-level socket control and native speed across heterogeneous operating systems.
In a global monetary network, the overhead of a garbage collector (as in Java) or the slowness of interpreted languages could cause fatal desynchronization of data blocks. C++ compiles to machine code with no intermediate layers.
Transaction validation must produce exactly the same result on any hardware on the planet. With C++, Satoshi controlled data types down to the bit — especially critical for satoshi arithmetic with int64_t.
The first client ran simultaneously on Windows XP, Ubuntu 8.04 and macOS. In 2009, with no Docker or containers, C++ was the only viable option for universal distribution.
// Real fragment of Satoshi's original v0.1.0 code (2009)
// Monetary arithmetic uses int64 to avoid floating-point overflow
typedef long long CAmount;
static const CAmount COIN = 100000000; // 1 BTC = 10^8 satoshis
static const CAmount MAX_MONEY = 21000000 * COIN;
inline bool MoneyRange(const CAmount& nValue) {
return (nValue >= 0 && nValue <= MAX_MONEY);
}Satoshi designed a network that survives attacks, outages and malicious actors through three fundamental architectural properties that reinforce one another.
Transactions and new blocks propagate redundantly from node to node. If 90% of the nodes go down, the remaining 10% retains the complete, synchronized copy. There is no single point of failure.
Instead of basing identity on IP addresses (easily forged), Satoshi tied the ability to add blocks to real computational power (Proof of Work), elegantly neutralizing massive Sybil attacks.
By unifying Proof of Work with a cryptographic timestamp linked in a chained manner, he eliminated at the root the need for a centralized timekeeping entity for validation.
Bitcoin's controlled issuance is governed by the block subsidy reward, which is halved every 210,000 blocks. This immutable rule is encoded in the consensus core:
| Event | Block | Year | Reward | BTC issued (cumul.) |
|---|---|---|---|---|
| Genesis | 0 | 2009 | 50 BTC | 0 → 10.5M |
| 1st Halving | 210,000 | 2012 | 25 BTC | 10.5M → 15.75M |
| 2nd Halving | 420,000 | 2016 | 12.5 BTC | 15.75M → 18.375M |
| 3rd Halving | 630,000 | 2020 | 6.25 BTC | 18.375M → 19.687M |
| 4th Halving ✦ | 840,000 | 2024 | 3.125 BTC | 19.687M → ~20.3M |
| 5th Halving | 1,050,000 | ~2028 | 1.5625 BTC | ~20.3M → ~20.65M |
| Final supply | ~6,929,999 | ~2140 | 0 BTC | 21,000,000 BTC |
Miners package transactions into a block and compete to solve a one-way hash puzzle. This requires performing trillions of operations per second to guess the random value (nonce) that meets the network's current difficulty.
Find a nonce N such that SHA256(SHA256(block_header + N)) begins with enough zeros. The difficulty determines how many zeros are required. There is no mathematical shortcut — only brute force.
Every 2,016 blocks (~2 weeks), the difficulty is dynamically recalculated to ensure that the average time to produce a block is always 10 minutes, regardless of total hashrate.
// Simplified pseudocode of the mining process
while (true) {
nonce++;
hash = SHA256(SHA256(block_header + nonce));
if (hash < target_difficulty) {
broadcast_block(block); // BLOCK FOUND!
collect_reward(3.125_BTC + fees);
break;
}
// Otherwise: try the next nonce (or change the extra-nonce)
}A common misconception: miners do not control Bitcoin. Full nodes are the sovereign guardians of the rules. This distinction is the most important political key of the protocol.
| Feature | 🖥️ Full Nodes (Verifiers) | ⛏️ Miners (Block Builders) |
|---|---|---|
| Primary Function | Independently validate transactions and blocks against the consensus rules. | Group transactions and spend electrical energy to propose new valid blocks. |
| Reward | None directly. Their reward is sovereignty and the certainty of validating their own rules. | They earn the block subsidy (newly created satoshis) and network fees. |
| Political Power | Absolute. If miners propose an invalid block, the nodes simply ignore it. | Limited. They cannot force consensus rule changes that the nodes reject. |
| Historical example | In the block size war (2017), the nodes rejected SegWit2x despite the support of 90% of the hashrate. | The hashrate followed the economic nodes, not the other way around. The miners backed down. |
I've moved on to other things. The project is in good hands with Gavin and the rest of the developers.
His voluntary disappearance transformed software created by one person into a truly decentralized and indestructible protocol, with no single political points of failure. Had Satoshi continued, Bitcoin would be a project led by one person — vulnerable to legal pressure, coercion and points of failure. By disappearing, he created a headless system that cannot be decapitated.
Published on October 31, 2008 by the pseudonym Satoshi Nakamoto, the White Paper titled "Bitcoin: A Peer-to-Peer Electronic Cash System" solved a problem that frustrated cryptographers for decades: double-spending without the need for a trusted third party.
"A purely peer-to-peer version of electronic cash would allow online payments to be sent directly from one party to another without going through a financial institution." — Satoshi Nakamoto.
The White Paper is just 9 pages and 12 sections long. In that space, Satoshi defined the double-spending problem, the solution via a P2P timestamp, Proof of Work, the longest chain and the privacy analysis.
Published 44 days after the collapse of Lehman Brothers (Sep 15, 2008). The global banking system was in free fall. Satoshi proposed a mathematically verifiable alternative at the very moment of greatest institutional distrust.
Bitcoin does not use cryptography to "hide" data (everything is public), but to guarantee ownership and the integrity of the system. It is cryptography as a mathematical substitute for trust.
Bitcoin uses SHA-256 to link blocks and in Proof of Work. It converts any input into a unique 256-bit string (64 hex). It is deterministic, one-way and exhibits the avalanche effect: a 1-bit change produces a completely different hash.
It uses the secp256k1 elliptic curve. Your private key (256 bits, ~77 digits) generates a public key, which in turn generates your Bitcoin address via SHA256+RIPEMD160 hashing.
⚠️ The process is one-way: from the address it is impossible to derive the public key, and from the public key it is impossible to derive the private key.
In Bitcoin there are no "balances" like in a bank account. There are UTXOs (Unspent Transaction Outputs). Your real balance is the sum of the "digital bills" (UTXOs) that you hold under the control of your private key.
You have 3 UTXOs: 0.5 BTC, 0.3 BTC, 0.2 BTC. They are your "bills". You cannot split a UTXO: you must spend it whole.
To pay 0.4 BTC, you select the 0.5 BTC UTXO. You sign with your private key to prove ownership.
Two outputs are created: 0.4 BTC → recipient, and 0.09 BTC → yourself (change). The remainder (0.01 BTC) = fee for the miner.
The miner includes the TX in a block. Your 0.5 UTXO is destroyed. Two new UTXOs are born: 0.4 and 0.09 BTC.
The UTXO is Bitcoin's "bill". It is not split or fractioned during spending — it is spent whole and produces change, exactly like a physical bill in a store.
The original software was written in C++ by Satoshi Nakamoto. Today, hundreds of developers maintain it under the name Bitcoin Core. It is one of the most audited and reviewed software projects in history.
// Validation pseudocode in Bitcoin Core
bool CheckTransaction(const CTransaction& tx) {
// 1. Verify that the inputs are not empty
if (tx.vin.empty()) return false;
// 2. Verify the range of values
for (const auto& txout : tx.vout) {
if (!MoneyRange(txout.nValue)) return false;
}
// 3. Verify that the output value does not exceed the input value
CAmount totalInput = GetValueIn(tx);
CAmount totalOutput = tx.GetValueOut();
if (totalOutput > totalInput) {
return false; // You cannot create money out of nothing
}
// 4. The difference is the fee for the miner
CAmount fee = totalInput - totalOutput; // ≥ 0
// 5. Verify the cryptographic signature (ECDSA / Schnorr)
if (!VerifySignatures(tx)) return false;
return true;
}Bitcoin Core is developed on GitHub with public code review. Any consensus change requires exhaustive review, discussion on mailing lists and voluntary adoption by the nodes. There is no CTO or CEO.
The rules are Bitcoin's legal system: the 21M limit, the halving reward, the maximum block size, signature validity. They are enforced by each node independently. They cannot be changed without massive consensus.
Bitcoin's transparency lies in the fact that anyone in the world can run a node in their own home with basic hardware (~500 GB of storage, ~4 GB of RAM). In doing so, you download an exact copy of the entire financial history since the genesis block (January 2009).
Once a block enters the blockchain with enough Proof of Work, modifying it would require redoing that block and all subsequent ones with more hashrate than 51% of the global network. Currently, that is equivalent to more energy than many countries.
It is written in stone: only 21 million Bitcoins will ever exist. Every 210,000 blocks (~4 years) the Halving occurs, cutting issuance in half. It is the only currency in the world with a mathematically verifiable supply.
You do not need to trust any bank, government or company. The rules are open source, run on tens of thousands of independent nodes in more than 100 countries. Trust is mathematical, not institutional.
Bitcoin's robustness lies in its mathematical verification. Don't trust, always verify.