Move Language (Aptos and Sui)
Why Move's resource model fundamentally differs from Solidity, how Aptos and Sui evolved from the same Facebook-origin language, and what 'resources' mean for safety guarantees.
The basics
What Move Is
Move is a smart-contract language originally developed at Facebook for the Diem (formerly Libra) blockchain. After Diem shut down, Aptos and Sui — both founded by former Diem team members — picked up Move as their primary smart-contract language. Move is notable for its 'resource' model: assets like tokens are first-class language constructs that can't be copied or accidentally deleted, only moved between owners. This eliminates a class of bugs (double-spending, accidental burn) at the language level.
Why Resources Matter
In Solidity, your token balance is just a number in a mapping. The contract has to enforce 'this balance can't decrease without an authorised transfer.' Bugs in that enforcement (Cream Finance, Compound's COMP distribution bug, others) have produced major losses. In Move, a token is a 'resource' — the language type system tracks ownership. You literally can't write code that copies a token or destroys it without using a defined `destroy` operation. Whole exploit categories that exist on Solidity are unrepresentable in Move.
Aptos vs Sui — Same Language, Different Ecosystems
Both Aptos and Sui use Move, but the chains diverge. Aptos uses Move closer to its original Diem form (extended in Move 2.x) with optimistic parallel execution (Block-STM). Sui uses Move with significant modifications (Sui Move) and parallel execution similar to Solana's Sealevel. The forks are now substantially different — code written for Aptos isn't directly portable to Sui. Both chains have active developer ecosystems; on DefiLlama, Sui's TVL peaked at about $2.6B (October 2025) and Aptos's at about $1.3B (December 2024), and on 14 November 2026 they stood at about $0.37B and $0.04B.
- Move originated at Facebook for the Diem project; lives on in Aptos and Sui
- Resource model: assets are first-class types that can't be copied or accidentally destroyed
- Aptos: closer to original Move, with optimistic parallel execution (Block-STM)
- Sui: forked Move with parallel execution and significant modifications
Key Takeaways
- Move's resource model prevents whole exploit categories at the language level
- Aptos and Sui both use Move but have diverged significantly
- Move developer pool is smaller than Solidity's
- Trade-off: stronger safety guarantees + harder onboarding for Solidity devs
Going deeper
The Resource Type System
In Move, every type has 'abilities': key, store, copy, drop. A type with 'copy' can be duplicated; without it, only moved. A type with 'drop' can be silently discarded; without it, must be explicitly destroyed. Tokens are defined without copy or drop abilities — so they can't be duplicated and must be explicitly burned. The compiler enforces this. Write code that tries to copy a token, the program won't compile. This is fundamentally stronger than runtime checks in Solidity.
Sui's Object Model
Sui takes Move's resource model further with an object model: every on-chain entity is an 'object' with explicit ownership. NFTs are objects you own; positions in DEX pools are objects. Transactions specify which objects they touch, similar to Solana's account declarations — enabling parallel execution. The object model is more granular than Solana's accounts (objects can be nested, owned by other objects, etc.) and creates new design patterns for composability.
Aptos's Block-STM
Aptos uses a different parallelism approach called Block-STM (Software Transactional Memory). Transactions execute optimistically in parallel; if conflicts are detected post-hoc, conflicting transactions re-execute serially. Block-STM doesn't require advance declaration of account dependencies (unlike Solana). Developers don't declare access lists, so the developer experience is closer to Ethereum's 'just call whatever you want.'
Move's Diem Heritage
Move was designed for Facebook's planned Diem stablecoin — a payments project that, in its own words, aimed to design a better and more inclusive payment system. After Diem was wound down in 2022 (its own statement said dialogue with federal regulators made clear the project could not move ahead, and its assets were sold to Silvergate, announced 31 January 2022), the team scattered and brought Move to multiple new chains. Some Move infrastructure (Move Prover, formal verification tooling) was developed for Diem's institutional-grade requirements and is still maintained as part of the Aptos toolchain.
Key Takeaways
- Move's type abilities (key/store/copy/drop) enforce resource discipline at compile time
- Sui's object model extends Move's resources to all on-chain entities
- Aptos's Block-STM enables parallel execution without account declarations
- Move's Diem heritage produced formal-verification tooling (the Move Prover)
Under the hood
Move Prover and Formal Verification
Move Prover is a formal verification tool that proves properties of Move programs. You write specifications (e.g., 'no token is ever created from nothing,' 'this function never decreases the total supply'), and the prover formally verifies that the program satisfies them. Most Solidity equivalents (Certora, KEVM) are external tools requiring substantial expertise; Move Prover is part of the Move toolchain on Aptos, while Sui's formal-verification tool (the Sui Prover) is a separate project.
Comparison to Solidity's Patterns
Several classes of Solidity bugs are eliminated by Move's design. Double-spending: a resource can't be in two places at once, so you can't accidentally credit two accounts. Reentrancy: Move has historically prevented reentrancy, but Aptos's function values (Move 2.2) make certain forms possible again, so check the Move security guidelines. Integer overflow: arithmetic that overflows or underflows aborts the transaction (left shift is the exception). Approval misuse: there are no token allowances; transfers happen via direct resource movement. These eliminations aren't perfect — sophisticated attacks are still possible — but the baseline safety floor is significantly higher than Solidity.
Why Adoption Has Been Slow
Despite genuine technical merits, Move adoption has lagged Solidity by orders of magnitude. Reasons: existing developer talent is concentrated in Solidity; tooling (debuggers, IDE support, testing frameworks) is more mature on EVM; battle-tested protocols (Uniswap, Aave, Curve) don't exist as Move equivalents that new projects can compose against; the EVM ecosystem's network effects compound. Aptos and Sui have grown but remain ecosystems where you're often deploying the second or third version of common DeFi primitives.
Aptos and Sui's Divergent Strategies
Aptos presents itself around payments, structured finance, DeFi, media and AI/DePIN use cases. Sui presents a modular 'Sui Stack' (Walrus storage, DeepBook liquidity, Seal encryption, Nautilus offchain compute) with industry pages for payments, capital markets, DeFi and AI agents. Both chains have active ecosystems with their own surrounding stacks, sharing Move as the underlying language.
If Evaluating Move-Based Chains, Read the Whitepapers
Move's nuances reward careful reading. The official Move Book, Aptos's white paper, and Sui's documentation explain the design choices in detail. Many criticisms of Move-based chains are based on outdated information or surface-level comparisons. Engaging with the primary sources is the only way to form a substantive view of whether the architectural advantages translate to your specific use case.
Key Takeaways
- Move Prover provides formal verification as part of the Aptos Move toolchain (Sui has a separate Sui Prover)
- Several Solidity bug classes (double-spending, approval misuse, silent integer overflow) are eliminated by design, though Aptos function values reopen some reentrancy
- Adoption lags Solidity by orders of magnitude due to talent, tooling, and ecosystem network effects
- Aptos and Sui position themselves differently — Aptos around payments and structured finance, Sui around its modular Sui Stack
- Engaging with primary documentation is essential for a substantive view of Move-based chains
Related Content
Related Coins
Related Topics
Key Terms
More Topics
Browse all 189 topicsOptimism Bedrock and the Superchain
How OP Mainnet's Bedrock architecture, fault-proof rollout, and Superchain interop strategy reshape Optimism from a single rollup into a widely deployed modular L2 framework (Optimism says 54 mainnet chains ran on the OP Stack as of October 2026).
Base Architecture
How Coinbase's Base L2 launched on the OP Stack and has been moving to its own Base-operated stack, how Coinbase's exchange-side integration drives uniquely smooth UX, what the sequencer's centralised reality means today, and the path to a 'stage-2' rollup.
Linea and Polygon zkEVM Compared
How two zkEVMs — Linea (Consensys) and Polygon zkEVM, whose Mainnet Beta sequencer was sunset on 3 July 2026 — compare on EVM-equivalence levels, prover technology, ecosystem strategy, and what each chain's positioning means for users and developers.
Solana Programs and Anchor
How Solana's account model differs from Ethereum's, why Sealevel enables parallel execution, what makes Solana programs feel different to write, and where Anchor fits.
Cairo and StarkNet Contract Development
How Cairo as a language differs from Solidity and Rust, why account abstraction is native to StarkNet, and what writing production StarkNet contracts actually involves.
CosmWasm and Cosmos Smart Contracts
How CosmWasm enables smart contracts on Cosmos chains via WebAssembly, what makes the developer experience distinct from EVM, and why Cosmos's sovereign-chain architecture is a different bet from rollup-style scaling.
Cardano Plutus and EUTxO Contracts
How Cardano's Extended UTXO (EUTxO) model differs fundamentally from Ethereum's account model, what writing Plutus contracts actually involves, and why concurrency on Cardano works differently.
NEAR Contract Model
How NEAR's sharded execution, async cross-contract calls, and storage staking model differ from Ethereum and Solana — and what writing production NEAR contracts looks like.
References & further reading
- primary
- secondary
- primaryAptos - Blockchain Execution (Block-STM)
How Aptos executes blocks in parallel without access lists.
- primaryAptos - Move Security Guidelines
Integer behaviour and reentrancy with function values.