Skip to main content

The Sui Difference

Sui represents a fundamental rethinking of blockchain architecture, designed from the ground up to address the limitations of existing platforms.

10x-100x Lower Latency

Sub-second transaction finality for instant user experiences

Horizontal Scalability

Add resources to increase throughput linearly

Lower Gas Costs

Efficient execution reduces transaction fees

Developer Friendly

Move language prevents common vulnerabilities

Unmatched Performance

Parallel Transaction Execution

Unlike traditional blockchains that process transactions sequentially, Sui executes independent transactions in parallel.
Simple Transactions bypass consensus entirely, achieving finality in ~400ms compared to 12+ seconds on Ethereum.

Fast-Path Execution

Owned objects (the majority of transactions) use the fast path:
  1. No Consensus Required: Direct validator certification
  2. Instant Finality: Certificate ready in one round-trip
  3. Low Latency: Typically less than 500ms
Client → Validators (broadcast)
Validators → Client (signatures)
Client → Certificate (assembled)
✅ Transaction finalized

Time: ~400ms

Object-Centric Architecture

Everything is an Object

Sui’s data model treats all on-chain state as typed objects with unique IDs, owners, and version numbers.
This approach enables fine-grained parallelism - transactions touching different objects execute simultaneously.
Object Types:
  • Owned: Single address owns (fast path)
  • Shared: Multiple parties can access (consensus path)
  • Immutable: Read-only, never changes
  • Wrapped: Contained within another object

Flexible Ownership Model

// Owned object - transferred directly
public fun transfer_sword(sword: Sword, recipient: address) {
    transfer::transfer(sword, recipient);
}

// Shared object - accessible by anyone
public fun create_auction(ctx: &mut TxContext) {
    let auction = Auction { /* ... */ };
    transfer::share_object(auction);
}

// Immutable object - publish once, read forever
public fun freeze_metadata(metadata: Metadata) {
    transfer::freeze_object(metadata);
}

Move Programming Language

Built for Asset Safety

Move was designed at Meta (formerly Facebook) specifically for managing digital assets securely.

Resource Safety

Assets can’t be copied or accidentally destroyed

Type Safety

Strong typing catches errors at compile time

Formal Verification

Mathematical proofs of correctness

Auditable

Clear, readable code structure

Preventing Common Vulnerabilities

// Move's borrow checker prevents reentrancy
public fun withdraw(pool: &mut Pool, amount: u64): Coin<SUI> {
    // Can't call withdraw again while &mut Pool is borrowed
    pool.balance = pool.balance - amount;
    coin::split(&mut pool.reserves, amount, ctx)
}

Programmable Transaction Blocks

Compose Multiple Operations

Execute complex multi-step operations atomically in a single transaction.
// TypeScript SDK example
const tx = new Transaction();

// 1. Split a coin
const [coin] = tx.splitCoins(tx.gas, [100_000_000]);

// 2. Call a Move function
const result = tx.moveCall({
  target: '0x2::coin::mint',
  arguments: [coin],
});

// 3. Transfer the result
tx.transferObjects([result], address);

// All succeed or all fail atomically
const result = await client.signAndExecuteTransaction({
  signer: keypair,
  transaction: tx,
});
PTBs can include up to 1,024 commands, enabling complex DeFi operations, batch NFT mints, and sophisticated game logic in a single transaction.

Economic Model

Storage Fund for Sustainability

Sui’s storage fund ensures long-term economic sustainability.
1

Pay for Storage

Users pay a one-time storage fee when creating objects based on size.
2

Storage Fund Grows

Fees accumulate in the storage fund, generating staking rewards.
3

Rebates on Deletion

Users receive rebates when deleting objects, incentivizing cleanup.

Gas Price Mechanism

  • Reference Gas Price: Validators vote on minimum price each epoch
  • Computation Gas: Based on execution complexity
  • Storage Gas: Based on object size and duration
  • Rebates: Partial refunds when deleting objects

Network Architecture

Mysticeti Consensus

Sui uses Mysticeti, a state-of-the-art DAG-based BFT consensus protocol.

Low Latency

Commits in ~500ms (2-3 network round-trips)

High Throughput

160,000+ TPS demonstrated in testing

Byzantine Fault Tolerant

Tolerates up to 1/3 malicious validators

Pipelining

Overlaps multiple rounds for efficiency

Validator Set

  • Permissionless: Anyone can become a validator with sufficient stake
  • Delegated PoS: Token holders delegate stake to validators
  • Epoch-based: Validator set reconfigures every 24 hours
  • Incentive-aligned: Rewards tied to performance and uptime

Developer Experience

Rich Ecosystem

Rust SDK

Type-safe Rust client library

TypeScript SDK

Full-featured JS/TS SDK

GraphQL API

Rich query interface

CLI Tools

Comprehensive command-line tools

Move Analyzer

IDE support via Language Server

Indexing

PostgreSQL-based indexer

Quick Iteration

# Create a new Move package
sui move new my_project

# Build and test locally
sui move build
sui move test

# Publish to devnet
sui client publish --gas-budget 100000000

# All in under 30 seconds

Enterprise Features

zkLogin

Authenticate users with Web2 credentials (Google, Facebook, Twitch) without compromising privacy.
zkLogin uses zero-knowledge proofs to verify OAuth tokens on-chain without revealing user identity.
Allow applications to pay gas fees on behalf of users, enabling seamless onboarding.
// App sponsors user's first transaction
const tx = new Transaction();
tx.setSender(userAddress);
tx.setGasOwner(sponsorAddress);

// Sponsor signs and submits
await sponsor.signAndExecuteTransaction({ transaction: tx });

Multisig Support

Native support for multi-signature wallets and complex authorization schemes.

Comparison

FeatureSuiEthereum
Finalityless than 500ms12-15 min
TPS297,000+15-20
LanguageMoveSolidity
ExecutionParallelSequential
State ModelObject-basedAccount-based

Get Started

Install Sui

Set up your development environment

Quickstart Tutorial

Build and deploy your first package

Architecture Overview

Understand how Sui works

Developer Guides

Comprehensive development guides

Build docs developers (and LLMs) love