The story of Ethereum is not one of sudden revelation, but of evolution — a journey shaped by vision, collaboration, and technical refinement. This article traces the formative development of the Ethereum protocol from its earliest conceptual stages through to the launch of the mainnet in 2015. While much has been written about Ethereum’s ecosystem and applications, this narrative focuses on the foundational protocol design: how ideas emerged, clashed, and converged into what would become one of the most influential blockchain platforms in history.
The Genesis: A Scripting Language for Smart Contracts
It all began in late 2013, during a trip to Israel where Vitalik Buterin spent time with the Mastercoin team. Inspired by their work on financial contracts built atop Bitcoin, Buterin drafted a proposal to expand their scripting capabilities into a more generalized framework. His vision was simple yet profound: create a platform where decentralized applications could be built without bloating the protocol with complex, case-specific features.
👉 Discover how blockchain innovation began with simple ideas that changed everything.
At that stage, the concept wasn’t even called Ethereum. The initial design focused narrowly on two-party contracts — for example, betting agreements where funds would be released based on external outcomes. The scripting language was not Turing-complete, limiting its scope. But this prototype laid the groundwork.
By December 2013, a second version emerged — now hosted at vitalik.ca/ethereum.html. This marked a pivotal shift: contracts were no longer just transaction rules, but full-fledged accounts capable of holding assets, sending transactions, and maintaining persistent storage (then referred to as “memory”). The virtual machine evolved from stack-based to register-based — though this too would later change.
In this early model, gas (then called “ether”) was consumed directly by the executing contract. If a contract ran out of funds mid-execution, the process halted. A small allowance of 16 free steps let contracts reject unpaid interactions. This mechanism placed financial responsibility on smart contracts themselves — an idea soon to be rethought.
The Arrival of Key Contributors
Until this point, Ethereum was largely a solo project. But collaboration quickly transformed its trajectory.
Gavin Wood reached out via about.me in December 2013 and became instrumental in shaping the protocol. One of his earliest contributions involved the transaction execution model. Buterin originally envisioned asynchronous internal transactions, meaning one contract calling another wouldn’t execute immediately — instead, the call would be queued until the parent transaction completed.
However, when Gavin implemented the specification, he naturally used synchronous execution: when Contract A calls Contract B, B runs immediately, returns control, and A continues. This behavior felt more intuitive and powerful. After discussion, they adopted it as standard.
Another critical shift came during a walk in San Francisco (details lost to time) — the rethinking of transaction fees and gas. The original model charged contracts per computational step. Gavin proposed a new architecture: users pay upfront for a budget of gas, which acts as a computational quota. If execution exceeds gas limit, all state changes revert — eliminating partial execution risks. Unused gas is refunded. This model greatly improved security and predictability.
This change subtly repositioned Ethereum: from a platform for programmable money to a general-purpose decentralized computer.
Architectural Refinements in Early 2014
As development accelerated in early 2014, community input led to further refinements.
- Return to Stack-Based VM: Following suggestions from Andrew Miller and others, Ethereum abandoned the register-based model in favor of a stack-based architecture — simpler to implement and audit.
- Cryptography Upgrade: Charles Hoskinson proposed replacing Bitcoin’s SHA256 with Keccak256 (SHA3) for hashing. After debate, the team agreed, enhancing future-proofing against cryptographic advances.
- Fixed-Size Values: To simplify gas pricing and avoid unpredictable computation costs, values in the EVM were capped at 32 bytes. Unlimited integers were considered but discarded due to challenges in modeling gas costs for operations like multiplication.
The Evolution of Proof-of-Work: From Dagger to Ethash
Mining algorithm design became a central challenge. The goal was clear: resist ASIC dominance while remaining lightweight enough for verification on mobile devices.
Dagger and DAGs
The first serious candidate was Dagger, based on Directed Acyclic Graphs (DAGs). Every N blocks, a new multi-gigabyte dataset was pseudorandomly generated. Mining required fetching random nodes from this set and hashing them — fast if stored in memory (RAM-bound), slow otherwise. This made ASIC optimization difficult due to high memory bandwidth demands.
Light clients could verify slowly using minimal memory — ideal for decentralization.
Adaptive Proof-of-Work (PoW)
An ambitious idea followed: let miners execute randomly selected Ethereum contracts as part of PoW. Since ASICs can't efficiently run arbitrary code, generic hardware (CPUs) would have an advantage. Miners could even deploy contracts specifically designed to foil ASICs.
But this failed due to long-range attacks: attackers could fork from genesis using only simple, ASIC-friendly contracts — easily outpacing the main chain.
Random Circuits & SAT-Based PoW
Vlad Zamfir and Vitalik explored "random circuit" mining — generating circuits on-the-fly to simulate general computation. Meanwhile, Matthew Wampler-Doty proposed SAT-solver-based PoW. Both ideas showed theoretical promise but faced skepticism from hardware experts regarding practical feasibility.
👉 Explore how next-gen consensus mechanisms are redefining blockchain efficiency.
Birth of Ethash
Eventually, these threads converged into Dagger Hashimoto, later refined into Ethash. It combined Hashimoto’s I/O-bound design (emphasizing memory access speed over raw hashing power) with Dagger’s DAG structure. After iterations by Vitalik, Gavin, Tim, and others, Ethash became Ethereum’s launch PoW algorithm — ASIC-resistant and light-client-friendly.
Protocol Enhancements: Uncle Blocks, Logs & Precompiles
By mid-2014, the protocol stabilized around core innovations:
Uncle Blocks (August 2014)
Introduced to improve block propagation and reduce centralization pressure from stale blocks, uncle inclusion allowed orphaned blocks to be referenced in later ones. This boosted network throughput and rewarded miners fairly — a key feature distinguishing Ethereum from Bitcoin.
Receipts and Logs (September 2014)
Two major changes were introduced:
- Each block now included a receipts trie, storing logs from transactions.
- Transactions could emit logs — data entries accessible to light clients but not to future contract logic.
This enabled dApps to efficiently index events like token transfers or auction updates without bloating state.
Alternative ideas — such as Merkleizing full execution traces — were abandoned in favor of simplicity.
Precompiled Contracts
Complex cryptographic operations (e.g., EC recovery) were too costly under standard EVM execution. The solution? Precompiles — hardcoded functions executed natively at low gas cost.
Earlier proposals allowed miners to vote on gas prices for optimized implementations, but were scrapped due to security risks: malicious actors could introduce backdoored contracts and manipulate pricing via collusion.
Instead, a minimal set of precompiles was added for essential crypto primitives.
Governance and Flexibility: The Gas Limit Vote
Unlike Bitcoin’s rigid block size debate, Ethereum embraced adaptability. The question was: how should the gas limit per block be determined?
Vitalik initially proposed a dynamic model: 1.5x the exponential moving average (EMA) of recent usage — targeting ~67% block utilization. But Andrew Miller demonstrated it could be gamed: miners could fill blocks with low-cost/high-gas transactions to artificially inflate limits.
The fallback? Let miners vote on the gas limit directly, with 1.5x EMA as default guidance. Though imperfect, it prioritized flexibility over theoretical optimality — allowing rapid adjustment in response to network needs.
Final Steps: Testing, Audits & Launch
PoC9 (March 2015) marked the final proof-of-concept release after a mini-hackathon involving Vitalik, Gavin, and Jeffrey Wilcke. This evolved into the Olympic testnet, running for four months with production-level code.
Security audits played a crucial role:
- Ittay Eyal (known for "selfish mining" research) reviewed consensus rules; led to excluding uncle blocks from total difficulty calculations.
- Least Authority audited smart contracts, gas economics, and Patricia trees; prompted hashing keys (
sha3(addr),sha3(key)) to prevent worst-case tree attacks.
Vinay Gupta outlined Ethereum’s roadmap: four phases named Frontier, Homestead, Metropolis, and Serenity — guiding long-term development.
By July 2015, code was frozen. On July 30, the Ethereum mainnet launched.
Frequently Asked Questions
Q: What was Ethereum’s original name or concept before it became Ethereum?
A: Before "Ethereum," Vitalik Buterin proposed enhancements to Mastercoin's protocol focused on two-party contracts. These ideas evolved into a standalone platform during late 2013.
Q: Why did Ethereum switch from a register-based VM to a stack-based one?
A: Community feedback, particularly from Andrew Miller, highlighted implementation complexity and auditing challenges with register-based systems. Stack-based VMs offered better simplicity and consistency.
Q: How does Ethash prevent ASIC dominance?
A: Ethash is memory-hard, requiring frequent access to large datasets (DAG). High memory bandwidth needs make ASIC optimization less efficient compared to GPUs.
Q: What are uncle blocks and why are they important?
A: Uncle blocks are valid orphaned blocks included in later blocks. They reduce centralization by rewarding fast-mining nodes even if their blocks become stale, improving overall network fairness and efficiency.
Q: Who decided Ethereum’s final protocol design?
A: While Vitalik initiated the vision, key contributors like Gavin Wood, Andrew Miller, Vlad Zamfir, and Jeffrey Wilcke shaped critical components through collaboration and technical debate.
Q: Was Ethereum’s gas limit always decided by miner votes?
A: Yes. After failing to design a secure dynamic model immune to manipulation, the team opted for miner voting with default guidance based on usage trends — balancing flexibility with decentralization.
👉 Learn how you can participate in the future of decentralized networks today.