Move is the programming language that treats digital assets like they’re real things you could drop on your foot. It’s strongly typed, resource-oriented, and designed so tokens, NFTs, and capabilities can’t accidentally vanish in a puff of “whoops.” Born at Facebook’s Diem project and now powering chains like Aptos and Sui, Move aims to make smart contracts less “hold my beverage” and more “sir, please step away from the production wallet.”
If you want the official deep dives, start with The Move Book, the original Move paper, Aptos Move, the Move Prover guide, and Sui Move concepts. And if you want something you can actually hang on your wall (or your hoodie), here’s the latest drop from the studio: DaveLumAI on Redbubble.
What is it?
Move is a smart-contract language with “resource types.” In plain English: it encodes the idea that some values (coins, NFTs, permissions) are unique, can’t be duplicated by accident, and must be explicitly moved, not copied. The type system and bytecode verifier enforce these rules before your code ever runs. Think of it as strict bouncers at the door of your state transitions — polite, but firm.
Is it still relevant?
Yes. After Diem, Move found new life as the core language of Aptos and Sui, and it’s used in production today. Both ecosystems actively ship tooling, training, and improvements (see Sui’s Move intro course).
Pros and cons (a snack-sized tasting menu)
Pros
- Resource safety by design: No accidental double-spends or “copy-pasted money.”
- Formal verification: Move Prover lets you specify and prove properties about your code.
- Modular & platform-agnostic: The language is adaptable; chains can extend data models.
- Auditor-friendly semantics: Clear rules around ownership and abilities (
key,store,copy,drop).
Cons
- Ecosystem fragmentation: Aptos Move and Sui Move differ in details; porting isn’t always copy-paste bliss.
- New-ish ecosystem: Fewer third-party libraries than Solidity land.
- Learning curve: The resource mindset is a shift if you’re coming from “just structs and vibes.”
Strengths and weaknesses
Strengths: Safety, predictable asset semantics, first-class verification, explicit module scoping, and fine-grained capabilities.
Weaknesses: Smaller ecosystem, divergent chain dialects, and fewer battle-scars compared to Ethereum’s decade of “we survived that?”.
What is it used for?
Anything where “ownership” matters: fungible tokens, NFTs, permissioned actions, custody workflows, DeFi primitives, on-chain games with inventories, and mint/burn flows that shouldn’t explode on contact with reality.
Can you give me an example?
Here’s a tiny (and very incomplete) taste of Move’s “resource” flavor — minting and transferring a coin type under a capability:
module 0xCAFE::coffee_coin {
use std::signer;
/// A resource type representing our coin supply capability.
struct MintCap has key { admin: address }
/// A resource type representing the coin itself.
struct COFFEE has store { value: u64 }
/// Initialize the module by publishing a MintCap to the deployer.
public entry fun init(owner: &signer) {
let cap = MintCap { admin: signer::address_of(owner) };
move_to<MintCap>(owner, cap);
}
/// Mint new coins; only the address holding MintCap can call this.
public entry fun mint(owner: &signer, recipient: address, amount: u64) {
let cap = borrow_global<MintCap>(signer::address_of(owner));
assert!(signer::address_of(owner) == cap.admin, 0);
let c = COFFEE { value: amount };
// deposit into recipient's balance (left as an exercise)
// e.g., a table or object-based balance per address
// store_coin(recipient, c);
// For demo purposes, we avoid chain-specific storage APIs here.
let _ = c; // prevent unused variable warning in this minimal example
}
/// Transfer requires explicitly moving the resource.
public fun transfer(c: COFFEE, to: address): COFFEE {
// real code would update per-address storage, then return/change state
let _ = to;
c
}
}
Move’s rules prevent you from duplicating COFFEE or dropping it on the floor. You must move it or deliberately destroy it.
What are the alternatives?
- Solidity/Vyper: Dominant in EVM land; huge tooling and liquidity.
- Rust (Solana, Near, CosmWasm): Performance and mature ecosystem; different mental model.
- Cairo (Starknet): ZK-native focus.
- Ink! (Polkadot): Rust-based for Wasm chains.
Is it the subject of any famous art?
Not yet, unless your idea of “gallery” is a GitHub org and your curator is a linter. (Banksy, call us.)
How popular is it? Up or down? When was it hottest?
Developer activity surged after Aptos and Sui launched, with steady growth through 2024–2025 (see Electric Capital’s developer dashboards for Aptos). Momentum remains strongest where Move has first-class support and grants.
What’s its history? Who invented it?
Move emerged from the Diem (formerly Libra) project. The seminal paper by Sam Blackshear and team describes programmable resources and the verifier model. After Diem sunset, Move evolved in open ecosystems led by Aptos Labs and Mysten Labs (Sui).
Is it similar to anything else?
Conceptually, it rhymes with Rust’s ownership and linear types but is purpose-built for digital assets and on-chain safety. The “abilities” system (copy/drop/store/key) makes capabilities explicit instead of relying on conventions.
Does it work well with AI?
Yes — indirectly. Move’s strict semantics make static analysis and automated reasoning (tests, fuzzers, and the Move Prover) more effective. AI-assisted audits benefit from specs the Prover can check, turning “this should be safe” into “we proved it.”
What tech stack does it work with?
- Aptos toolchain: CLI, framework, Move package manager, Move Book, and SDKs.
- Sui toolchain: Sui CLI, object-centric APIs, Sui Move concepts, and a hands-on intro course.
- Editors: VS Code Move Analyzer, language servers, formatters.
- Verification: Move Prover.
How much is it going to cost me?
The language and tools are free; your costs are chain fees and time. Aptos explains fee mechanics in its Gas & Storage Fees and Base Gas docs. Sui’s fee model (compute + storage with rebates) is detailed in Gas Pricing and Gas in Sui. Translation: optimize your contracts and you’ll pay cents, not kidneys.
Any other interesting tidbits?
- Spec language: You can attach formal specs right next to code; the Prover checks them.
- Upgradeable patterns: Capabilities and module addresses keep upgrades explicit rather than magical.
- Chain dialects: Sui extends the model with first-class objects; Aptos focuses on accounts + resources — same melody, different arrangement.
Question for you: What’s the spiciest bug you’ve seen in a token contract — any chain, any language? Drop it in the comments, then hit Follow for more deep dives, dev laughs, and AI mischief.
Art Prompt (Abstract Expressionism): A luminous field of stacked, breathing color bands that hover like mist — deep carmine sinking into ember orange, then dissolving into a tranquil, blue-violet horizon. Edges are feathered and soft, with subtle drips and scumbles along the borders. The canvas feels meditative and immense, inviting quiet contemplation. The surface carries velvety matte passages interrupted by thin, translucent glazes that let underlayers glow through, evoking cathedral-like stillness.
Video Prompt: Begin with a blank wall that gently inhales and exhales. With each breath, broad bands of color fade in and out, swelling and receding as if painted by invisible hands. Soft texture blooms at the margins, micro-ripples travel across the surface, and occasional pigment “flares” pulse to the beat. Midway, the palette shifts from warm embers to cool twilight, then brightens in a final crescendo of saturated hue before settling into a calm, glowing afterimage. Loop seamlessly with a subtle luminance flicker.
Two songs to score the video:
- Tessellate — alt-J
- Cold Little Heart — Michael Kiwanuka
