loom:anim — the codec

Instead of storing 10,000 image files, Ciggie Puffs stores a function + a shared art "alphabet" + one seed per token. The whole collection — every trait layer, every background, the full animation — is a single ~900 KB bundle sealed on-ledger. loom:anim is a tiny, dependency-free, integer-deterministic animation codec: byte-identical output on every device, which is what lets the art be content-addressed and independently verified. Layers use an indexed cell-diff mode (chunky pixel art) or a true-colour "feather" mode (soft gradients); on-ledger the docs are LZMA-compressed.

The reactive engine

Every monkey's look is a pure function of (its seed, the live ledger, time). Eleven live inputs are read straight from the Radix Gateway — no oracle, no server:

• Token prices & 24h moves for $XRD, $CIGGIE, $EARLY, $OCI — from on-ledger DEX pool state (reserve ratios / price_sqrt²), anchored to USD via an on-ledger XRD/hUSDC pool.
• Network throughput — 24h transaction volume from the ledger's state_version delta.
• Your wallet — account activity and how many Ciggie Puffs you hold.

Each token is seeded to react to its own mix of these signals (its eyes might track $CIGGIE while its background tracks network volume), each with its own direction and sensitivity. That's why no two monkeys move alike.

Mood, cliques & the wallet social vibe

A monkey's sentiment blends the market with a social signal from its wallet-mates. Each monkey has a seeded affinity (−1…+1) toward eight trait cliques — gold, zombie, albino, female, crowns, officers, hypersuits, diamonds. The more of a liked clique it's surrounded by in an account, the better its mood; rivals drag it down. Mood then drives its eye colour, its nickname, and its speech together.

Names & nicknames

Each token gets a fixed First · Type · Last name computed at mint and stored on-ledger (so the wallet's name matches the rendered name exactly). The reactive nickname — an adjective + noun in the middle — is derived live from the monkey's blended mood and its generated line, shifting from "the Mooning Prophet" to "the Liquidated Doomer" as the market swings.

Talking Loom — the text generator

Speech is generated, not written. A compact n-gram language model (~625 KB) is stored on-ledger alongside the art. A deterministic decoder walks it from the token's seed to a unique line (~96% unique across the collection) that also reacts to the live quote. It's closed-output — every token comes from the stored dictionary — so the whole vocabulary can be audited and moderated offline, and the same seed always yields the same line on any device.

On-ledger architecture

A Scrypto component holds the sealed bundle and the collection NFT resource. Per-token data is tiny: a fixed name, a mint timestamp, and a mutable key_image_url. Because wallets and marketplaces display a static image, a content-addressed render service at ciggiepuffs.xrd.social turns each token's current ledger-reactive state into an animated GIF — refreshed about hourly (the wallet image-proxy's cache window), re-rendering only the monkeys whose reactive state actually changed.

Why loom:anim

A 10,000-piece animated PFP collection is gigabytes of image files. Nobody puts that on a blockchain — so "NFT art" almost always lives on IPFS or a company's servers behind a pointer. Links rot, pinning bills come due, and "on-chain" turns out to be mostly a promise.

loom:anim flips it: instead of files, store a function + a shared art alphabet + one seed per token. The entire collection's art, text and behaviour is a single ~900 KB bundle, sealed on-ledger once. Each token is just its number — the seed. Because the codec is integer-deterministic, every device reproduces byte-identical frames, so the art can be content-addressed, independently verified, and — the part that matters most — made reactive: the render is a pure function of (seed, live ledger, time).

Net: ~900 KB for the whole collection versus multiple gigabytes of rendered files — roughly a 3,000× reduction — and it's genuinely on-chain and alive, not a JPEG behind a link.

Why Radix

• Assets are native. On Radix an NFT is a first-class resource the ledger understands — not hand-rolled bookkeeping inside a contract. Minting, ownership and transfers are safer, simpler and cheaper, with fewer ways to get it wrong.
• Keyless reads via the Gateway. Anyone can read live ledger state — DEX pool prices, network throughput, an account's holdings — with no API key, no node, no oracle. That's what lets each monkey react to the real market with zero backend.
• Owner-controlled, mutable metadata. The on-ledger key_image_url is mutable, so the collection can point each token at its live render without re-minting.
• Scrypto + predictable fees. Publishing the ~900 KB bundle is a one-time, predictable cost; reads are free; and the asset-oriented model keeps the component tiny and auditable.

What it would cost elsewhere

Approach	Where the art lives	Truly on-chain?	Reactive?	Storing 10k
ETH + IPFS (typical PFP)	IPFS / a server	❌ pointer only	❌	ongoing pinning / hosting; link-rot risk
ETH fully on-chain (SVG)	contract storage	✅	❌	~tens of thousands of $ for <1 MB of storage — only tiny art is feasible
Solana + Arweave	Arweave	❌ off-chain	❌	pay-once, permanent — but static files
loom:anim on Radix	on-ledger bundle	✅	✅	one ~900 KB bundle, published once

Cost figures are illustrative — gas-based prices swing with network conditions. The point isn't the exact dollar amount; it's the shape: everywhere else, "fully on-chain + animated + reactive" is either impossibly expensive or simply not offered. loom:anim on Radix makes all three true at the price of a single ~900 KB publish.

The reactive part no one else has

Even projects that put static art fully on-chain can't make it move with the market, because that needs live state at render time with no trusted server. Ciggie Puffs reads the ledger directly, so a monkey's eyes, smoke, coins and mood track real prices and your real wallet — refreshed about hourly through the wallet's image proxy, re-rendering only the tokens whose state actually changed. That's the combination loom:anim + Radix unlocks, and why the collection is built this way.