Move

Move is a statically typed, resource-oriented programming language for writing smart contracts and on-chain transaction logic. Its defining idea is that digital assets can be represented directly in the type system as resources — values that, by the rules of the language, can never be copied and can never be silently discarded. They can only be moved from one place to another, which is where the language gets its name. This single constraint, borrowed from the world of linear and substructural type theory, turns a whole category of expensive blockchain bugs — double-spends, accidentally destroyed funds, duplicated tokens — into programs that simply will not compile or will not pass on-chain verification.

Move was created inside Facebook (Meta) for the Libra blockchain, announced in 2019. Libra was renamed Diem and ultimately abandoned, but the language outlived its birthplace: today it is the smart contract language of two prominent Layer 1 blockchains, Aptos and Sui, both founded by engineers who had worked on Diem.

History & Origins

In June 2019, Facebook unveiled an ambitious plan for a global payments network built on a new blockchain called Libra. Writing safe financial software on existing smart contract platforms was known to be perilous — Ethereum’s Solidity had been the source of high-profile, multi-million-dollar exploits where the underlying problem was that “money” was just a number in a mapping, with no language-level protection against duplicating or losing it. The Libra team, led on the language side by Sam Blackshear, set out to design a language where assets were first-class and where the most dangerous mistakes were structurally impossible.

The team studied Rust closely — Move’s ownership and move semantics are visibly indebted to Rust and to C++11’s move semantics — but concluded that no existing language gave them exactly the properties they needed for programmable money. The result was Move, described in the 2019 white paper Move: A Language With Programmable Resources and the follow-up research paper Resources: A Safe Language Abstraction for Money (2020).

Libra was renamed Diem in December 2020 amid intense regulatory pressure, and the Diem Association wound down in January 2022, selling its assets to Silvergate Bank. By then, however, the people who had built Move had begun to scatter into new ventures — and they took the language with them. Aptos launched its mainnet in October 2022, and Sui followed in May 2023, each carrying a distinct flavor of Move.

Design Philosophy

Move’s design grows from one central conviction: the language, not the programmer, should enforce the conservation of value.

Resources as linear types

In most languages, a value can be freely copied (assign it twice) or dropped (let it go out of scope). Money does not work that way: you cannot photocopy a coin, and a coin should never vanish by accident. Move encodes this directly. A struct declared with the key/store abilities but without copy or drop is a resource. The type system guarantees a resource is used exactly once along every path — it must be explicitly stored, transferred, or destructured. Trying to overwrite or implicitly discard a resource is a compile-time error. This is a practical application of linear (substructural) typing, where the “structural rules” that normally let you duplicate or discard values are deliberately removed.

Abilities

Move generalizes this with a system of four abilities that a type may or may not have:

An ordinary integer has copy and drop; a coin resource typically has neither. By choosing which abilities a type carries, a programmer precisely specifies what may and may not happen to it.

Modules and encapsulation

Code and data in Move live in modules, which are published to global storage at an account address. Critically, only the module that defines a resource type can create, destroy, or directly access its fields. This gives every asset a single, auditable authority over its own invariants — the analog of a class with strictly private internals, enforced at the verifier level rather than by convention.

Verify, then execute

Move source compiles to a compact, typed bytecode. Before any module can be published or run, it must pass the Move bytecode verifier, an on-chain static analysis that re-checks type safety, reference (memory) safety, and resource safety on the bytecode itself — independent of the source compiler. Nothing executes until it has been proven well-behaved by this verifier, so even maliciously hand-crafted bytecode cannot bypass the safety rules.

Key Features

• Resource types that cannot be copied or dropped, giving assets the semantics of physical objects.
• Abilities (copy, drop, store, key) for fine-grained control over what can happen to each type.
• First-class global storage addressed by account and type, with module-controlled access.
• A bytecode verifier that enforces type, memory, and resource safety on-chain before execution.
• Generics with ability constraints, allowing reusable, type-safe abstractions over resources.
• The Move Prover, a formal verification tool that lets developers write machine-checkable specifications (pre/postconditions, invariants) and prove properties of their code.
• Platform-tunable storage models — Aptos stores resources under accounts, while Sui treats each asset as an addressable object — built on a shared core language.

A small flavor of the syntax:

module my_addr::coin {
    /// A resource: no `copy`, no `drop` — it can only be moved.
    struct Coin has store {
        value: u64,
    }

    public fun mint(value: u64): Coin {
        Coin { value }
    }

    /// Combine two coins into one; both inputs are consumed.
    public fun merge(a: Coin, b: Coin): Coin {
        let Coin { value: a_val } = a;   // destructure consumes `a`
        let Coin { value: b_val } = b;   // and `b`
        Coin { value: a_val + b_val }
    }
}

Because Coin lacks the drop ability, a function that received a Coin and simply ignored it would fail to compile — the value has to go somewhere.

Evolution

Move began as a single language with one virtual machine, but its diaspora produced dialects. Aptos Move keeps the original account-centric storage model, in which resources are stored under user accounts. Sui Move reorganizes the world around objects: every asset is an object with a globally unique ID and an explicit owner, a model that enables Sui to execute non-conflicting transactions in parallel. The two share a common ancestry and much syntax, but differ enough that contracts are generally not portable between them without changes.

The biggest leap in the core language arrived with the Move 2024 edition (and Aptos’s parallel Move 2.x line) in 2024, which added long-requested features such as enum types, macro functions, method-call (receiver) syntax like value.func(arg), index notation, positional structs, and richer pattern matching with wildcard patterns. These additions modernized the developer experience considerably while preserving the resource-safety guarantees at the heart of the language.

Current Relevance

Move occupies a specific but growing niche: it is one of the leading “safety-first” alternatives to Solidity in the smart contract world. Its two flagship platforms, Aptos and Sui, are well-funded Layer 1 blockchains with active developer ecosystems, and additional projects such as Movement Labs aim to extend Move’s reach into the broader modular and Ethereum-adjacent landscape. The language continues to evolve, the Move Prover keeps formal verification within practical reach for ordinary contract authors, and tooling — compilers, package managers, IDE support, and test frameworks — has matured well beyond its experimental origins.

Why It Matters

Move is a rare example of a language whose central feature is a deliberate restriction — the inability to copy or discard certain values — and whose entire value proposition flows from that restriction. By lifting decades-old ideas from linear logic and substructural type theory into a practical, deployable language, it offered a concrete answer to one of blockchain’s most painful questions: how do you make digital money behave like real money, where it cannot be forged or accidentally annihilated? That it survived the collapse of the very project it was built for — Facebook’s Diem — and went on to anchor multiple independent blockchains is the strongest testament to the durability of its core idea. Whatever becomes of any single chain, Move stands as an influential demonstration that the type system can be a frontline defense for high-stakes financial code.

Sources: Move (programming language) — Wikipedia, Diem (digital currency) — Wikipedia, Resources: A Safe Language Abstraction for Money (arXiv 2004.05106), Sui AMA: The Move Programming Language with Sam Blackshear, Move Adds Enums and Macros in 2024 Edition (Sui Blog), The Move on Aptos Book — Language Versions, Aptos Blockchain Goes Live on Mainnet (CoinDesk).