Crypto Gloss

Move Language

Move is a programming language for blockchains that fundamentally rethinks how digital assets should be represented in code. The key insight: in Solidity, tokens are just numbers in a mapping — balances[alice] = 100. A bug that increments the wrong number can create tokens from thin air or destroy them. In Move, tokens are resources — they obey linear type theory, meaning they can only be moved, never copied or silently discarded. If a Move program tries to “lose” an asset, it crashes at compile time. This isn’t just a safety improvement — it’s a paradigm shift in how developers reason about financial logic. Originally designed by a team at Facebook/Meta (Diem blockchain), Move now lives on in two major blockchains: Aptos (using the original “pure Move” execution model) and Sui (using “Sui Move” with an object-centric model). Both are top-10 blockchains by developer activity and TVL as of 2025.

Background: Move at Facebook/Diem

Move was created in 2019 by a team at Facebook Research (Sam Blackshear, principal author) for the Libra/Diem project — Facebook’s attempt to build a global payment stablecoin.

Design goals for Diem’s use case (payments):

  • No accidental asset duplication (can’t accidentally double-count payments)
  • No reentrancy attacks (payment logic must be linearizable)
  • Formally verifiable (regulators and auditors could mathematically verify contract behavior)
  • Expressive enough for complex financial logic

When Diem was killed by regulators (2021–2022): The Move engineers left Meta and some founded Aptos (Sam Blackshear, Mo Shaikh, Avery Ching), while others helped bootstrap Sui’s Move dialect (Mysten Labs, including Evan Cheng, Adeniyi Abiodun, Sam Blackshear also consulting).

Core Concept: Resources and Linear Types

The following sections cover this in detail.

The Problem Move Solves

Solidity’s token representation:

“`solidity

mapping(address => uint256) public balances; // Just a number

function transfer(address to, uint256 amount) {

balances[msg.sender] -= amount; // Bug: can underflow

balances[to] += amount; // Bug: can overflow; no guarantee amount was deducted first

}

“`

The reentrancy vulnerability (responsible for >$500M in hacks) stems from Solidity calling external contracts in the middle of state changes — which can re-enter your function before you subtract the balance.

Move’s Resource Model

In Move, a token exists as an actual data structure (“resource”) that must obey the linear type rule:

“`move

struct Coin has key {

value: u64

}

public fun transfer(coin: Coin, recipient: address) {

// coin is MOVED inside this function

// The caller no longer has it after calling transfer

// The compiler enforces this at compile time

move_to(recipient, coin); // coin now owned by recipient; caller has nothing

}

“`

Linear type rules:

  • Cannot duplicate: You can’t use a resource variable twice (copying is compile error)
  • Cannot discard: You can’t let a resource go out of scope without storing it (dropping is compile error)
  • Can only move: Transfer ownership; the previous holder loses access

This makes the entire class of “double-spend” and “token creation from thin air” bugs impossible by construction — the compiler catches them, not runtime or auditors.

Formal Verification: The Move Prover

Move ships with a formal verifier — the Move Prover (MSP):

  • Write specifications as properties your contract must satisfy (invariants, pre/post conditions)
  • Run the prover: it mathematically proves whether your contract satisfies those properties for ALL possible inputs
  • Not fuzzing or test coverage — mathematical proof

Example specification:

“`move

spec transfer {

ensures old(coin.value) == receiver.value + sender.remaining;

// Proves: conservation of value — no coins created or destroyed

}

“`

The Aptos team regularly uses the Move Prover to prove properties of their Move standard library. Formal verification tools this integrated are unique in blockchain — Ethereum’s solc compiler has no equivalent.

Aptos vs. Sui: Two Move Dialects

Both use Move but with different programming models:

Aptos Move (Original / Pure Move)

Account-centric model:

  • Assets stored in user accounts (similar to Ethereum but with resources)
  • Addresses hold resources in a “global storage” (like a flat key-value store per address)
  • move_to(address, resource) and move_from(address) are the primitives
  • More similar to original Diem Move; familiar for coming from Ethereum

Parallelism: Aptos uses Block-STM for parallel transaction execution — transactions that don’t touch the same accounts execute simultaneously; massive throughput advantage

Language: Aptos Move (faithful to original design)

Sui Move (Object-Centric)

Object model (key differentiator):

  • Objects are the primary data unit — each with a unique ID, owner, and type
  • Object kinds: Owned (by address), Shared (by transaction consensus), Immutable (read-only)
  • Transactions declare which objects they access → Sui can parallelize non-conflicting transactions at the execution level (not just account level)

Advantages of object model:

  • Natural fit for NFTs (each NFT IS an object with unique ID)
  • Easier to reason about ownership (object has exactly one owner except shared objects)
  • Enables “single-owner transactions” that bypass consensus entirely for owned objects (extremely fast, no validator voting needed)
  • Kiosk system: Natural marketplace primitive for object trading

Trade-off: Object model requires explicit input declaration (all objects used in a transaction listed upfront); more complex than Ethereum-style programming; harder to write some global-state DeFi patterns

Key Language Features

Modules: Packages of functions and types (similar to Rust crates / Solidity contracts)

Structs with abilities:

  • key — can be stored in global storage
  • store — can be stored inside other structs
  • copy — can be duplicated (NOT for assets — only non-financial data)
  • drop — can be discarded (NOT for assets)

Financial assets are structs with only key and store — no copy, no drop. This is the type system enforcement.

Generics: Move supports generic types for composable financial primitives (like Rust generics)

Events: Emittable from transactions; indexed by indexers (similar to Ethereum events)

Entry functions: Public entry points callable from transactions; enforced visibility boundary

Ecosystem and Adoption

Aptos (APT):

  • Mainnet: October 2022
  • Backed by a16z, Multicoin, FTX Ventures (pre-collapse), others
  • ~$850M raised in funding
  • Growing DeFi ecosystem: Liquidswap, Thala, Joule Finance
  • Aptos Labs building enterprise integrations (Microsoft Azure partnership for verifiable credentials)

Sui (SUI):

  • Mainnet: May 2023
  • Mysten Labs backed by a16z, FTX Ventures (pre-collapse), Coinbase Ventures
  • ~$336M raised
  • Sui gaming and NFT ecosystem particularly active: Sui Kiosk, DeepBook (native CLOB)
  • SuiPlay0X1 (Sui gaming handheld gaming device announced 2024)

Move VM: The Move Virtual Machine is being adapted for other environments:

  • Movement Network: Bringing Move to Ethereum-compatible chains
  • Linera: Another Move-based chain targeting micro-chains

Comparison: Move vs. Solidity vs. Rust

Feature Move Solidity Rust (Solana)
Asset model Linear resource types Mappings/integers Custom (SPL token standard)
Reentrancy risk None (by design) High (classic vulnerability) None (borrowing model)
Formal verification Built-in (Move Prover) External (Certora, etc.) Limited
Learning curve Moderate-steep Moderate Very steep
Key blockchains Aptos, Sui Ethereum, Base, nearly all EVMs Solana
Compilation Move bytecode (MoveVM) EVM bytecode BPF bytecode
Composability Module system Interface/ABI CPI (Cross-Program Invocation)

Social Media Sentiment

Move as a language has earned significant respect in the developer community for its safety properties. Security researchers frequently note that Move eliminates whole categories of smart contract vulnerabilities that audit firms spend hours looking for in Solidity. Aptos and Sui have both attracted substantive developer communities though neither has unseated Solana or Ethereum in mindshare. Sui has particular traction in gaming and NFTs (object model is very natural for gaming assets). Movement Network’s attempt to bring Move to EVM chains represents the “best of both worlds” approach — Move safety with Ethereum liquidity. The formal verification story is compelling for institutional adoption but rarely highlighted in retail-facing communication. The Diem backstory (everyone is building on a “failed Facebook project”) is both a liability (stigma) and an asset (the design process involved enormous resources and talent from a major tech company with high stakes).

Last updated: 2026-04

Related Terms

Sources

Blackshear, S., Cheng, E., Dill, D.L., Gao, V., Maurer, T., Motheramgari, K., Nowacki, T., Paler, L., Park, S., Qadeer, S., Senanayake, R., Sin, T., Xu, K., & Zhou, T. (2019). Move: A Language With Programmable Resources. Meta Research / Diem Technical Report.

Dill, D.L., Gao, V., Qadeer, S., & Xu, K. (2022). The Move Prover. Springer International Journal on Software Tools for Technology Transfer.

Spiegelman, A., Giridharan, N., Sonnino, A., & Kokoris-Kogias, L. (2022). Bullshark: DAG BFT Protocols Made Practical. ACM CCS 2022.

Gelashvili, R., Spiegelman, A., Xiang, Z., Danezis, G., Li, Z., Xia, Y., Zhou, J., & Malkhi, D. (2022). Block-STM: Scaling Blockchain Execution by Turning Ordering Curse into a Performance Blessing. arXiv:2203.06871.

Grossman, D., Morrisett, G., Jim, T., Hicks, M., Wang, Y., & Cheney, J. (2002). Region-Based Memory Management in Cyclone. ACM SIGPLAN Notices (PLDI 2002).