Ceramic Network

Ceramic is a foundational layer for self-sovereign identity (SSI) and portable social graphs. Applications use Decentralized Identifiers (DIDs) and Verifiable Credentials (VCs) anchored to Ceramic streams to create user-controlled profiles, reputations, and social connections that are portable across applications.

• Key Use Case: IDX, a cross-application identity protocol, uses Ceramic to unify a user's profile, connections, and data across multiple dApps.
• Example: A user's social graph from a Web3 social app can be reused in a DeFi app for underwriting or a DAO for governance, without platform lock-in.

Ceramic enables data composability by allowing applications to read from and write to the same mutable data streams. This creates a shared data layer where applications can build upon each other's data, similar to how DeFi protocols compose with each other's smart contracts.

• Key Mechanism: Data is stored in TileDocument or Model streams, which are JSON documents with defined schemas that any application can query if permitted.
• Example: A user's curated list of NFTs in a gallery app could be read and displayed by a separate portfolio tracker app, with updates syncing automatically across both.

Ceramic solves the problem of static NFT metadata by providing an off-chain data layer that can be updated in a decentralized, verifiable manner. This enables dynamic NFTs whose traits, artwork, or utility can evolve based on on-chain or off-chain events.

• Key Use Case: Gaming assets that level up, generative art that changes, or membership tokens with evolving benefits.
• Technical Detail: The NFT's on-chain token URI points to a Ceramic stream ID. The asset's owner or governed logic can update the stream content, and all viewers see the latest verified version.

Ceramic provides a censorship-resistant backend for blogs, documentation, and other content platforms. Authors publish content to their own data streams, which are replicated across the peer-to-peer network, ensuring availability and integrity without relying on a central server.

• Key Feature: Mutable yet verifiable history. All updates are signed and appended to the stream's log, creating a full version history that can be audited.
• Example: A decentralized blogging platform where posts are stored on Ceramic, giving authors full ownership and control over their content and its distribution.

Ceramic is chain-agnostic and integrates with multiple blockchain ecosystems to anchor data ownership and permissions. StreamControllers are often blockchain accounts (e.g., Ethereum wallets via Ethereum Auth Method), making on-chain identity the root of trust for off-chain data.

• Primary Integrations: Heavily used within the Ethereum and Polygon ecosystems. Also integrated with Solana, Flow, and others via wallet-based DIDs.
• How it Works: A user signs a message with their blockchain wallet to create or update a Ceramic stream, cryptographically linking the data to their on-chain identity.

Developers define Data Models—composable schemas for application data—which are deployed to the network. The GraphQL API (Ceramic's indexing layer) then provides a unified query interface across all streams conforming to those models, enabling efficient data discovery and retrieval.

• Key Benefit: Solves the "data discovery problem" in a decentralized network. Applications can query for all streams of a certain type (e.g., all user profiles) without knowing their StreamIDs in advance.
• Workflow: 1. Create & deploy a Model schema. 2. Create streams that implement the model. 3. Query all instances via the GraphQL endpoint.

Ceramic is foundational for self-sovereign identity (SSI) and portable social graphs. Applications can store user profiles, connections, and reputations as streams that users own and control. This enables:

• Portable social data across platforms (e.g., Lens Protocol).
• Verifiable credentials that are not locked to a single app.
• User-centric data models that break down platform silos.

Ceramic enables dynamic NFTs whose metadata can evolve based on off-chain events or user interactions. Instead of static JSON files, NFT attributes are stored as updatable data streams. This allows for:

• Game items that change based on gameplay.
• Artwork that updates with time or owner input.
• Deed titles where property details can be amended.

At its core, Ceramic is a protocol for creating, updating, and discovering verifiable data streams based on shared data models. This involves:

• TileDocument streams: The basic unit for mutable data on Ceramic.
• Data Models (Schemas): Community-defined standards (using JSON Schema) that ensure interoperability.
• StreamIDs & CommitIDs: Unique, immutable identifiers for streams and every change made to them.

A graph database built on Ceramic that enables developers to create and query composable data models. It uses GraphQL for querying and InterPlanetary File System (IPFS) for decentralized storage, allowing applications to share and reuse data across different projects.

• Key Feature: Supports mutable data streams where updates are anchored to a blockchain.
• Use Case: Building social applications where user profiles and social graphs are portable across different frontends.

A W3C standard for verifiable, self-sovereign identity. On Ceramic, a DID is the controller of one or more streams, providing the cryptographic authority to create and update them.

• Ceramic's Method: Primarily uses did:key and did:3 (a Ceramic-specific method).
• Role: Enables users to own their data without relying on a central server; the DID signs all transactions to its streams.

A user-centric framework and SDK for building applications with decentralized identity and data. It provides React components and hooks to easily integrate Ceramic and ComposeDB, abstracting away complexity for developers.

• Purpose: Manages user authentication (DID), data storage, and social graph interactions.
• Utility: Allows developers to focus on application logic while handling data portability and user sovereignty automatically.