NodeScholar

On this page

Educational, not financial

This page is a reference for understanding Ethereum — the technology, the economics, and the culture around it. It is not investment advice. Nothing here is a recommendation to buy, sell, or hold anything. Ethereum is volatile and carries real risk; if that matters to you, treat this as background reading, not a tip.

What Ethereum is

is a programmable blockchain — a network that runs code as well as moving money. Where Bitcoin is essentially a ledger that records who owns bitcoins, Ethereum is a general-purpose computing platform: anyone can deploy a — a program that lives on-chain and executes automatically when its conditions are met — and the network of nodes runs that code exactly as written. The native asset, (ETH), is both the fuel that pays for computation and a monetary asset in its own right.

The motivation was a frustration with Bitcoin's narrow scope. Vitalik Buterin, a teenage Bitcoin writer, kept wanting to build applications on top of Bitcoin — decentralized exchanges, prediction markets, token systems — and kept hitting the same wall: Bitcoin's scripting language is deliberately tiny, built for spending conditions, not general programs. His proposal, made when he was 19, was to build a new chain whose whole purpose was to be programmable — a world computer that anyone could write software for without asking permission.

That single design difference — general computation instead of payments only — is the fork in the road that explains almost everything else. It is why Ethereum has DeFi, NFTs, DAOs, stablecoins, and a sprawling ecosystem of tokens, and why it changes constantly while Bitcoin barely changes at all. The trade-off is complexity: more capability means more attack surface, more governance decisions, and more ways for things to go wrong. Ethereum chose the capability; the consequences of that choice are the story of this page.

How Ethereum works

Ethereum, like Bitcoin, is a network of that agree on a shared state. But Ethereum's state is far richer than a set of coin ownership records — it includes the balance of every account and the full bytecode and storage of every smart contract on the chain.

Accounts, not UTXOs

Ethereum uses an , not Bitcoin's model. There are two kinds of accounts: externally owned accounts (EOAs) controlled by a private key, and contract accounts controlled by their code. Both have a balance and a ; both can send transactions. The account model is more familiar — it works like a running balance — and it makes smart contracts natural, because a contract is just another account that runs code when it receives a message. The cost is weaker baseline privacy and a different set of security tradeoffs than UTXO chains.

The EVM and state

Every node runs the (EVM), a stack-based virtual machine with its own bytecode. A transaction triggers execution: the EVM steps through the bytecode, updating account balances and contract storage as it goes. Every node executes every transaction, so every node arrives at the same resulting state. That state — all balances and all contract storage — is stored in a Merkle-Patricia trie whose root is committed in each block, so anyone can cryptographically prove any piece of state. Finality on Ethereum is now explicit and fast: after a , a finalized block cannot be reverted without destroying at least a third of all staked ETH.

Blocks, slots, and the two layers

Since the Merge, Ethereum is two cooperating layers: an execution layer (transactions, the EVM, account state — the old Ethereum) and a (the Beacon Chain, proof of stake). A block is produced roughly every 12 seconds (a ), and attest to it; 32 slots make an epoch. The execution layer is what users and contracts see; the consensus layer is what keeps it honest.

Smart contracts & dApps

A is a program deployed to the chain. Once deployed it is immutable (you cannot edit it — at best you can redirect users to a new version), and it runs deterministically: every node gets the same result for the same input. That determinism is the point — it is what lets strangers run code together without trusting each other or a server.

Most contracts are written in a high-level language and compiled to EVM bytecode. Solidity is the dominant language (JavaScript-ish, curly-braced); Vyper is the safety-first alternative (Python-ish, deliberately limited to make bugs harder to write). The smart-contracts module walks through the common bug classes — reentrancy, integer overflow, access-control flaws — that have caused billions in losses.

A (decentralized application) is a user-facing app built on top of smart contracts — typically a web front end that talks to an on-chain backend through a wallet like MetaMask. Because the backend is on-chain, nobody can unilaterally shut it down or change its rules; because anyone can read the chain, anyone can build a competing front end for the same contracts. This composability — contracts calling other contracts, front ends swapping between back ends — is what earned Ethereum the nickname money legos.

Gas, fees & EIP-1559

Every EVM operation costs — a measure of computational work. Adding two numbers costs a little gas; storing data costs more; transferring ETH is cheap; an unbounded loop is ruinously expensive by design. Gas exists because every node runs every transaction, so the network has to limit how much work each block can contain and make users pay for the work they request.

Before 2021, fees were set by a first-price auction: you bid a gas price and hoped it was high enough to get included. The overhaul changed that to a two-part fee: a protocol-set that rises and falls with demand (and is burned, removed from supply), plus an optional (tip) you pay to jump the queue. The burn is why ETH's supply can go down as well as up — a major change to its economics, covered below. Try the gas-fee estimator →

A transaction also sets a — the maximum gas you're willing to spend. If execution runs past the limit, the transaction reverts (all state changes roll back) but you still pay for the work done. This is the network's defense against infinite loops: a buggy contract can burn your gas, but it cannot run forever.

Proof of stake & the Merge

For its first seven years Ethereum was secured by , exactly like Bitcoin. In September 2022 it executed the Merge: the execution layer fused with the Beacon Chain and proof of work was switched off. Ethereum is now secured by , in which participants lock up capital (stake ETH) and are selected to propose and attest blocks in proportion to their stake — replacing energy with economic skin in the game.

The motivation was primarily environmental and economic: proof of stake cut Ethereum's energy use by roughly 99.95%, eliminated the need for mining hardware and ASICs, and let the security cost be paid to holders rather than to electricity and chip makers. The critiques are real too — the “nothing at stake” worry, concerns about stake centralization, and the fact that PoS security depends on the value of the staked asset (which can fall). The PoW-vs-PoS deep dive covers the whole debate →

Crucially, the Merge is also why Ethereum can have finality: in PoS, once two-thirds of staked ETH attests to a block, it is “justified,” and once the next checkpoint justifies, the prior becomes “finalized” — reverting it would require destroying at least a third of all staked ETH through . Bitcoin's finality is probabilistic (wait for more blocks); Ethereum's is explicit and faster.

Staking & validators

To become a you deposit 32 ETH into the deposit contract and run a validator client plus a beacon node (with client diversity — running a minority client to avoid a single bug taking down the network — increasingly seen as a duty, not a preference). Validators are randomly assigned to propose and attest blocks; honest participation earns rewards, while going offline incurs inactivity leaks and attacking the network triggers — the forced destruction of some of your stake and ejection from the set.

Because 32 ETH is a high bar, most people stake through protocols or exchanges. You deposit ETH and receive a liquid token representing the stake — Lido's stETH is the largest — which you can then use in DeFi while it earns staking rewards. This convenience has a centralization cost: Lido and a few large operators now hold a large share of all staked ETH, which the community treats as one of its most serious ongoing risks. The upgrade in 2023 enabled withdrawals, letting stakers exit — and, contrary to fears, total staking grew afterward.

Ether & tokenomics

ETH is unusual in that it plays three roles at once: it is money (a store of value and medium of exchange), gas (the unit that pays for computation), and collateral (the asset backing DeFi loans and staking). This “triple-point asset” framing is why ETH is compared to Bitcoin so differently by different people: it is not just a coin, it is the load-bearing asset of an entire computing platform.

Unlike Bitcoin, ETH has no hard cap. Its supply was pure inflation under proof of work, but EIP-1559's base-fee burn changed that: when network demand is high, more ETH is burned than created, and the supply shrinks (“” in the meme of its proponents); when demand is low, net issuance is positive again. The supply is thus elastic rather than fixed — a deliberate contrast with Bitcoin's 21 million, and a real philosophical disagreement about what a monetary asset should be.

The ERC token family

Ethereum's programmability means anyone can issue a token with a few lines of Solidity. To keep tokens interoperable, the community adopted Ethereum Request for Comments standards — the ERC family. A token standard is just an interface: any contract that implements it works with any wallet, exchange, or dApp that expects it.

— fungible tokens. The standard for almost every coin issued on Ethereum: stablecoins, governance tokens, utility tokens. It is the foundation of the entire token economy.
— non-fungible tokens (NFTs). Each token is unique and trackable, which is why NFTs exploded as collectibles and digital-art proofs of ownership. NFTs deep dive →
— multi-token standard: one contract manages fungible, semi-fungible, and non-fungible tokens together, more efficiently than separate ERC-20/721 contracts.
— tokenized vaults, the standard behind yield-bearing wrappers and restaking tokens.

The standards layer is a quiet reason Ethereum compounds: every new standard makes the next application cheaper to build, because wallets and tooling already know how to handle it.

DeFi on Ethereum

is Ethereum's flagship use case: financial primitives — exchanges, lending, stablecoins, insurance, derivatives — rebuilt as smart contracts that anyone can use and no one can gatekeep. Ethereum hosts the overwhelming majority of DeFi's , and the major building blocks all started here.

DEXes — like Uniswap let you swap tokens against a governed by a math formula, no order book or counterparty needed.
Lending — Aave and Compound let you supply assets to earn yield or borrow against collateral, with rates set algorithmically by supply and demand.
Stablecoins — DAI (a backed by crypto collateral) and USDC anchor DeFi's unit of account. MakerDAO/DAI deep dive →

The signature property is composability: a lending protocol can use a DEX's prices, a stablecoin can be deposited into a yield vault, and a derivative can wrap all of the above — all by calling contracts that already exist. This is enormously powerful and also the source of cascading risk: when one primitive fails, everything bolted on top of it can fail too. The DeFi module and the DeFi exploits deep dive cover the failures as frankly as the successes.

Layer 2s & scaling

Ethereum's base layer, like Bitcoin's, is intentionally limited — roughly a few dozen transactions per second. Scaling happens on : networks that batch thousands of transactions off-chain and post a compressed proof or summary back to Ethereum, inheriting its security while charging a fraction of the fees.

The dominant pattern is the . An (Arbitrum, Optimism, Base) assumes transactions are valid and lets anyone challenge a fraudulent batch with a within a challenge window. A (zkSync, Starknet, Linea, and others) posts a cryptographic validity proof so the base layer mathematically cannot accept an invalid state. The zero-knowledge deep dive explains the cryptography →

Ethereum's scaling roadmap is explicitly rollup-centric: the base layer's job is to provide cheap data and strong settlement for rollups, not to process every user transaction itself. The 2024 upgrade (EIP-4844 ) introduced — cheap, temporary data storage just for rollups — and L2 fees collapsed overnight. The next stages (full ) push that throughput far higher.

Governance & EIPs

Ethereum changes through the Ethereum Improvement Proposal (EIP) process — formally similar to Bitcoin's BIPs but radically different in tempo. Ethereum ships scheduled every few months (Frontier, Homestead, Metropolis, Constantinople, London, Shanghai, Dencun…), each bundling many EIPs. A hard fork here is not a schism — it is the normal upgrade mechanism, coordinated in advance so every client upgrades together. The community simply moves; those who don't upgrade are left on a stale chain.

Coordination happens off-chain: regular All Core Devs calls, the Ethereum Foundation, client teams, researchers, and rough consensus among application developers. There is no on-chain governance and no token vote for protocol changes (unlike many DAOs that run on Ethereum). The result is fast-moving compared to Bitcoin — Ethereum has overhauled its fee market, its consensus algorithm, and its data layer in a few years — at the cost of a more visible “team in charge” and recurring arguments about who actually decides.

A quiet but critical safety valve is client diversity: Ethereum has multiple independent implementations of both layers (Prysm/Lighthouse/Teku/Nimbus for consensus, Geth/Nethermind/Besu/Reth for execution). If one client has a bug, the others keep the chain correct — provided no single client has a supermajority of validators. Centralization of validators on one client is treated as an existential risk for exactly this reason.

The DAO hack & the fork

In 2016 a smart contract called The DAO raised ~$150M to act as a decentralized venture fund — the largest crowdfunding ever at the time. A bug in its code (a flaw) let an attacker repeatedly withdraw ETH before the balance was updated, draining about 3.6M ETH. The exploit was technically legal under the contract's code; the question was whether Ethereum should let it stand.

After a fierce debate, the community executed an irregular state change — a hard fork that moved the stolen funds to a recovery contract, effectively bailing out The DAO's depositors. A principled minority refused the fork on the grounds that “” and a blockchain should never rewrite history; they continued the unforked chain as . The split is crypto's defining governance precedent: it established that Ethereum would intervene to correct catastrophic bugs, prioritizing users over immutability — the opposite of Bitcoin's ethos. The full deep dive →

History & milestones

Tap any event to expand its story.

Ethereum vs. Bitcoin

The two are constantly compared, and the comparison is genuinely illuminating — but it is a comparison of different bets, not a contest with a clear winner.

Scope. Bitcoin is a payments/settlement ledger; Ethereum is a general-purpose computing platform. Bitcoin does one thing conservatively; Ethereum does many things ambitiously.
Consensus. Bitcoin uses proof of work (energy, probabilistic finality, ASIC mining); Ethereum uses proof of stake (capital, explicit finality, no mining). The energy and centralization arguments cut both ways. Full debate →
Account model. Bitcoin tracks unspent outputs (UTXOs); Ethereum tracks account balances and contract state. UTXOs give better privacy tooling and parallelism; accounts make smart contracts far more natural.
Change. Bitcoin barely changes (no hard forks to consensus rules, ever); Ethereum hard-forks on a schedule and has replaced its own consensus mechanism. Bitcoin optimizes for predictability; Ethereum for adaptability.
Supply. Bitcoin has a fixed 21M cap; ETH's supply is elastic, nudged deflationary by the fee burn. Each side argues its model is the right one for money.
Culture. Bitcoin's ethos is sound money and self-sovereignty; Ethereum's is build — a builder-first culture that ships constantly and treats the base chain as a platform to compose on, not a relic to preserve.

The “” — the hypothetical moment ETH's market cap overtakes Bitcoin's — is a perennial meme, but the more honest framing is that they are optimized for different things and are likely to coexist for a long time. The Bitcoin topic page lays out the other side of each of these tradeoffs.

Security & risks

Ethereum's security story is layered and, because of smart contracts, more complicated than Bitcoin's. The base layer is secured by staked ETH and explicit finality; the application layer is secured by... whatever the author of each contract wrote. That is where most of the money has been lost.

Smart-contract bugs. Reentrancy, integer overflow, access-control flaws, and oracle manipulation have drained billions. A contract is immutable once deployed, so a bug is permanent unless funds are socially recovered (as in the DAO fork) or paused via an upgradeable proxy. Exploits deep dive →
Bridge hacks. The biggest thefts in crypto history have mostly been cross-chain bridges, many connecting to or from Ethereum. Bridges hold huge value and have complex, often under-audited code. Bridge hacks deep dive →
MEV. — the profit searchers extract by reordering, inserting, or censoring transactions — is endemic to Ethereum's account and fee model. It manifests as sandwich attacks and arbitrage, and the Flashbots/MEV-Boost pipeline was built to manage it. MEV deep dive →
Stake centralization. A few liquid-staking operators and exchanges hold a large share of staked ETH. The protocol is designed to punish attacks through slashing, but centralization weakens censorship resistance and the client-diversity safety valve.
Client and consensus bugs. Because Ethereum upgrades constantly, each hard fork is a chance for a consensus bug to split the chain. Client diversity is the mitigation, but it only works if no single client dominates.

Wallets & account abstraction

Ethereum wallets are key managers like Bitcoin's, but the account model changes the UX. A standard wallet is an externally owned account controlled by a ; browser extensions like MetaMask sign transactions and broadcast them. Try the wallet lab →

The long-running pain point is that EOAs are rigid: if you lose your keys your funds are gone, you can't set spending limits, and you can't pay gas in the token you're sending. (EIP-4337) is the fix — it lets smart-contract wallets become first-class accounts with custom logic: social recovery, session keys, gas sponsorship, multi-signature rules, and batching. It is the biggest UX upgrade Ethereum has attempted and is still rolling out across the ecosystem.

Culture & community

Ethereum's culture is builder-first. Where Bitcoin's ethos is hold and verify, Ethereum's is ship and compose. The community gathers around developer conferences (Devcon, ETHGlobal hackathons), the Ethereum Foundation, and a dense web of client teams, rollup teams, and application builders who ship constantly. Vitalik Buterin remains a public intellectual anchor for the project — unusually for a major crypto network — publishing research and opinions that shape direction even though he has no formal power to enforce any of it.

The culture has its own lexicon and memes. “” is the half-joking, half-serious claim that EIP-1559's burn makes ETH deflationary. The “” is the dream of ETH overtaking BTC. The “rollup-centric roadmap” is the canonical scaling plan. And the recurring argument with Bitcoin maximalists — “” — over which design is correct is itself a cultural ritual. The most distinctive trait, though, is optimism about building: the default assumption is that most problems are solvable with another protocol upgrade.

The roadmap

Ethereum's roadmap, articulated most clearly by Vitalik, is a set of named milestones rather than a fixed schedule.

The Merge — done (2022). PoW retired; proof of stake live.
The Surge — scaling through rollups and danksharding. EIP-4844 was the first step; full danksharding and shared data availability push throughput orders of magnitude higher.
The Scourge — taming MEV and resisting censorship: making sure the protocol stays credibly neutral even as large stakers and builders accrue power.
The Verge — and so anyone can verify the chain without storing all state, keeping decentralization of verification alive as the chain grows.
The Purge — pruning historical state bloat so the chain doesn't become unbearably heavy over decades.
The Splurge — everything else: the long tail of improvements that don't fit a theme.

The throughline is a bet that Ethereum can keep upgrading its way past each limitation without sacrificing the credibility that makes it worth building on — a harder balancing act than it sounds, and the real test of the project over the next decade. The roadmap deep dive goes deeper →

Key takeaways

Ethereum is a programmable blockchain — a world computer that runs smart contracts as well as moving money — which is the single design choice that distinguishes it from Bitcoin and explains its ecosystem.
It uses an account model and the EVM; since the 2022 Merge it is secured by proof of stake with explicit finality, using roughly 99.95% less energy than before.
Gas pays for computation; EIP-1559's base fee is burned, making ETH's supply elastic (sometimes deflationary), in deliberate contrast to Bitcoin's fixed cap.
Its killer feature is composability: ERC-20/721/1155 tokens, DeFi primitives, and rollups all call each other, which is enormously powerful and the source of cascading risk when a primitive fails.
Scaling is rollup-centric: Layer 2s (optimistic and zk) batch transactions and inherit Ethereum's security; EIP-4844 blobs made them dramatically cheaper in 2024.
Ethereum governs itself with frequent, scheduled hard forks and off-chain core-dev consensus — fast-moving and adaptable, at the cost of a more visible “team in charge” than Bitcoin.
The 2016 DAO fork set its defining precedent: Ethereum prioritizes users over immutability and will intervene to correct catastrophic bugs — the opposite of Bitcoin's ethos.
For the deeper stories — Vitalik and the launch, the DAO hack, the Merge, MEV, the roadmap — follow the related Deep Dives below.

Your chain