What is Ethereum?

Ethereum is a public blockchain network. It does more than record transfers of a native asset: it also lets developers deploy programs onto the blockchain, has the computers taking part in the network execute those programs under shared rules, and preserves the resulting state.

These onchain programs are usually called smart contracts. Ethereum's native asset is called Ether (ETH) and is recorded directly by the network protocol. Several smart contracts, a web interface and other services can together make up an application; token standards, meanwhile, let different programs handle certain digital units in a shared way. What Ethereum provides is a shared execution and accounting environment — it is not the operator of any particular application or token.

A jointly maintained network state

Ethereum nodes keep and verify a continuously updated network state. You can think of the state as the records the network currently accepts, including how much native asset an account holds, what code a contract has deployed, and which data a contract stores.

Ethereum accounts come in two kinds: externally owned accounts and contract accounts. An externally owned account initiates operations by signing with a private key; a contract account instead executes according to its code when it receives a transaction or a call from another contract. Both have addresses, but they are controlled differently: one relies on a valid signature, the other on program rules.

Nodes do not each modify the records as they please. They check transactions and execute code under the same protocol, and confirm block order according to the consensus rules used to decide which stretch of block history to accept. Only state changes that comply with the rules are accepted.

How a transaction changes state

A transaction is an operation request signed by an externally owned account and submitted to the network. It can send ETH to another address, deploy a contract, or call a contract that already exists.

A transaction usually carries the sender, the destination, a value, the data to be handed to a contract, a sequence number that prevents repeated processing, and the execution fee the sender is willing to bear. After receiving a transaction, nodes first check its signature and format; a block proposer then includes qualifying transactions in a candidate block.

Transactions in a block execute in a determined order. Each one starts from the state left by the previous execution, so order can affect the outcome. If a contract call succeeds, balances or contract data are updated according to the code; if execution fails, the intended state changes are rolled back, but the computing resources already consumed may still incur a fee.

Shared execution of smart contracts

A smart contract is code and associated data deployed on Ethereum. Once a user or another contract initiates a call, execution clients across the network process the instructions under the same rules, producing a result other nodes can recompute and check.

The rule environment that executes these instructions is called the Ethereum Virtual Machine (EVM). The EVM specifies how code reads data, computes and updates state. It is not one physical computer but a set of shared execution rules implemented by each node.

A contract can directly use only call data, onchain state and information the protocol permits it to read. It cannot reach arbitrary web pages on its own; when offchain data is needed, that usually has to be supplied by an external participant or by a service dedicated to submitting external information onchain — an oracle. Even when every node reaches the same execution result, that does not mean the offchain information fed in was necessarily true.

What ETH does for the network

ETH is recorded directly by the Ethereum protocol. It is not a token issued by a smart contract following a fungible token interface such as ERC-20.

ETH can be transferred between addresses, and it is also used to pay the gas fee the network charges for executing transactions. Gas measures the computing resources an operation consumes; the final fee also depends on the applicable gas price. When sending tokens or calling an application, a user usually still needs native ETH to pay execution fees on Ethereum mainnet.

ETH also serves Ethereum's proof of stake mechanism. A validator locks a specified amount of ETH to take part in proposing and confirming blocks, and may receive protocol rewards for performing correctly, or penalties for violations and certain failures. Holding ETH does not by itself make an account a validator, and it does not amount to owning Ethereum or holding administrative control over any application.

Proof of stake and a shared history

Ethereum uses proof of stake to decide who proposes a block, how other validators check it, and which stretch of history the network accepts when competing branches appear. Validators send protocol votes on blocks and checkpoints; once the required conditions are met, a block can gain stronger confirmation and become finalized.

Execution and consensus carry different tasks: execution rules determine how a transaction changes state, while consensus rules determine the block order in which transactions enter the shared history. A node has to run an execution client and a consensus client that work together in order to verify the current Ethereum protocol in full.

Finalization raises the cost and difficulty of overturning already confirmed history, but it does not mean every application outcome is free of risk. Contract defects, mistaken approvals, inaccurate inputs or administrative permissions can still produce irreversible consequences.

Ethereum, ETH, the EVM and tokens

These names often appear together but point to different things:

• Ethereum is the blockchain network and its protocol;
• ETH is that network's native asset;
• the EVM is the rule environment nodes follow when executing contract code;
• a token is usually recorded by a specific smart contract or another onchain program;
• a decentralized application usually consists of smart contracts, a user interface and offchain services together.

Using an Ethereum application therefore does not mean you will only encounter ETH; an application may also handle stablecoins, non-fungible tokens (NFTs) or other tokens. Conversely, having "Ethereum" in a name or using a similar address format cannot on its own prove that an asset sits on Ethereum mainnet.

Mainnet, testnets and compatible networks

Ethereum mainnet is the production network carrying the real network state and native ETH. Testnets instead serve development and experimentation, with their own separate state and test assets that carry no mainnet value meaning.

Other blockchains can also implement the EVM or adopt similar tooling, making it easier to migrate contracts originally written for Ethereum. They remain independent networks: each has its own block history, fee asset, contract address context and security arrangements. Even when the same address or contract code appears on several networks, balances and execution results do not synchronize automatically.

Before initiating an operation, a wallet has to confirm the selected network, the chain identifier representing that network — its network number — and the contract address. Sending assets to the wrong network, or interacting with the wrong contract, is not something you can judge from how an address looks.

How Layer 2 works with Ethereum mainnet

Layer 2 refers to a class of scaling approach that handles some transactions outside Ethereum mainnet and then submits the related data or results back to mainnet. These approaches aim to increase capacity or lower the cost of an individual operation while retaining a particular Ethereum settlement or data dependency.

Different Layer 2 systems arrange transaction ordering, data publication, proof methods, withdrawal waiting periods and failure handling differently. Balances and transactions on a Layer 2 also do not appear automatically in a mainnet account; moving across layers usually requires a bridge or a deposit-and-withdrawal flow the protocol specifies.

"Built on Ethereum" therefore does not mean every operation executes directly on Ethereum mainnet. When judging fees, confirmation times and risk, first confirm which layer a transaction actually happens on, and by what mechanism funds move between layers.

The boundary between protocol capability and application risk

Ethereum's shared execution environment lets different developers deploy tokens, trading protocols, lending programs, games and other applications, and lets smart contracts call one another. But open deployment also means anyone may publish a contract that is defective, carries administrative permissions or is misleading.

The network confirming that a transaction complies with the protocol only shows that the signature, execution and block record passed the corresponding rule checks. It cannot prove that:

• a contract matches a user's actual intent or is free of defects;
• a token's name, issuer or offchain reserves are genuine;
• the data an application interface displays is complete;
• the offchain information an oracle provides contains no errors;
• a project will keep operating or honour offchain commitments.

When using a specific application, you still have to check the network, contract address, approval content, administrative permissions and dependent services. A blockchain can verify operations within protocol rules; it cannot automatically verify every offchain fact.

FAQ

Are Ethereum and ETH the same thing?

No. Ethereum is the network and protocol; ETH is the network's native asset.

Is Ethereum controlled by one company?

Ethereum is not kept as a ledger directly by a single database operator. Several client teams, node operators, validators, application developers and users influence how the ecosystem develops, but their respective powers differ; changing the protocol still requires implementation, adoption and coordination among network participants, so the whole network cannot be equated with any one company or website.

Does every transaction run a smart contract?

Not necessarily. An externally owned account can send ETH directly to another externally owned account. Contract code is executed when a contract is deployed or called.

If a transaction shows as successful, does that mean the operation was safe?

No. Success only means the transaction completed under the network and contract rules in force at the time. A mistaken approval, a malicious contract or an outcome that does not match a user's expectation can still be written onchain successfully.

Is an EVM-compatible network the same as Ethereum?

No. Such networks may use similar contract execution rules and development tools, but network state, validators, fee asset and security arrangements can be entirely independent.

Related concepts

Continue with smart contract, proof of stake, blockchain, gas fee and crypto token, or return to the Crypto Glossary.

Sources

• Ethereum.org: what is Ethereum — the basic scope of the network, ETH, smart contracts and the application ecosystem.
• Ethereum.org: accounts — externally owned accounts, contract accounts and how each is controlled.
• Ethereum.org: transactions — transaction fields, signing, execution and state changes.
• Ethereum.org: Ethereum Virtual Machine — the EVM's state transitions and shared execution environment.
• Ethereum.org: proof of stake — validators, block proposal, voting and finalization.