Walrus is built around a simple but powerful idea: data should be treated as a first-class object, not an afterthought attached to transactions. Instead of embedding files directly on a blockchain, Walrus separates data storage from data control. The result is a system where large files can live off-chain in a decentralized storage network, while their ownership, lifecycle, and guarantees are enforced on-chain in a transparent and auditable way.
At the core of Walrus is the concept of a blob. A blob is an immutable array of bytes that can represent anything: text, images, videos, datasets, or application binaries. Once stored, a blob never changes. This immutability allows applications to reason about data with certainty, knowing that the content retrieved today will be identical tomorrow. Walrus does not attempt to make data editable; instead, it makes data provable.
Each blob is identified by a content-derived identifier, meaning the identifier is computed directly from the data itself. If the same file is uploaded twice, the resulting blob identifier is the same. This eliminates ambiguity and enables integrity verification at read time. Anyone retrieving a blob can cryptographically confirm that the bytes they received match the expected identifier, without trusting the storage provider.
While blob identifiers handle content verification, Walrus relies on on-chain objects to manage blob metadata. For every stored blob, a corresponding object is created on the Sui blockchain. This object records ownership, retention duration, and lifecycle state. The blockchain does not store the data itself; it stores authoritative information about who controls the blob and how long the network is obligated to keep it available. This clean separation keeps the chain lightweight while preserving strong guarantees.
To ensure durability and availability, Walrus breaks blobs into smaller units known as slivers. These slivers are distributed across many independent storage servers and protected using erasure coding. Erasure coding allows the original data to be reconstructed even if some slivers are missing or some servers are offline. Instead of relying on full replication, Walrus achieves resilience through mathematical redundancy, balancing efficiency with fault tolerance.
Storage commitments in Walrus are measured in epochs, which represent discrete units of network time. When a blob is stored, the user specifies how many epochs it should be retained. This commitment is enforced through the on-chain object associated with the blob. If continued availability is required, the owner can extend the storage duration by updating the object metadata. This makes data retention explicit, verifiable, and programmable.
Walrus deliberately distinguishes between immutability and deletion. While users can issue a delete operation, deletion affects the network’s metadata and discoverability rather than guaranteeing physical erasure of all copies. Because blobs are immutable and may have been cached or copied by others, Walrus treats deletion as a governance action rather than an absolute erasure. This model reflects the realities of distributed systems and encourages careful data publishing practices.
All lifecycle actions—creation, extension, and deletion—are executed as on-chain transactions. This creates a permanent audit trail that records who acted on a blob and when. For developers and institutions, this auditability is critical: it enables compliance, dispute resolution, and historical analysis without relying on centralized operators.
Security in Walrus inherits the account model of the underlying blockchain. Control over blob metadata is tied directly to cryptographic keys. Whoever owns the private key controlling the on-chain object controls the blob’s lifecycle. This makes key management a central operational concern, as losing a key means losing the ability to manage or renew stored data.
Taken together, Walrus introduces a storage model where data is immutable, verifiable, time-bound, and governed by programmable rules. By combining content-addressed blobs, on-chain metadata, erasure-coded distribution, and explicit retention economics, Walrus turns decentralized storage into a reliable foundation for applications that depend on long-term data integrity rather than short-term availability signals.