What is Move language?
A programming language for blockchains in which digital assets are first-class values that cannot be copied or accidentally discarded, enforced by the type system rather than by contract logic.
Not yet verifiedHow we verify
3 min read
In this entry
A programming language for blockchains in which digital assets are first-class values that cannot be copied or accidentally discarded, enforced by the type system rather than by contract logic.
It was created for Meta's Diem project and now underpins Aptos and Sui, each with its own dialect (source: the Move language documentation). You meet the name when reading about either chain, and occasionally in comparisons with Solidity.
The design goal is to make a whole class of asset bugs unrepresentable, where an erc 20 balance is just a number in a mapping that a bug can duplicate. Understanding it does not require writing any code, but it explains why supporters of these chains talk about safety as a language property rather than an auditing outcome.
How it works
Move borrows the idea of linear types from research languages. A value marked as a resource has two restrictions enforced by the compiler: it cannot be copied, and it cannot be dropped. It can only be moved from one place to another, which is where the language gets its name.
A coin balance declared as a resource therefore cannot be duplicated by an arithmetic mistake, and it cannot vanish because a function forgot to store it. Code that tries either fails to compile rather than shipping and failing later.
The contrast is instructive. In a typical Solidity token, balances are entries in a mapping from address to integer. Nothing at the language level distinguishes that integer from any other, so double-crediting is a logic error the language happily allows and an auditor must catch by reading.
Move also uses a module system where types are owned by the module that declares them, so only that module's code can create or destroy its resources. Aptos and Sui diverge in how they model storage: Aptos keeps resources under accounts, while Sui treats objects as first-class with explicit ownership, which is what enables its parallel execution.
Example
Illustrative comparison of the same mistake in two languages.
| Situation | Mapping-based token | Move resource |
|---|---|---|
| Code credits a balance twice | Compiles and runs, supply inflates | Not expressible, a resource cannot be copied |
| A function returns without storing a value | Compiles, value silently lost | Fails to compile |
| Who can create units | Any code with mapping access | Only the declaring module |
None of this prevents a developer from writing a module that mints freely on purpose. It prevents the accident, not the intent.
Why it matters when you buy
This is background rather than a buying input. It matters if you hold assets on Aptos or Sui, because the wallet, address, and token account model differ from Ethereum, and moving assets to and from an exchange follows different conventions. Which venues support these networks for deposits and withdrawals is recorded at the exchange directory, and the per-chain measurements are on the chain rankings.
Related terms
- smart contract — what Move is used to write
- erc 20 — the mapping-based contrast case
- parallel execution — what Sui's object model enables
- smart contract audit — still required regardless
- evm — the alternative execution environment
- protocol — the layer above the language
Questions
Does Move make a chain safer to use?
It removes one category of bug at compile time, which is real but narrow. Most losses in practice come from application logic, key management, and bridges, none of which a type system addresses.
Do I need a different wallet for Aptos or Sui?
Yes. Both use their own address formats and signing conventions, so an Ethereum wallet will not hold them. Check that your exchange supports withdrawal to the specific network before buying.
Is Move related to Rust?
Its syntax is Rust-influenced and its ownership thinking is similar, but it is a separate language with a bytecode verifier designed for on-chain execution.