Build on Rising Tide

Smart Products on Bitcoin.

Each smart product is a Clarity contract on Stacks, a layer that anchors to Bitcoin blocks, and a collector pays for an edition in sats, held as sBTC. Today this runs on the Stacks testnet, where sBTC is a stand-in token; nothing is on mainnet yet. Stacks has the detail.

Rising Tide is not a writing app, or an events app, or a prediction app. It is one primitive - the smart product - and every app on the protocol is that same primitive, shaped for a purpose. If you can picture your idea as something ownable, numbered, and permanent, with everyone who contributed paid automatically, you can build it here.

One primitive

A smart product is a small, sharp idea: take anything worth owning, give it a permanent numbered edition, and encode who gets paid when someone collects it. That is the whole unit. Everything else composes on top of it.

Every smart product, whatever the domain, is:

• Ownable - each edition is an on-chain token with a real owner, transferable forever.
• Composable - it shares one revenue engine and one visual layer with every other smart product. A haiku, a ticket, and a message coexist and can pay into each other.
• Recorded - once deployed, the contract exists independently of the app that made it. If the app disappears, the contract does not. The rendered artwork is saved in our storage until an owner saves a permanent copy (Storage).
• Revenue-encoded - the split among the creator, collaborators, the template artist, and any causes is set at creation and runs automatically on every collect.
• Extensible - opt-in capabilities add behavior without new infrastructure: let collectors leave a note (feedback), gather agreement ratings (sentiment), or pin a piece to permanent storage (detachable).

That is the shape. A "product type" - haiku, ticket, bracket - is just a named configuration of it.

Why a protocol, not a platform

A platform decides what creators can do. A protocol gives creators primitives and lets developers compose them. Rising Tide is a protocol because the most valuable parts of a creative economy - identity, ownership, payment, provenance - should not be owned by any single company. They should be open infrastructure that any app can build on, the same way email runs on open protocols and no single email app owns your messages.

For developers, that means: you do not have to rebuild payment rails, royalty splits, identity, or ownership for your app. The protocol handles those, with the rules held in the contract, and you focus on the surface your users see.

For creators, that means: when you publish through one app, your earnings, identity, and audience are not locked inside that app. You can move between apps without losing anything. If an app shuts down, the on-chain record of your work survives.

The range

The same primitive already spans very different things. These are not separate systems - they are one primitive, shaped:

And it reaches past what has an app today. The revenue splits, numbered ownership, and permanence that power writing work just as well for music, photography, and creative domains nobody has built yet - the infrastructure already carries them; what is missing is a purpose-built surface. If one of those is yours, reach out - early builders help shape it.

Bottle Drop: a weekend, and no new infrastructure

The clearest proof that this is a primitive and not a product is how little it takes to make something new with it.

Bottle Drop looks nothing like a writing app. It is a drifting-stream game where you seal a message in a bottle and a stranger finds it. But underneath, a "bottle" is not a protocol concept at all - it is a basic page with the feedback capability turned on and a nautical brand painted over the top. (The first bottles were open letters with the recipient left blank; both types live in the stream.) That is the entire invention. No new contract, no new backend, no new payment logic.

A small team stood up a genuinely novel experience - its own look, its own vocabulary - on primitives that already carried ownership, permanence, and direct payment. That is what building on Rising Tide feels like: you compose and paint, you do not rebuild.

You compose, you do not rebuild

The hard parts are already solved and shared. You do not write payment rails, royalty math, identity, ownership, or permanent storage. You decide the product's shape and ship the surface your users see.

The headless SDK is the only backend dependency a thin client needs. Bring your own design system; the protocol brings the economics.

What the protocol is made of

Every app on the protocol serves one of these domains, shaped and branded - and the same primitives are open to domains that have no app yet.

Bring a domain online

If you see a creative domain the protocol should serve, we want to hear about it. Early builders who work with the Rising Tide team to bring a new domain online participate in the same revenue system as any other contributor - build the product type, design the template, ship the app, and earn from what you make.

Protocol direction is set by the Rising Tide team; this is a collaboration with builders who have real needs, not an open free-for-all. If you have a domain in mind, reach out - the people who show up early benefit from doing so.

Where to go next

• Integrating now? Getting Started installs the SDK and makes your first call.
• Want the model first? Smart Products is the primitive in technical depth, and Capabilities, Constraints & Attributes is the traits you compose onto it.
• Reading an interface? The SDK, the UI package and the API.
• Running on a specific chain or storage provider? Marketplaces and Storage.
• Need a term defined? The Glossary.
• Want a worked example? Bottle Drop, end to end, in the product guides.