Messaging SDK Beta: Now Live on Sui and Walrus Mainnet

Main Takeaways

• The Messaging SDK brings encrypted, wallet-linked communication to Sui apps, rebuilt after alpha into a production-ready architecture
• The beta redesigns the alpha architecture around scalability, cost efficiency, and cross-device recoverability
• Messaging is now a programmable infrastructure, composable with identity, access control, and storage on Sui

Overview

Building messaging into a Web3 app has historically meant reaching for centralized services or tools disconnected from wallet identity, onchain activity, and the access control logic already powering the rest of the product.

The Sui Stack Messaging SDK was designed to close that gap: encrypted, programmable communication built natively into the same stack as assets, storage, identity, and access control.

The alpha release showed strong developer interest and surfaced important architectural questions. After a few months of iteration and real-world feedback, the Sui Stack Messaging SDK Beta is now live on Sui and Walrus Mainnet.

From alpha to production

This isn’t just a version bump. The Beta is a redesigned architecture built for scalability, performance, cost efficiency, and production-grade use, while preserving what made the original concept powerful: programmable, encrypted, composable messaging built on open infrastructure.

The alpha release proved that developers want messaging tightly integrated with onchain identity, access control, and storage. But it also surfaced questions that the original design hadn't fully resolved.

Should every message be a transaction? How do you deliver real-time chat without overwhelming the chain? How do you keep costs predictable for apps that might scale to millions of messages? How do you support cross-device restore without centralized backups and in a cost-efficient manner?

If messaging is going to power games, DeFi apps, identity systems, AI agents, and cross-app workflows, it has to feel fast, affordable, and reliable. The Beta was reworked around three goals:

• Scalability: no need to route every message through an onchain transaction
• Cost efficiency: predictable economics for consumer apps
• Recoverability: encrypted, cross-device message restore

The beta release reflects that redesign.

The Beta architecture

The Messaging SDK Beta introduces a modular, production-oriented stack built around three core components.

First, the Groups SDK runs on Sui and manages channel creation, memberships, permissions, and configurations. Channel state lives onchain, giving you verifiable access control and enforceable membership rules without putting every message onchain. The SDK can also be used standalone for experiences beyond messaging.

Second, a Backend Relayer handles real-time message exchange. Instead of writing each message as a transaction, the relayer validates membership using gRPC-fetched data from a Sui full node and enables fast message delivery. The available pattern can be enhanced with the desired storage mechanism, and be run as a standard service or inside a Trusted Execution Environment (TEE) using Nautilus. Messages are periodically backed up to Walrus for durability and recovery.

Third, the high-level Messaging SDK ties everything together. It abstracts Groups and Relayer while handling encryption with Seal, attachment storage on Walrus, and message restore from Walrus for cross-device access.

This separation of responsibilities gives developers real-time messaging without sacrificing verifiability or composability.

Encryption and storage by default

All messages and attachments are encrypted using Seal before leaving the client. The relayer never sees plaintext. Walrus stores encrypted attachments and message backups.

In beta:

• Attachments are encrypted client-side and stored on Walrus
• Messages are periodically archived to Walrus
• Clients can restore message history from Walrus
• Channel membership controls decryption rights

This enables encrypted messaging with decentralized recoverability, without relying on centralized backups like traditional messaging apps.

What you can build

With the Beta release, developers can build messaging experiences that feel native to their apps, not bolted on. That includes:

• Secure 1:1 DMs and group chats
• Custom token-gated or membership-gated communities
• Guild chats for games
• In-app support channels
• Cross-app coordination between protocols
• AI agents that interact inside encrypted channels
• Reputation or identity-driven messaging workflows

Because the architecture is modular, you can deploy the relayer in a non-TEE setup or inside Nautilus, add the desired storage mechanism, adjust archival frequency, or extend transport layers (polling, long polling, WebSockets, SSE) based on your needs.

Messaging becomes programmable infrastructure, not just chat UI.

Why this matters

Messaging is more than conversation. It’s coordination, identity signaling, encrypted commerce, and cross-application state exchange. In Web3, messaging can become a composable layer that integrates directly with identity, access control, and storage primitives.

The beta release strikes a balance: onchain state for verifiable membership, offchain relayer for speed and scale, Walrus for decentralized storage and recovery, Seal for end-to-end encryption, and SuiNS for human-readable identities and discoverability.

That hybrid model is what makes scalable, encrypted, composable messaging possible with the Sui Stack.

Ready to build

Messaging SDK Beta is ready for real-world use, and we’re excited to see teams take it to production. The architecture is stable and modular, and further improvements will be prioritized based on clear, production-driven feedback from builders.

If you’re shipping and hit constraints, let’s work through them together. Thoughtful PRs tied to real app use cases are encouraged. The goal is simple: evolve the messaging layer alongside teams actively building with the Sui Stack.

The messaging layer is ready. What you build with it is up to you.