UTXOs vs. account models

If you've used both Bitcoin and Ethereum, you've already encountered the deepest design split in cryptocurrency without necessarily noticing it. Bitcoin uses the UTXO model. Ethereum uses the account model. Almost every major chain is a variation on one of these two approaches, and the choice has wide downstream consequences.

The account model: what you'd expect

Ethereum looks like a bank. Each address is an account with a balance. To send 1 ETH from Alice to Bob, the network deducts 1 from Alice's balance and adds 1 to Bob's. Easy. Familiar. Also exactly how a database thinks about money.

Before:        After 1 ETH transfer:
Alice: 5 ETH    Alice: 4 ETH
Bob:   2 ETH    Bob:   3 ETH

Smart contracts use the same model. A contract is an account. It has a balance and storage. State updates are reads and writes against a global key-value store keyed by address.

The UTXO model: more like cash

Bitcoin doesn't store balances. It stores coins. Each coin — formally, an Unspent Transaction Output, or UTXO — is a discrete chunk of value with an owner and a specific size. Your 'balance' is the sum of UTXOs that you can spend.

When you send bitcoin, you don't decrement a balance. You consume one or more UTXOs entirely and create new UTXOs for the recipient and (usually) a 'change' UTXO back to yourself.

Alice has these UTXOs:
  UTXO-A: 0.6 BTC
  UTXO-B: 0.5 BTC

Alice sends 1.0 BTC to Bob.

The transaction:
  INPUTS:  UTXO-A (0.6) + UTXO-B (0.5) = 1.1 BTC
  OUTPUTS: 1.0 to Bob, 0.0995 back to Alice (change),
           0.0005 fee to miner

Notice the inputs are consumed in their entirety. UTXOs don't get partially spent — they get destroyed and replaced.

Why this distinction matters

Privacy and traceability

In an account model, every transfer is between two accounts whose entire history is linked. In UTXO, an output that's been received is fungible with any other UTXO of the same value once it's mixed. Each UTXO can sit at a different address. A determined user can keep different UTXOs cleanly separated, never co-mingling them in the same transaction. This is one reason Bitcoin privacy practices look weird from an Ethereum perspective.

Parallelism

Account-model state is fundamentally sequential. To know Alice's balance, you have to apply every transaction touching her account in order. UTXOs are independent — different UTXOs can be validated in parallel. This is part of why Bitcoin's scaling story leans on layers (Lightning) more than throughput.

Smart contract complexity

Account models map naturally to mutable global state, which is what general-purpose smart contracts want. UTXO chains can do contracts (Cardano, Bitcoin Script with covenants, Liquid) but the programming model is more constrained — each output carries its own little script that locks it. This is good for security (less surface area) and bad for ergonomics.

Replay and front-running

In an account model, transaction ordering matters globally — Alice's nonce strictly increases. Anyone who sees a pending transaction in the mempool can try to insert their own ahead of it (MEV). UTXOs sidestep some of this because each output is consumed exactly once; you can't 'reorder' independent transactions in a way that changes the outcome.

Which is better?

Neither. They optimize for different goals.

• If your top priority is sound money and fungibility for a single asset, UTXOs win.
• If your top priority is general-purpose programmability and developer ergonomics, accounts win.

Newer chains have started blurring the line. Sui and Aptos use object-based models that look UTXO-shaped but support rich smart contracts. Cardano's eUTXO extends Bitcoin's model with arbitrary state. The next decade of chain design is largely a search for hybrids that get the privacy and parallelism of UTXOs with the programmability of accounts.