suideveloper
Get started
All questions
Sui Move

What is Sui Move?

November 4, 2026

Sui Move is the smart contract language of Sui: the Move language, originally built for the Diem project, adapted to Sui's object model. You write modules that define types and functions, publish them as a package, and call them from transactions. The main change from the original Move is storage. Sui has no global storage keyed by account. Data lives in objects, each with a unique ID and an owner tracked by the system, and the code that uses them is written in the current Move 2024 edition.

What Move gives you

Move is a statically typed, bytecode-verified language designed for digital assets:

  • Resources can't be copied or dropped by accident. A type has only the abilities (copy, drop, store, key) you declare. A coin without copy can't be duplicated, and a value without drop must be used before the transaction ends.
  • Modules own their types. Only the module that defines a struct can create it, unpack it or read its fields directly. Other code goes through the functions the module exposes.
  • The verifier runs at publish time. Bytecode is checked for type, reference and resource safety before it goes on chain.

What Sui changes

  • Objects instead of global storage. A struct with key and a first field id: UID is an object. It can be owned by an address, shared, frozen, or wrapped inside another object. The original Move's global storage operators (move_to, borrow_global and the rest) don't exist on Sui.
  • 32-byte addresses. Addresses and object IDs share the same 32-byte space.
  • Explicit inputs. Transactions list the objects they touch, so transactions that don't share objects can run in parallel.
  • Module initializers. An init function runs once when the package is published, typically to create admin capabilities or shared objects. See How does the init function work in Sui Move?.
  • Sui-specific patterns. One-time witnesses, Publisher, dynamic fields, TxContext, Clock and on-chain randomness are all part of the Sui framework.
  • Transactions compose on the client. Calls are chained in programmable transaction blocks instead of through contract wrappers.

A small example

Move
module counter::counter;

public struct Counter has key {
    id: UID,
    value: u64,
}

/// Create a shared counter anyone can increment.
public fun create(ctx: &mut TxContext) {
    transfer::share_object(Counter { id: object::new(ctx), value: 0 })
}

public fun increment(c: &mut Counter) {
    c.value = c.value + 1;
}

public fun value(c: &Counter): u64 {
    c.value
}

UID, object, transfer and TxContext are available without use statements, because the 2024 edition imports them implicitly. Build and test with the CLI:

Terminal
sui move new counter
sui move build
sui move test

Then publish the package and call increment from the CLI, the TypeScript SDK or the playground on testnet.

Sui Move vs "Move" elsewhere

Aptos and other chains also use Move. The core ideas carry over (abilities, modules, generics, the verifier), but the storage model, standard libraries and language editions have diverged. Code isn't portable between them without rewriting. See How is Sui Move different from Aptos Move and core Move?.

Where to learn

The Move Book is the reference for Move on Sui and uses the 2024 edition throughout. For a learning path, see What is the best way to learn Sui Move?.

Sources