What Is Starknet? Cairo, STARKs, and Scalability

Starknet is an Ethereum layer 2 network built as a validity (zk) rollup, using STARK cryptographic proofs, a scalable and quantum-resistant proof system, rather than the more commonly used SNARK proofs, to mathematically verify that off-chain transaction batches were executed correctly before posting that verification to Ethereum.

Developed by StarkWare, Starknet is notable for not using the Ethereum Virtual Machine at all. Instead, it runs its own custom virtual machine and a purpose-built programming language called Cairo, a different approach than the zkEVM path taken by projects like zkSync Era or Scroll.

STARKs vs. SNARKs

Both STARKs (Scalable Transparent Arguments of Knowledge) and SNARKs (Succinct Non-Interactive Arguments of Knowledge) are types of zero-knowledge validity proofs used to prove a computation was performed correctly without re-executing it. The key differences:

• Transparency: STARKs don't require a "trusted setup" ceremony, a process some SNARK systems need to generate initial cryptographic parameters securely. STARKs avoid this by using only publicly verifiable, collision-resistant hash functions.
• Post-quantum resistance: STARKs rely on hash-based cryptography rather than elliptic curve assumptions, making them more resistant, in theory, to future quantum computing attacks compared to many SNARK constructions.
• Proof size: STARK proofs tend to be larger than SNARK proofs, which can mean higher on-chain verification costs, though ongoing optimizations have narrowed this gap over time.

Why Cairo instead of the EVM

Cairo is a Turing-complete programming language purpose-built for writing STARK-provable programs, designed from the ground up around the constraints of efficient proof generation rather than adapted from an existing execution environment. This gives Starknet more flexibility to optimize for proving efficiency, but it means developers can't simply redeploy existing Ethereum Solidity contracts without adaptation, unlike zkEVM-based rollups that prioritize EVM bytecode compatibility.

Cairo has its own tooling, standard library conventions, and learning curve, which has meant a somewhat smaller pool of developers immediately able to build on Starknet compared to EVM-compatible chains, though this gap has narrowed considerably as Cairo tooling and documentation have matured.

How the rollup mechanics work

Like other validity rollups, Starknet's general flow is:

• A sequencer orders and executes transactions off-chain.
• A prover generates a STARK proof attesting the batch was executed correctly according to Starknet's rules.
• The proof, along with necessary state data, is submitted to and verified by a smart contract on Ethereum.
• Once verified on-chain, the batch is considered final, without the roughly week-long dispute window that optimistic rollups require.

Decentralization status

Starknet's sequencer and prover infrastructure has historically been operated primarily by StarkWare, with active roadmap work toward decentralizing both roles over time, similar to the broader sequencer decentralization challenges discussed in our dedicated guide. Users should treat this centralization as a real, current tradeoff rather than an already-solved problem, regardless of a chain's long-term roadmap intentions.

Ecosystem and use cases

Starknet hosts a growing set of DeFi protocols, and its STARK-based technology is also used in other StarkWare products beyond Starknet itself. Check TVL and activity data on our chains page for current adoption figures relative to other L2s.

Recursive proofs and scalability

Starknet has invested heavily in recursive proof techniques, where individual proofs of smaller computations can be combined into a single larger proof, letting the network aggregate many transactions' worth of proving work more efficiently over time. This is a meaningful part of StarkWare's broader technical thesis: that STARK-based proving systems have a clearer long-term path to handling very large transaction volumes cheaply, even if the technology took longer to mature than some SNARK-based alternatives in its earlier years.

Fees and cost considerations

Like other validity rollups, transaction costs on Starknet reflect both the computational cost of generating STARK proofs and the cost of posting the resulting proof and state data to Ethereum. Because STARK proofs have historically been larger than SNARK proofs, on-chain verification costs can be higher in isolation, though this is partly offset by STARK proving systems scaling more efficiently as transaction volume grows, an active area of ongoing optimization across the ecosystem.

Starknet vs. a zkEVM rollup

Factor	Starknet	zkEVM rollup (e.g. zkSync Era, Scroll)
Proof system	STARKs	Typically SNARKs
Execution environment	Custom VM (Cairo)	zkEVM, EVM-compatible
Trusted setup needed	No	Depends on specific SNARK construction
Developer familiarity	Requires learning Cairo	Familiar Solidity/EVM tooling
Withdrawal delay	Faster than optimistic rollups	Faster than optimistic rollups

Bottom line

Starknet takes a distinctive path among Ethereum layer 2s, using STARK proofs and its own Cairo language rather than an EVM-compatible execution environment, trading some developer familiarity for potential long-term proving efficiency and post-quantum resistant cryptography. As with other zk-rollups, its sequencer and prover roles remain relatively centralized today, so treat that as an active risk factor. Compare it directly against other zk-rollups in our zkSync vs Starknet guide before deciding where to deploy capital.