How Sui Move Primitives Differ

Sui Move primitives operate on a fundamentally different architecture than EVM accounts. Instead of treating accounts as the primary unit of storage, Sui centers its model on objects. This shift changes how data is structured, accessed, and transferred on the blockchain.

In the EVM, an account holds a balance and storage slots. To move value, you update that account's state. On Sui, every asset—whether it is an NFT, a token, or a custom data structure—is an independent object. Each object has a unique ID, type, and owner. This means assets are not tied to a specific account address by default; they exist as discrete entities that can be moved between addresses or held in shared storage.

This object-centric approach enables parallel execution. Because objects are distinct, transactions that interact with different objects do not conflict. The network can process these transactions simultaneously, increasing throughput. In contrast, EVM accounts often create bottlenecks when multiple transactions target the same account, as they must be processed sequentially to maintain state consistency.

The result is a system where data ownership is explicit and granular. Developers build with objects as the core building blocks, allowing for more flexible composability and higher performance. This model supports complex DeFi interactions that would be difficult to optimize on an account-based chain.

Core data types and abilities

Sui Move Primitives works best when the purchase path is explicit. Verify the source, compare the offer against real alternatives, check the total cost, and confirm what happens after payment before you decide. After each comparison, write down the one risk that would change your mind. If the seller, condition, support, warranty, shipping, or upkeep still feels uncertain, resolve that question before moving to checkout.

The simplest way to use this section is to verify the seller, compare the total cost, and resolve the biggest risk before you commit.

Objects as the primary asset unit

Sui Move replaces the traditional account-based model with an object-centric architecture. In most blockchains, accounts serve as the primary container for value, requiring a complex system of internal mappings to track individual assets. Sui inverts this structure: objects are the fundamental units of ownership and identity. This shift allows the network to treat every unique asset as a first-class citizen rather than a line item in a ledger.

Each object in the Sui Move ecosystem is assigned a globally unique identifier. This ID is derived from the object’s type, content, and the address of its creator. Because the identifier is intrinsic to the object’s data, there is no need for a centralized registry to verify uniqueness. The blockchain itself guarantees that no two objects can share the same ID, creating a robust foundation for digital scarcity and provenance.

This design enables objects to be moved, transferred, or modified independently of other assets. Unlike account-based systems where transfers often require updating global state for multiple parties, Sui objects can be processed in parallel. This parallelism is possible because each object carries its own ownership rules and access control lists, allowing the network to validate transactions without coordinating across the entire state.

The result is a system where value is not just stored, but actively managed through its container. Developers can build applications that interact directly with these unique objects, leveraging their inherent properties for everything from non-fungible tokens to complex financial instruments. This approach simplifies the underlying logic while increasing the flexibility of on-chain interactions.

Sui Move Primitives in

Parallel execution and concurrency

Sui’s object-centric model changes how transactions are processed. Instead of treating the ledger as a single, shared state that must be updated one item at a time, Sui breaks data down into independent objects. Each object has a unique ID and can be owned by an account, another object, or a group. This structure allows the network to process multiple transactions simultaneously, provided they do not interact with the same objects.

Think of the ledger like a library. In a traditional blockchain, every transaction is a single reader checking out books one by one, blocking the line for everyone else. In Sui, the library has multiple checkout desks. If Reader A wants to check out "Book X" and Reader B wants "Book Y," they can do so at the same time because their requests don’t conflict. Only when two readers want the same book does the system pause to decide who goes first.

This parallel execution is the core driver of Sui’s high throughput. For DeFi applications, this means trades, swaps, and liquidity movements can happen in bursts without clogging the network. The Move language enforces strict rules on object access, ensuring that even when transactions run in parallel, data integrity remains intact. Developers can build complex financial products that rely on speed and low latency, knowing the underlying architecture supports concurrent processing.

The result is a blockchain that scales horizontally. As demand increases, the network handles the load by executing non-conflicting transactions in parallel rather than forcing them into a single linear sequence. This efficiency reduces gas fees during peak times and provides a smoother experience for users interacting with DeFi protocols.

Building DeFi with Sui Primitives

Sui Move shifts DeFi architecture from account-based ledgers to object-centric design. This change allows protocols to treat assets like lending pools or liquidity positions as distinct, ownable entities rather than just balances in a shared account. The result is higher composability and parallel execution, as transactions can interact with different objects simultaneously without conflicting.

Lending Protocols as Objects

In traditional DeFi, lending positions are often tracked as state within a contract’s storage. On Sui, a lending position becomes an object. When you supply assets, you receive a unique position object that represents your claim. This object can be transferred, used as collateral in another transaction, or even bundled into an NFT. This structure simplifies collateral management and reduces the complexity of tracking user states across the network.

DEXs and Liquidity Pools

Decentralized exchanges on Sui handle liquidity differently. Instead of a single global pool address, liquidity is often represented by specific pool objects. When a user adds liquidity, they mint a new LP token object that proves their share. This object-centric approach allows for more flexible pool configurations and easier integration with other protocols. Users can trade directly against these objects, enabling atomic operations that would be difficult to replicate in account-based systems.

Cross-Protocol Composability

The object model shines in cross-protocol interactions. Since every asset and position is an object, it can be passed directly between protocols in a single transaction. A user can swap tokens, add liquidity, and borrow against the new position in one atomic step. This reduces the risk of partial execution and simplifies the user experience by eliminating the need for multiple separate transactions.

Common questions about Sui Move

Developers transitioning to Sui often ask how the object-centric model changes their workflow. The core difference is that assets are first-class objects with explicit ownership, rather than balances linked to addresses. This shift simplifies composability and reduces common smart contract vulnerabilities.

How does object ownership work in Move?

In Sui Move, every asset is an object with a unique ID and explicit ownership. Ownership is either held by a single address, shared among all addresses, or locked in a struct. This explicit model prevents the "double-spend" risks found in account-based chains and makes tracking assets straightforward.

Is Move the same as Solidity?

No. Move is designed for safety and asset-centric logic, while Solidity uses an account-based model. Move’s type system enforces strict ownership rules at compile time, making it harder to accidentally lose or corrupt assets. The syntax is similar, but the underlying mechanics of how data is stored and transferred are fundamentally different.

Can I migrate from EVM to Sui Move?

Direct migration is not possible due to the architectural differences in storage and execution. However, the logic can be ported. Developers must rewrite contracts to handle objects instead of balances and adjust for Sui’s parallel execution model. The move-core library provides utilities to ease this transition for common DeFi patterns.