Sui Development: Next-Generation Blockchain Built for Performance

Why Sui? Reimagining Blockchain from First Principles

Sui represents a fundamental rethinking of blockchain architecture. While most chains iterate on Ethereum's account model, Sui's engineering team at Mysten Labs (ex-Meta/Facebook Novi) designed from scratch using insights from building Diem. The result: a blockchain that processes over 297,000 transactions per second in testing, with sub-second finality and gas fees measured in fractions of a cent.

The secret is parallel execution. Traditional blockchains process transactions sequentially—even if two transactions don't interact, they wait in line. Sui's object-centric model identifies independent transactions and processes them simultaneously across validator cores. For applications with many users performing non-conflicting actions (games, NFT mints, social interactions), this parallelization delivers exponential throughput gains.

What makes Sui exceptional for developers is the Move programming language. Originally created for Diem, Move provides memory safety, resource scarcity, and formal verification capabilities that Solidity lacks. Move's type system prevents entire classes of vulnerabilities that plague Ethereum contracts—no reentrancy attacks, no integer overflows, no accidentally locked funds. For teams building serious financial infrastructure, these safety guarantees are transformative.

• Parallel execution: 297K TPS in testing, processes independent transactions simultaneously across cores.
• Move language: Memory-safe, resource-oriented programming with formal verification capabilities.
• Gaming infrastructure: Unity/Unreal SDKs, object composition, VRF randomness built-in for blockchain games.
• World-class team: Mysten Labs (ex-Meta Novi engineers), backed by a16z, Binance Labs, top-tier VCs.

What We Build on Sui

Sui Development Process

1. Phase 1 - Move Contract Architecture: Design object-centric data models, implement Move packages with proper resource patterns, leverage capabilities for access control, and use formal verification for critical logic. Establish foundation that maximizes parallel execution.
2. Phase 2 - Core Application Development: Build frontend with @mysten/dapp-kit React hooks, implement wallet integration supporting all major Sui wallets, handle programmable transaction blocks (PTBs) for complex workflows, and manage gas objects correctly.
3. Phase 3 - Object Management & Indexing: Implement efficient object queries using dynamic fields, build custom event indexing for historical data, optimize for Sui's object model with proper caching strategies, and handle owned vs shared object trade-offs.
4. Phase 4 - Gaming/Advanced Integration: Integrate Unity/Unreal SDKs for gaming projects, implement transfer policies and Kiosk standard for marketplaces, leverage object composition for programmable assets, and optimize for mainnet deployment with security review.

Sui Development Timeline: Blockchain Gaming Marketplace

Sui-Specific Development Patterns

Here's what makes Sui development unique with Move and object-centric architecture:

// Move prevents entire classes of Solidity vulnerabilities
module my_game::sword {
    use sui::object::{Self, UID};
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};

    // Resources have "abilities" defining their behavior
    struct Sword has key, store {
        id: UID,
        strength: u64,
        // No "copy" ability - swords can't be duplicated
        // No "drop" ability - swords can't be destroyed accidentally
    }

    // Mint a new sword - only callable by module owner
    public entry fun mint(strength: u64, ctx: &mut TxContext) {
        let sword = Sword {
            id: object::new(ctx),
            strength,
        };

        // Transfer to transaction sender
        transfer::transfer(sword, tx_context::sender(ctx));
    }

    // Upgrade sword by consuming weaker sword
    public entry fun upgrade(
        strong_sword: &mut Sword,
        weak_sword: Sword,  // Consumes this sword
    ) {
        let Sword { id, strength } = weak_sword;
        object::delete(id);  // Explicit deletion required
        strong_sword.strength = strong_sword.strength + strength;
    }

    // Move prevents:
    // - Reentrancy (no recursive calls)
    // - Integer overflow (checked by default)
    // - Accidental fund locking (can't forget to handle resources)
    // - Duplicating assets (no copy ability)
}

// Type safety at the language level, not runtime checks

// Compose multiple operations into atomic transactions
import { TransactionBlock } from '@mysten/sui.js';

const purchaseAndEquipItem = async (itemId: string) => {
  const tx = new TransactionBlock();

  // 1. Split coin for payment
  const [coin] = tx.splitCoins(tx.gas, [tx.pure(1000000)]); // 0.001 SUI

  // 2. Purchase item from marketplace
  const [item] = tx.moveCall({
    target: `${PACKAGE}::marketplace::purchase`,
    arguments: [
      tx.object(MARKETPLACE_ID),
      tx.object(itemId),
      coin,
    ],
  });

  // 3. Equip item to player character
  tx.moveCall({
    target: `${PACKAGE}::character::equip_item`,
    arguments: [
      tx.object(PLAYER_CHARACTER_ID),
      item,
    ],
  });

  // 4. Update achievement if first purchase
  tx.moveCall({
    target: `${PACKAGE}::achievements::check_first_purchase`,
    arguments: [tx.object(PLAYER_PROFILE_ID)],
  });

  // Execute all operations atomically
  // If any step fails, entire transaction reverts
  const result = await signAndExecuteTransactionBlock({
    transactionBlock: tx,
    options: {
      showObjectChanges: true,
      showEffects: true,
    },
  });

  return result;
};

// PTBs = complex workflows in single transaction
// No multi-step UX, no intermediate failures

// Sui's object model enables true asset composition
module my_game::character {
    use sui::object::{Self, UID};
    use sui::dynamic_object_field as dof;
    use my_game::sword::Sword;
    use my_game::armor::Armor;

    struct Character has key, store {
        id: UID,
        level: u64,
        // Objects can own other objects via dynamic fields
    }

    // Equip sword as dynamic object field
    public entry fun equip_sword(
        character: &mut Character,
        sword: Sword,
    ) {
        // Attach sword as nested object
        // Sword remains a distinct object, queryable separately
        dof::add(&mut character.id, b"weapon", sword);
    }

    // Equip armor
    public entry fun equip_armor(
        character: &mut Character,
        armor: Armor,
    ) {
        dof::add(&mut character.id, b"armor", armor);
    }

    // Unequip and transfer sword to another player
    public entry fun unequip_sword(
        character: &mut Character,
        recipient: address,
    ) {
        let sword: Sword = dof::remove(&mut character.id, b"weapon");
        transfer::public_transfer(sword, recipient);
    }

    // Query total character power (including equipped items)
    public fun calculate_power(character: &Character): u64 {
        let base_power = character.level * 10;

        // Access nested objects
        if (dof::exists_(&character.id, b"weapon")) {
            let sword = dof::borrow<vector<u8>, Sword>(
                &character.id,
                b"weapon"
            );
            base_power = base_power + sword.strength;
        }

        base_power
    }
}

// Characters own swords, which own gems, which have properties
// True object composition, not just references

These patterns leverage Sui's unique architecture: Move's resource safety prevents vulnerabilities, PTBs enable complex atomic transactions, object composition creates true asset hierarchies, and dApp Kit simplifies React integration.

Who Should Build on Sui

Frequently Asked Questions