Every generation of software has been shaped less by imagination and more by infrastructure. The browser made the web possible; cloud platforms made scale possible; social graphs and app stores made distribution possible

Web2’s gift (and curse) was speed. You could rent servers from AWS, plug into Google or Facebook for authentication, lean on Stripe or PayPal for payments, deploy frontends through Netlify or Vercel. The time to launch collapsed from years to weeks.

Yes, speed came at a cost. The web grew on rented servers, rented identities, and fragile connections between platforms. Users never owned their data; companies did. What should have been an open system of people, apps, organizations, and now even AI agents turned into a maze of locked boxes.

That story didn’t have to repeat itself...and since May 3rd 2023, Sui has been on a mission

‍

‍

‍

The Stack

If you’ve tried building Web3 apps, you know the pattern: you can deploy contracts, but you end up wiring in Web2 infra for storage, auth, or delivery.

“When you start stacking these up together (Sui, Walrus, SEAL, Deep, and SuiNS) this becomes a full developer stack. It makes innovation much easier.” - Christian T.

in Adeniyi's words "Changing user behavior is incredibly tough. So the smartest path is to create a UX that seamlessly fits into the existing user behavior without adding any friction. That’s the guiding principle behind #Sui’s DevEx."

‍

‍

Thats why they came with the Stack: >Sui handles execution and coordination.
>Walrus gives you storage with provenance
>Walrus Sites makes frontends verifiable.
>SEAL turns access control into programmable policy.
>DeepBook brings native liquidity
>Nautilus proves what happens offchain.
>zkLogin + Passkeys smooth onboarding without compromise
>SuiNS gives names and identity that travel.

‍

Individually, these are useful. Together, they’re a response to the reality that infra is the bottleneck now. Each piece (Sui, Walrus, Walrus Sites, SEAL, DeepBook, Nautilus, zkLogin, Passkeys, SuiNS) addresses a failure of Web2 infra.

‍

Compute and coordination - @SuiNetwork

SUUUUUU..WAIT, NO

Sui organizes the world as objects, or simply things you can own, share, or leave unchanged. Transactions act on those objects directly. Unrelated actions can run side by side, while shared ones still stay consistent. And because it finalizes in under a second, coordination between apps feels instant.

Sam Blackshear has broken this down:

Think of how @Google changed search. Before PageRank, authority on the web was a matter of reputation and marketing. After PageRank, it was a matter of links, relationships that could be computed.

Sui does the same for coordination: relationships between objects become computable, not contractual.

‍

Walrus - storage and provenance

Think about the last time a group worked on the same document. Someone emailed the file, another person saved a new version, then came “final,” “final2,” “final-final.” Pretty soon, nobody knew which copy was the right one.

That’s the problem Walrus Protocol solves. Instead of identifying files by where they’re stored, it gives each piece a fingerprint that proves what it is. The content becomes the identity.

this means:

• research groups can share datasets without worrying about which copy is correct
• AI teams can publish models that anyone can verify are unchanged
• artists can release files without the risk of silent swaps.

Data can be verified wherever it moves. Applications don’t need to negotiate who hosts the “real” version, they all point to the same reference. That makes storage part of the system itself, not an external dependency.

For the community, the benefit is obvious: apps can share information directly without middle layers, and users know their data can’t be swapped or lost. Walrus brings the same guarantees we expect from Sui’s execution to the data that applications depend on.

TLDR: Walrus turns data and code into self-verifying assets. No matter where they move, their integrity can be proven, closing the front-end blind spot and setting the foundation for trustworthy apps, agents, and AI.

‍

‍

Walrus Sites – frontends you can trust

Most people meet an application through its interface. And yet, in Web3, that interface usually comes from a Web2 source you can’t verify.

Walrus Sites deploys frontends as verifiable bundles, so users can check the code they load is the same one the developer shipped. Developers know their work can’t be swapped silently, and users know the interface matches the logic underneath.

The weakest point in Web3 isn’t the blockchain, it’s the interfaces and data we trust without checking. The $1.4B @Bybit hack proved this. Attackers didn’t break encryption; they injected malicious code into the front end. Executives signed what looked like a normal transaction, but the interface was lying.

‍

The contracts weren’t the problem, the delivery of code was.

‍

TLDR: You know the buttons you click match the logic underneath, and developers know their work can’t be hijacked at the entry point.

‍

‍

SEAL - brings rules onchain

Access in today’s systems is fragile. Links get forwarded too far. Permissions fail to expire. Every rule depends on someone remembering to enforce it.

SEAL rewrites that model by making access control part of the chain itself. Policies are written as Move smart contracts and enforced cryptographically. No servers. No admins. No silent overrides.

• SEAL makes those rules part of the chain itself.
• A creator can lock content to token holders
• A researcher can share a dataset for 30 days
• A team can grant access only to a defined list of addresses.
• Games can hide logic, gated assets, or story progressions until players qualify.

Once the rule is written, the network enforces it cryptographically. No servers,no admins, and no chance to override.

You can write policies like “unlock for token holders” or “open to this address for 30 days,” and SEAL enforces them cryptographically. This makes subscriptions, gated content, private docs, or licensed datasets native to Sui instead of bolted on.

For builders, SEAL is plug-and-play: encryption and policy enforcement without standing up your own Web2 key management system. For users, it means access rights aren’t favors from a platform, they’re rules that enforce themselves.

TLDR: SEAL turns access rules into self-enforcing code.

‍

‍

‍

DeepBook – liquidity + infrastructure

Every platform eventually needs a marketplace. In Web2 you either build it yourself or plug into a gatekeeper who owns the rails. Payments, order matching, custody, all of it sits behind someone else’s APIs.

DeepBook is Sui’s answer: a native, shared liquidity layer baked into the stack. Instead of each app reinventing an exchange or routing orders through a centralized service, everyone can plug into the same pool. Liquidity isn’t fragmented across dozens of silos; it’s composable, verifiable, and accessible by default.

> For builders, that means you can launch a product (a game, a marketplace, a new token model) and instantly tap into existing liquidity without negotiating integrations.

> For users, it means tighter spreads, deeper markets, and the confidence that trades execute on-chain under the same guarantees as the rest of Sui.

It also opens the door for new kinds of coordination. Imagine AI agents that can negotiate and settle trades across applications, or games where in-game assets can be swapped directly in shared order books. DeepBook turns liquidity into a public good.

TLDR: DeepBook makes liquidity a layer of the stack, a common marketplace any app can build on.

‍

‍

‍

Nautilus – say NO to “trust me bro”

Not everything belongs onchain. Some logic is too heavy. Some data needs to stay private. The problem is that once computation leaves the chain, guarantees usually vanish, you’re back to “trust me bro.”

‍

Nautilus fixes that by running workloads inside Trusted Execution Environments secure hardware enclaves (ex. AWS Nitro Enclave)s. The TEE executes the code and produces a cryptographic attestation. That attestation is then verified by Move smart contracts on Sui before any output is accepted.

In simple terms: you send data into a black box. Normally, you’d just trust whatever comes out. With Nautilus, the black box hands you a receipt proving it really did the work.

> For builders, it means you can combine onchain trust with offchain privacy.

> For the community, it means sensitive compute can’t hide behind “trust me bro”

TLDR: Nautilus makes offchain work provable.

‍

‍

‍

zkLogin + Passkeys

For years, the hardest part of Web3 has been the first step. Seed phrases (those words you write on a small piece of paper you keep forgetting it’s place), browser extensions, key management. For no surprise, most new users drop off right there.

> zkLogin lets people sign in with accounts they already use, like Google or Apple, but behind the scenes it creates a wallet-compatible identity.

>Passkeys add passwordless, biometric login. The experience feels familiar, but the outcome is still self-custody.

TLDR: zkLogin and Passkeys make self-custody feel like normal login.

‍

‍

‍

SuiNS - unique onchain names (and more)

Every app invents its own usernames, and nothing carries over. Think about how many times your favorite nickname was already taken in a new game. SuiNS fixes that with portable, human-readable names that work across the ecosystem.

‍

It began as a simple naming service but is quickly becoming the identity backbone of the Sui ecosystem. Beyond human-readable addresses, it now anchors governance, personalization, and on-chain marketplaces.

SuiNS fixes this with portable, human-readable names that work across Sui. Meaning, instead of being tied to one app, your identity comes with you. Reputation, access, and connections move as you do. What’s live and coming:

• Governance: Holders actively vote on roadmap priorities, treasury allocations, and discounts, turning SuiNS into a community-led project.
• From ultra-short names and emoji handles to NFT avatars, Linktree-style profiles, and referral systems, identity on Sui is evolving into a full suite.
• Moving from .sui to
• Auction Service, reserve pricing, live bidding, full history, and notifications.

For the ecosystem, it means a base layer of identity that doesn’t lock you in, one simple name that represents you anywhere.

TLDR: SuiNS makes your identity travel with you.

‍

‍

‍

Building what the last wave couldn’t

The web we inherited gave us speed, but it also dependence.

Sui is a chance to reset those foundations by making trust and coordination properties of the system itself. Execution, storage, access, identity, and markets, all aligned around verifiability rather than permission.

That’s why this stack doesn’t close the door on the lessons of Web2; it carries them forward, but without the trade-offs that bent the web toward centralization. It gives builders a base that stays open as it scales, and users a place where their presence isn’t borrowed but owned.

We’ve chosen to grow here because we recognize the weight of that shift. If the next wave of the web is going to be built on these principles, then Sui the right place to stay.

‍

‍

== If the future of the web is taking this shape, then we’re exactly where we need to be. ==

‍

‍