In the exploration of the Web3 world, beyond the common pursuit of faster transaction speeds and lower fees, deeper, structural challenges are increasingly surfacing.

How can massive amounts of data be stored economically? How can sensitive information be securely protected in a decentralized environment? Can complex computations be efficiently executed off-chain while still having their results verified and trusted on-chain?

Many projects attempt to address these problems by combining various third-party services. However, this path often brings with it integration complexity, potential trust friction, and a fragmented user experience.

Facing these infrastructure-level challenges, the Sui blockchain and its core development team Mysten Labs have proposed a more integrated solution. Rather than relying on a patchwork of external tools, they’ve designed a blockchain with a unique architecture—including its object-centric model and the Move programming language while simultaneously building three tightly connected native infrastructure components: Walrus, Seal, and Nautilus.

This article aims to unpack the design concepts behind these three components, explore how they work, how they relate to each other, and what real changes they might bring to Web3 applications.

---

Sui’s Unique Architecture

To understand how these three tools operate on Sui, we must first look at some key characteristics of the Sui platform itself.

One of Sui’s core innovations is its object-oriented model, a fundamental shift from the traditional account-based architecture. Sui treats tokens, NFTs, and even complex data structures as standalone “objects”. Imagine managing each asset as a separate box instead of logging everything into a single ledger. This design allows unrelated actions—like handling two unrelated NFTs—to be processed in parallel, enhancing throughput.

This object granularity creates a natural synergy with Walrus and Seal: Walrus treats stored data as objects, while Seal can attach permission rules directly to individual objects.

In addition, Sui uses the Move programming language, designed specifically for managing digital assets. Move emphasizes safety and aims to reduce many common smart contract vulnerabilities at the language level. This strong foundation makes it well-suited for building robust infrastructure components.

By aligning chain design and infrastructure development under one roof (Mysten Labs), Sui aims to deliver a more seamless, synergistic developer experience.

⸻

Walrus: Economical, Programmable Decentralized Storage

Storing large files (images, videos, AI models—collectively called blobs) directly on-chain is notoriously expensive. Existing decentralized storage solutions each have trade-offs, but Walrus seeks a new balance between cost-efficiency and smart contract interactivity, directly tackling the cost barriers of large-scale on-chain data.

At the heart of Walrus is Erasure Coding, a clever technique that “shards” a file and adds “recovery clues” so the file can be reconstructed even if parts are lost. Walrus calls these extra fragments “Red Stuff”.

Think of it this way: if you have two numbers, say 3 and 5, and you store both as well as their sum (8), losing the 3 isn’t catastrophic—you can recover it using 8 - 5 = 3. The additional recovery fragments play a similar role, mathematically tied to the originals.

After fragmenting and encoding, Walrus distributes these shards across many nodes. Even if some shards go missing, the system can reconstruct the original file as long as a threshold number of fragments is retrieved—saving significant space compared to full file replication.

This approach dramatically reduces storage costs and could bring decentralized storage pricing closer to that of centralized cloud providers.

Even more interesting, Walrus leverages Sui’s object model: each stored file becomes a programmable on-chain object. Developers can use Move to write smart contracts that manage these storage objects—setting access rules, auto-updating metadata, etc. Storage is no longer just passive—it becomes a natively programmable resource.

There’s also a token utility layer: interacting with Walrus data on Sui requires SUI tokens to record metadata (like file names, sizes, storage locations) and potentially lock tokens for storage fees. If Walrus adoption grows, demand for SUI could increase, tightening supply.

⸻

Seal: The Decentralized Vault and Access Gatekeeper

Many Web3 apps deal with sensitive data: user IDs, financial details, paywalled content. In a decentralized context, how do you securely store secrets and control access to them?

Seal is a Decentralized Secrets Management (DSM) solution designed to answer that question.

One of its core technologies is Threshold Encryption. Imagine a vault that requires two keys to open, each held by a different person. Similarly, threshold encryption splits decryption keys into multiple parts and distributes them to independent key servers. Only when a predefined number of them collaborate (the threshold) can the data be decrypted—no single server can do it alone, which spreads out trust and increases fault tolerance.

Seal’s other clever feature is that access control logic is written as Move smart contracts on-chain. Developers can define clear rules: for example, only users holding a certain NFT or who’ve paid a fee can access certain data. This transparency and verifiability distinguishes Seal from traditional centralized access systems.

When a user or app wants to decrypt a secret, it sends a request to key servers. These servers check the on-chain rules. Only if conditions are met do they release their key fragments. The actual decryption happens on the client device, so key servers never touch the original data.

Seal can protect data stored anywhere—on Walrus, other decentralized networks, or even centralized clouds. This makes it ideal for secure messaging, private user data, paid content gating, confidential voting, and more.

⸻

Nautilus: Making Off-Chain Computation Verifiable On-Chain

Blockchains aren’t great at complex or resource-heavy tasks. Doing those on-chain is slow, expensive, and compromises privacy. Solutions like Layer 2s or oracles help, but Nautilus explores a different path: enabling trustworthy off-chain computation.

Nautilus uses a hardware-based solution called Trusted Execution Environments (TEEs). Think of a TEE as a secure, isolated zone inside a CPU. Code and data inside this zone are shielded from the rest of the system, including the operating system itself.

The basic workflow is as follows:

1. A developer deploys a computational task (e.g., financial models, AI inference, game logic) to a TEE they control.
2. When the task finishes, the TEE produces a cryptographic attestation—a kind of tamper-proof “receipt” that proves:

• the task ran in a TEE
• the code wasn’t tampered with
• the process completed successfully.

3. This attestation and the result are submitted to a Move smart contract on Sui.
4. The contract verifies the attestation (e.g., signature validity and hash of the code).
5. Only if verification passes does the contract accept the result and proceed with on-chain actions.

Nautilus bridges high-performance off-chain computing with on-chain verifiability and trust, without exposing sensitive details.

⸻

Nautilus in Action: The Case of Bluefin

A concrete example is Bluefin, a decentralized perpetuals trading platform.

Most high-performance trading platforms face a dilemma: keeping order books fully on-chain offers transparency but is slow and expensive; moving them off-chain improves speed but introduces trust issues.

Bluefin uses Nautilus to bridge this gap: • Order matching runs inside a TEE, ensuring secure, isolated processing. • Nautilus provides cryptographic proof that the matching logic ran correctly. • Proofs and results are submitted on-chain, where smart contracts verify them before executing settlement.

This approach allows Bluefin to offer fast off-chain matching with on-chain trust guarantees, making it viable for performance-heavy DeFi like derivatives trading. Of course, this does shift some trust from pure blockchain consensus to TEE hardware and implementation.