Ethereum launch

From idea to Frontier

A new pitch: world computer

Vitalik Buterin’s 2013 whitepaper proposed a general-purpose chain with a Turing-complete scripting language. Instead of Bitcoin’s narrow opcodes, Ethereum promised programmable state. The pre-sale in 2014 raised ~31k BTC, funding development of clients in Go (Geth), C++ (cpp-ethereum), and later Rust (Parity). The original paper is still on ethereum.org ↗.

By July 2015, Frontier launched—bare-bones, command-line only, with warnings that it was for developers. Gas was the key innovation: every opcode had a cost, preventing infinite loops and pricing computation directly. The launch post ↗ reads like a caveat emptor for early builders.

Frontier to Homestead

Frontier shipped with low defaults and a 5,000,000 gas block target. Developers learned by breaking things: contracts ran out of gas, storage refunds were misunderstood, and clients disagreed on edge cases. Homestead (March 2016) stabilized the protocol, improved networking, and lowered the “this might break” warning level (release notes ↗).

Why gas mattered

Gas turned computation into an economic meter. Deploying a contract burned ETH; so did every storage write. Users set gas price; miners chose transactions. This market mechanism foreshadowed today’s priority fees and MEV concerns. It also forced developers to think about efficiency and denial-of-service vectors.

Gas, the EVM, and clients

Multi-client from day one

Unlike Bitcoin’s de facto single reference client, Ethereum encouraged multiple implementations. Geth became dominant; Parity (2015) chased performance in Rust. Client diversity reduced single-codebase risk but introduced consensus headaches when implementations disagreed on corner cases.

Solidity, Serpent, and Vyper’s proto-days

Solidity emerged as the primary language, inspired by JavaScript syntax. Serpent (a Pythonic variant) and LLL existed but faded. Early Solidity lacked modern safety features: no overflow checks, footguns around default visibility, and no standardized patterns. Audits were rare; mainnet was the playground.

Testnets and tooling

Olympic (pre-launch) rewarded bug finding; Morden (early testnet) often broke; Ropsten replaced it. Truffle and Embark appeared, giving developers migrations and testing harnesses. Mist, the original Ethereum wallet/browser, bundled a light client but was resource-heavy. The tooling gap was obvious: you needed scripts and bravery to ship. The Olympic press release ↗ shows how early incentives were framed.

Community, bugs, and early culture

Mainnet YOLOs

Without robust staging, many teams deployed directly to mainnet. Simple mistakes—like forgetting a payable fallback or mispricing gas—burned funds. These scars seeded patterns like checks-effects-interactions and pull over push payments.

Reentrancy foreshocks

Before The DAO exploit, smaller bugs hinted at reentrancy dangers. Developers discovered that external calls could invoke contracts before state updates. Patterns to guard against this (mutexes, reentrancy locks) were not yet standard. The community was learning in public.

Eth culture takes shape

Meetups and Devcon gatherings framed Ethereum as a builder playground. “World computer” rhetoric met reality: nodes struggled under load, but the idea of composable contracts stuck. Ideals of openness and neutrality clashed with the pragmatism of raising funds and shipping tokens—a tension that would explode in the ICO era. Devcon1 videos (playlist ↗) capture the optimism and rough edges.

Monetary policy debates

Ether’s issuance (5 ETH per block then) and uncle rewards were tweaked to encourage chain health. Critics asked: what anchors ETH’s value? Supporters argued utility (gas) would be its gravity. This question foreshadowed later fee-burn (EIP-1559) and staking debates.

Why this launch mattered

Frontier proved a stateful, programmable chain could run in the wild. It birthed the ERC-20 standard, ICO boom, DeFi, and NFT eras down the line. The rough edges taught the community that programmability multiplies both creativity and attack surface.