Blockchain Mainnet since 2020 · Open source

Everscale Owned by no one. Built by everyone.

best user experience, speed and scalability, and near-free transfers

workchain 0 1 threads
thread message Simulation, not live data
Block time
~2 s
Average transaction fee
<$0.001
Threads per workchain, on demand
256
Workchains the protocol can address
232

Why Everscale

Capacity that follows demand

Everscale splits the work across more shards as activity grows and merges them back when it calms down. Users get the same fast, cheap experience at any load.

  • Dynamic sharding

    Workchains split into up to 256 threads as activity grows and merge back when it drops.

  • Near-free, fixed fees

    Fees are fixed by the network config, not by demand. A transfer costs a fraction of a cent.

  • Extra currencies, built in

    Up to 232 native currencies next to EVER, with no token contracts needed.

  • BFT finality

    Catchain BFT consensus with staked validators. Once two-thirds agree, a block is final.

  • Paid storage

    Contracts pay rent for their state, so abandoned data doesn't bloat the chain.

  • Asynchronous by design

    Contracts are actors that talk through messages, so transactions run in parallel.

Architecture

One masterchain. Many workchains. Threads on demand.

Everscale shards both data and execution.

  1. 01

    Masterchain

    Consensus and finality. It holds the latest block hashes of every other chain, so the whole network agrees on a single state.

  2. 02

    Workchains

    Data shards. Each can have its own rules, virtual machine and native currency. The protocol can address up to 232 of them.

  3. 03

    Threads

    Execution shards inside a workchain, from 1 to 256, scaled up and down automatically with network activity.

The EVER coin

EVER powers every transaction

EVER is Everscale's native coin. It pays for everything the network does and secures the network through validator staking.

  • Gas

    Pays for computation. A contract can accept the cost of an incoming external message itself, so apps can cover fees for their users.

  • Storage and messages

    Pays rent for on-chain state and forwarding fees for messages sent between contracts.

  • Staking

    Validators stake EVER to win seats in validator elections and earn rewards for producing blocks.

1 EVER = 1,000,000,000 nanoevers

Explore the chain

For developers

Solidity you know. A VM built for scale.

Write contracts in T-Sol, the EverVM dialect of Solidity, deploy and test them with a Hardhat-like framework. Calls contracts are messages, your code scales from day one.

Shop.tsol
pragma tvm-solidity >= 0.72.0;

contract Oracle {
    mapping(uint32 => coins) public prices;

    function getPrice(uint32 asset) public responsible returns (coins) {
        return prices[asset];
    }
}

contract Shop {
    coins public lastPrice;

    function quote(address oracle, uint32 asset) public {
        Oracle(oracle).getPrice{callback: Shop.onPrice}(asset);
    }

    function onPrice(coins price) public {
        lastPrice = price;
    }
}
Contracts never block each other - getPrice runs in its own transaction, maybe on another thread, and replies through the invocation of onPrice callback.

Built in the open

The whole stack, on GitHub

The openever community maintains Everscale's core: the node, the virtual machine, the compiler and the networking layer. Read it, run it, improve it.

Build a node
$ git clone --recurse-submodules https://github.com/open-ever/ever-node.git
$ cd ever-node
$ cargo build --release