Technical documentation

Everything it takes to add one tableau a day

The full technical documentation of Panorama: the daily cycle, the generation engine, each season’s pipeline, the smart contracts and renderers, the operator console, the site, the terminal, the indexer, the sales and the infrastructure.

Tableau #105Tableau #106Tableau #107Tableau #108Tableau #109Tableau #110
Six consecutive days, #105 to #110, as they stand on the canvas. Each was generated alone and joined to the day before it. Drag it sideways.

01

The whole system

Panorama is one artwork that grows by one tableau a day, at the mood the PANO/USD price sets. This page is how that is built, part by part.

210
tableaus revealed, one a day since 23 April 2026
1,700+
commits across the repositories
180,000
lines of TypeScript and Solidity, roughly
1,463
automated tests on the engine and the contracts
200,000+
candidate images generated and kept
6
renderer contracts shipped

1

2

3

4

The work's 365 token slots to scale. Solid: the 210 revealed so far. Lighter: Season 4, next. Outlined: #271 to #365.

PANO/WETH pool

Uniswap V4. Trades all day.

Indexer

Price, candles, trades, holders.

Engine

Reads the close, picks the mood, publishes, writes on-chain.

Operator console

Two artists prepare an option per mood and pick.

GPU and language models

Comfy Cloud, Modal, OpenRouter.

CDN

Images, metadata, the index.

IPFS and Arweave

Permanent copies.

Ethereum

Entry, steps, image hashes, storage links.

panorama.garden

Canvas, tableau pages, terminal.

On-chain viewer

The same artwork, served by the renderer.

Marketplaces

Token metadata built on request.

The path of one day. The artists work in the console before the close. From the reveal on, the engine works alone.

The parts

PartWhat it doesBuilt with
EngineReads the price, runs generation, publishes, writes to Ethereum, serves the console's API.Node, TypeScript, Bun, Express, viem
Operator consoleWhere the artists make and pick each day.Next.js, server-sent events
ContractsThe token, its renderers, storage, the step ledger, the sales.Solidity 0.8.34, Foundry, Solady
This siteThe canvas, tableau pages, terminal, collector tools.Next.js on Cloudflare Workers, wagmi
IndexerFollows the coin's pool: price, candles, trades, holders.Ponder, PostgreSQL, Hono
Season 4 studioThe live scene's page, its console and its GPU runner.three.js, Cloudflare Workers, Modal, Python
Sale sitesThe Season 2 and Season 3 auctions, each its own site and contracts.Next.js, Foundry, Playwright
BotsReveal posts, sale and trade posts, standing offers.TypeScript, X API, OpenSea SDK
InfrastructureOne server defined in Ansible, Cloudflare in front, R2 for files.Ansible, systemd, nginx, restic

In numbers

Engine
About 72,000 lines of TypeScript in 253 files. 86 test files with 805 test cases.
Contracts
About 23,800 lines of Solidity: 6,000 of contracts, 12,500 of tests, 5,300 of scripts. 658 test functions.
Console
About 34,000 lines of TypeScript.
This site
About 27,000 lines of TypeScript.
Season 4 studio
About 25,600 lines of TypeScript for the console alone, beside the scene's page and the Python pipeline.
Commits
More than 1,700 across the repositories, from February 2026.
Candidates kept
Over 200,000 candidate images, about 389 GB, by October 2026.
Renderers shipped
Six, with four viewer templates.
Image models used
Z-Image Turbo, FLUX.1 Dev, SDXL, FLUX.2 Klein 9B and 4B, Krea 2.
February
8
March
44
April
109
May
55
June
44
July
73
August
13
September
51
October
98
November
123
Commits to the main repository by month in 2026. April is the launch, July the Season 2 auction, October Season 3 and a server migration, November Season 4. November runs to the 18th.

How a tableau moves through it

  1. 1MarketThe coin trades on a Uniswap V4 pool. The indexer follows it for the terminal. The engine reads it once a day.
  2. 2MakeThe artists prepare options for each mood in the console. Language models write, image models generate, a seam joins each to yesterday.
  3. 3RevealAt 16:00 UTC the price picks the mood and the engine publishes the option both artists picked for it.
  4. 4RecordThe files go to the CDN, IPFS and Arweave. The entry, the steps and the image hashes go to Ethereum.
  5. 5ShowThe site and the on-chain viewer draw the artwork from the index and the chain. The renderer builds every token's metadata on request.

Where to read less

The about page explains the work without the machinery. The Season 4 pages explain the live scene.

02

What happens daily

One reveal a day at 16:00 UTC. Everything before it is preparation by the artists. Everything after it is the engine working alone.

Before 16:00

Nobody knows the day’s mood until the market closes its day, so the artists prepare more than one. In the Workshop each of the seven moods has its own lane. A lane holds options made for that mood on the same day of the story. An option becomes eligible when both artists of the season have picked it. A day does not need all seven: each mood stands alone.

Preparing options never publishes anything. While a Workshop session is open the engine holds a non-publishing safety switch, persisted to disk, so a crash or a restart cannot turn a draft into a reveal.

At 16:00 UTC

  1. 1PriceThe engine reads the PANO/USD price at the first and the last block of the day from two Uniswap V4 pools and computes the change. See Price and mood.
  2. 2MoodThe change maps to one of seven moods. The price itself never reaches a prompt.
  3. 3Reveal gateThe engine looks up only the mood the price landed on. If a fresh option picked by both artists covers it, the reveal goes on unattended. If not, the reveal holds.
  4. 4PublishThe picked tableau is uploaded to the CDN in three sizes, with its metadata. Yesterday’s tableau is uploaded again, because the seam rewrote its right edge.
  5. 5IndexThe metadata index, one JSON file listing every tableau, gets the new entry and the CDN cache is purged.
  6. 6ChainThe on-chain jobs are queued: the generation steps, the tableau entry, later the image hashes and the storage links.
  7. 7AnnounceA post goes out on X from the Panorama bot and a message to the artists’ Discord.

When a reveal holds

A scheduled run with no eligible option for the market’s mood does not fall back to generating live and does not exit. The main loop notifies the artists, checks every 30 seconds for a pick on the held day, retries every 5 minutes and sends a reminder every 6 hours. A pick on the held day breaks the wait early, so a joint pick publishes within seconds. An option is also refused as stale when the newest published tableau is no longer the one it was joined to.

The held reveal is shown in the console with the mood it waits for, so the work in front of the artist is plainly the work that becomes today’s tableau.

After the reveal

  1. 16:00 UTC

    Reveal

    The tableau, its metadata and the index are public. The post goes out.

Within minutes
The generation steps and the tableau entry are written to Ethereum from the engine’s minter wallet, each under a fixed ETH budget.
When gas is low
The keccak256 hashes of the tableau’s image fragments are committed once gas is under 0.5 gwei. After that anyone can upload the image itself.
Within a day
The image is pinned to IPFS and synced to Arweave. The token’s storage links (CDN, IPFS, Arweave) are registered with the MURI protocol. The engine waits up to 24 hours for the Arweave copy, then registers without it and keeps checking every 6 hours for 30 days.
Every 30 minutes
An audit compares the newest 30 tableaus on-chain with what was published and alerts on any difference.
Every 15 minutes
A monitor reads the balance of every paid dependency and the minter wallet.
The next day
Yesterday becomes final. Its right edge was rewritten by today’s seam, so its final image is the one that is hashed and stored.

Day N, 16:00 UTC

After it

Day N+1, 16:00 UTC

After it

Tableau N

Revealed as generated_N

Entry and steps written to Ethereum

Right edge rewritten by the seam. Published again as updated_N

Hashes committed. IPFS, Arweave, storage links

Tableau N+1

Revealed as generated_N+1, joined to N

Entry and steps written to Ethereum

Two days in order, left to right. A tableau gets its permanent copies only after the next day has rewritten its edge.

Why a day is final a day late

Each tableau is joined to the one before it by regenerating a band across their shared edge. That changes the right side of yesterday’s image. So every tableau exists in two published forms: as revealed (generated_<date>) and as joined by the next day (updated_<date>). The site, the on-chain viewer and the renderer all name every day but the newest by its updated_ files. Image hashes and permanent storage links are only written for the final form.

Catch-up and scheduling

  • The start date is fixed. On every start the engine computes which days are missing since then and generates them in order.
  • The season follows the token id, so one running server carries a season’s last day straight into the next season’s first. No restart at a boundary.
  • In Season 1 the engine warmed up at 15:56 and rechecked the mood at 15:59, so candidates were ready at the close. From Season 2 on it waits for 16:00 and publishes a prepared pick.
  • A dry run mode, toggled at run time, runs a whole cycle with every side effect off: no uploads, no chain writes, no index update, no post.

03

Price and mood

The only outside input is one number: how far PANO/USD moved in a day.

PANO / WETH

The coin's own Uniswap V4 pool

ETH / USDT

A second Uniswap V4 pool

PANO / USD

18 decimals, integer math only

No pool trades PANO against dollars, so the price is two pool reads multiplied. Both are read at the day's first block and at its last.

Reading the price

PANO has no USD pool, so the price is a two-hop product: PANO/WETH from the token’s own Uniswap V4 pool, times ETH/USDT from a second V4 pool. The engine reads each pool’s sqrtPriceX96 straight from the PoolManager’s storage with extsload, at the day’s first block and its last block, four reads in parallel, with no price API in between.

  • All arithmetic is BigInt at 18 decimals. No floating point touches the price. It is stored as a decimal string with 18 digits.
  • A timestamp becomes a block number through Etherscan’s API, with a binary search over block times as the fallback.
  • On launch day the pool did not exist at midnight, so the first block is clamped to the pool’s creation block.
  • Before the pool existed the engine could run with no price source at all. Only the genesis tableau can be generated in that state.
Season 1Season 2Season 3$0.37$0.20$0.207 on #210+12%0-12%#2: +51.51%, Extreme Bliss#3: -1.62%, Mild Suffering#4: -3.36%, Deep Suffering#5: -5.29%, Deep Suffering#6: -0.27%, Equilibrium#7: -2.77%, Mild Suffering#8: -0.24%, Equilibrium#9: -4.18%, Deep Suffering#10: -1.21%, Mild Suffering#11: +1.54%, Mild Joy#12: +5.01%, High Bliss#13: +0.64%, Equilibrium#14: -1.07%, Mild Suffering#15: -2.85%, Mild Suffering#16: -0.27%, Equilibrium#17: +1.06%, Mild Joy#18: -3.96%, Deep Suffering#19: +0.51%, Equilibrium#20: -0.95%, Equilibrium#21: -1.29%, Mild Suffering#22: +2.72%, Mild Joy#23: -3.51%, Deep Suffering#24: -2.65%, Mild Suffering#25: +0.3%, Equilibrium#26: -4.44%, Deep Suffering#27: -0.33%, Equilibrium#28: +0.75%, Equilibrium#29: -0.19%, Equilibrium#30: -0.69%, Equilibrium#31: -2.92%, Mild Suffering#32: +1.75%, Mild Joy#33: +0.96%, Equilibrium#34: -1.95%, Mild Suffering#35: -1.2%, Mild Suffering#36: -3.99%, Deep Suffering#37: +2.2%, Mild Joy#38: -0.2%, Equilibrium#39: -0.73%, Equilibrium#40: -2.1%, Mild Suffering#41: -2.87%, Mild Suffering#42: -3.93%, Deep Suffering#43: -3.11%, Deep Suffering#44: -8.92%, Deep Suffering#45: -4.59%, Deep Suffering#46: +4.63%, High Bliss#47: +3.84%, High Bliss#48: -3.69%, Deep Suffering#49: +1.25%, Mild Joy#50: -0.51%, Equilibrium#51: +1.03%, Mild Joy#52: +1.28%, Mild Joy#53: -0.3%, Equilibrium#54: +10.91%, Extreme Bliss#55: -4.08%, Deep Suffering#56: -0.57%, Equilibrium#57: -5.09%, Deep Suffering#58: +1.45%, Mild Joy#59: +1.86%, Mild Joy#60: -0.51%, Equilibrium#61: +0.8%, Equilibrium#62: -4.94%, Deep Suffering#63: -2.41%, Mild Suffering#64: -2.92%, Mild Suffering#65: +0.55%, Equilibrium#66: +1.62%, Mild Joy#67: -1.55%, Mild Suffering#68: -0.04%, Equilibrium#69: -1.32%, Mild Suffering#70: +3.47%, High Bliss#71: +2.39%, Mild Joy#72: +1.99%, Mild Joy#73: +4.16%, High Bliss#74: -0.93%, Equilibrium#75: +0.73%, Equilibrium#76: +0.53%, Equilibrium#77: -4.14%, Deep Suffering#78: +1.01%, Mild Joy#79: +3.76%, High Bliss#80: +1.33%, Mild Joy#81: +0.36%, Equilibrium#82: -2.38%, Mild Suffering#83: +5.46%, High Bliss#84: +2.89%, Mild Joy#85: -2.54%, Mild Suffering#86: -2.76%, Mild Suffering#87: +0.75%, Equilibrium#88: +1.45%, Mild Joy#89: +1.63%, Mild Joy#90: +1.56%, Mild Joy#91: -0.05%, Equilibrium#92: -2.85%, Mild Suffering#93: -1.74%, Mild Suffering#94: +0.28%, Equilibrium#95: +2.46%, Mild Joy#96: -0.44%, Equilibrium#97: -2.26%, Mild Suffering#98: -0.67%, Equilibrium#99: +1.28%, Mild Joy#100: -3.56%, Deep Suffering#101: -0.08%, Equilibrium#102: -1.13%, Mild Suffering#103: +1.49%, Mild Joy#104: +0.6%, Equilibrium#105: 0%, Equilibrium#106: +2.07%, Mild Joy#107: +0.28%, Equilibrium#108: +0.24%, Equilibrium#109: +0.15%, Equilibrium#110: -2.53%, Mild Suffering#111: -1.18%, Mild Suffering#112: +1.64%, Mild Joy#113: -0.58%, Equilibrium#114: -1.46%, Mild Suffering#115: +1.63%, Mild Joy#116: -0.06%, Equilibrium#117: +1.51%, Mild Joy#118: +0.26%, Equilibrium#119: +8.68%, High Bliss#120: +11.69%, Extreme Bliss#121: +2.94%, Mild Joy#122: +0.66%, Equilibrium#123: +1.12%, Mild Joy#124: +1.99%, Mild Joy#125: -0.35%, Equilibrium#126: -1.22%, Mild Suffering#127: +2.93%, Mild Joy#128: -5.14%, Deep Suffering#129: +2.17%, Mild Joy#130: +1.5%, Mild Joy#131: -0.45%, Equilibrium#132: -0.75%, Equilibrium#133: -2.45%, Mild Suffering#134: +5.21%, High Bliss#135: -2.53%, Mild Suffering#136: +0.26%, Equilibrium#137: +0.82%, Equilibrium#138: -0.39%, Equilibrium#139: +11.75%, Extreme Bliss#140: -11.46%, Extreme Anguish#141: -2.05%, Mild Suffering#142: +4.94%, High Bliss#143: -1.03%, Mild Suffering#144: -1.73%, Mild Suffering#145: +0.72%, Equilibrium#146: -3.34%, Deep Suffering#147: -1.3%, Mild Suffering#148: +3.18%, High Bliss#149: +4.59%, High Bliss#150: +2.28%, Mild Joy#151: -1.09%, Mild Suffering#152: +5.45%, High Bliss#153: -0.44%, Equilibrium#154: -3.26%, Deep Suffering#155: +1.06%, Mild Joy#156: +0.14%, Equilibrium#157: +0.23%, Equilibrium#158: -0.07%, Equilibrium#159: -0.42%, Equilibrium#160: -0.19%, Equilibrium#161: +0.39%, Equilibrium#162: -0.07%, Equilibrium#163: +1.23%, Mild Joy#164: -0.59%, Equilibrium#165: +0.65%, Equilibrium#166: -0.05%, Equilibrium#167: +0.18%, Equilibrium#168: -4.9%, Deep Suffering#169: -5.25%, Deep Suffering#170: +2.24%, Mild Joy#171: +0.85%, Equilibrium#172: +0.97%, Equilibrium#173: -0.18%, Equilibrium#174: -0.55%, Equilibrium#175: -3.43%, Deep Suffering#176: +0.51%, Equilibrium#177: -0.43%, Equilibrium#178: -0.73%, Equilibrium#179: -3.2%, Deep Suffering#180: +10.39%, Extreme Bliss#181: -5.39%, Deep Suffering#182: +2.92%, Mild Joy#183: -4.5%, Deep Suffering#184: +0.36%, Equilibrium#185: -4.14%, Deep Suffering#186: +1.57%, Mild Joy#187: -0.71%, Equilibrium#188: +0.8%, Equilibrium#189: -0.46%, Equilibrium#190: +1.43%, Mild Joy#191: -5.87%, Deep Suffering#192: +0.99%, Equilibrium#193: -0.09%, Equilibrium#194: +0.32%, Equilibrium#195: +1.1%, Mild Joy#196: +5.38%, High Bliss#197: -7.12%, Deep Suffering#198: -0.89%, Equilibrium#199: +0.29%, Equilibrium#200: +0.21%, Equilibrium#201: -4.2%, Deep Suffering#202: -5.74%, Deep Suffering#203: +2.51%, Mild Joy#204: -3.16%, Deep Suffering#205: -3.74%, Deep Suffering#206: -4.11%, Deep Suffering#207: -2.39%, Mild Suffering#208: -0.37%, Equilibrium#209: -0.66%, Equilibrium#210: -1.21%, Mild Suffering#2, +51.5%
The PANO/USD close and the daily change for #2 to #210, from each tableau's published metadata. Bars are coloured by the mood that day was given. #1 is left out: the genesis tableau had no market yet. #2 rose 51.5% and is cut off at the top of the scale.
Tableau #139, Extreme Bliss, +11.75%

Extreme Bliss

+11.75% on #139

Tableau #119, High Bliss, +8.68%

High Bliss

+8.68% on #119

Tableau #84, Mild Joy, +2.89%

Mild Joy

+2.89% on #84

Tableau #33, Equilibrium, +0.96%

Equilibrium

+0.96% on #33

Tableau #64, Mild Suffering, -2.92%

Mild Suffering

-2.92% on #64

Tableau #44, Deep Suffering, -8.92%

Deep Suffering

-8.92% on #44

Tableau #140, Extreme Anguish, -11.46%

Extreme Anguish

-11.46% on #140

One real day for each mood, with the change that set it. #140 is the only Extreme Anguish so far.

Seven moods

Extreme Bliss
+10% or more
High Bliss
+3% to +10%
Mild Joy
+1% to +3%
Equilibrium
within 1% either way
Mild Suffering
-1% to -3%
Deep Suffering
-3% to -10%
Extreme Anguish
-10% or worse

The mood is the only thing the writers and the models are told. No prompt mentions a market, money, a price or a chart. On-chain a tableau stores its price, the change in basis points and a mood index from 0 to 6.

Extreme Bliss
5 days
High Bliss
14 days
Mild Joy
41 days
Equilibrium
79 days
Mild Suffering
36 days
Deep Suffering
34 days
Extreme Anguish
1 day
How the first 210 days fell. More than a third were Equilibrium. One was Extreme Anguish.

Generation state

The engine keeps a small persistent state beside the price: the current streak of rising or falling days, the last ten generations and the count so far. The genesis tableau used a synthetic change of +0.5%, Mild Joy, because there was no day before it to compare with.

04

The engine

A single long-running Node process written in TypeScript. It is the scheduler, the job queue, the admin API and the publisher.

Shape

The entry point builds a Panorama object and hands it to PanoramaServer, an Express app with the admin API, the auth middleware and the scheduler’s main loop. The class keeps the daily cycle and hands three areas to collaborators that take narrow dependency objects, so each can be tested alone.

JobRunner
Every job body: a fresh idea, a regenerated tile, a new seam, a clean-up pass. It also builds the context of yesterday's tableau for the writers.
Publisher
Uploads to the CDN, including yesterday's rejoined copy, metadata reads, the index, the post.
PrefillDesk
The options saved for a reveal: file, copy to another mood, vote, note, delete, reopen.
SessionManager
The live session: candidates, votes, threads, selections. Persisted so a restart resumes it.
OnChainManager
Two persisted job queues that write to Ethereum. See On-chain writes.
CreditsMonitor
Balances of the paid services and the minter wallet.
OnChainAuditor
Compares the chain with what was published.

The pipeline, in order

  1. 1PriceThe Uniswap V4 price fetcher described above.
  2. 2StateStreaks, recent generations, the count.
  3. 3PromptTwo language model calls for a fresh candidate: one writes the day’s idea, the second turns it into the image prompt.
  4. 4ImageA ComfyUI graph generates the tile. A second graph joins it to yesterday. The models changed every season.
  5. 5Post-processMetadata stripped, an optimized WebP and a thumbnail made with Sharp, film grain added to the display copy only.
  6. 6StorageCloudflare R2 behind the CDN, then IPFS and Arweave.
  7. 7ChainThe entry, the steps, the hashes, the storage links.
  8. 8NotifyX and Discord.
Job 1
  1. Idea
  2. Image prompt
  3. Tile
  4. Seam
  5. Candidate
Job 2
  1. Idea
  2. Image prompt
  3. Tile
  4. Seam
  5. Candidate
Job 3
  1. Idea
  2. Image prompt
  3. Tile
  4. Seam
  5. Candidate

Idea and image prompt: two language model calls. Tile and seam: two ComfyUI graphs.

A cycle that wants three candidates. Each job writes its own idea and prompt and sends its own two graphs to the GPU. Up to five run at once.

Jobs

  • The job queue runs a pool of parallel workers. One candidate is one job: a cycle that wants three candidates enqueues three jobs, and each becomes its own prompt and its own GPU submission.
  • The pool size is a console setting, capped at 5. It matches what the GPU provider accepts at once.
  • A custom seed applies only to the first of several jobs. Otherwise every job would return the same image.
  • Retries use exponential backoff, two to the power of the attempt times a base delay, at most five times.
  • The queue keeps the last 20 failed jobs with the real reason, so the console can show a failure where the job stood.
  • The stage of each running job is owned by the server and sent with every state snapshot. A page refresh never loses a card.

Language models

Every model call goes through OpenRouter. Each writer has its own model, reasoning effort, token limit and temperature, layered over shared defaults, plus a free-form JSON of extra request fields merged in last. Prompt caching is on. Reasoning runs but is excluded from the reply.

Prompts are versioned data. Each writer has named profiles; saving one adds a version, an older version can be restored as the newest, and each kind of writer has its own default. The built-in prompts are only the first version.

Candidates and curation

Every candidate ever generated is kept, picked or not: its images, prompt, idea, seed, model, LoRA, the directions that led to it and the thread it belongs to. The images live in a private R2 bucket behind a read-through disk cache with a size cap, least recently used first. The records live on the server’s disk. Intermediate images of each run go to a debug folder that is pruned after 30 days.

Storage

CDN
Cloudflare R2 served at cdn.panorama.garden. Dated file names, so a file never changes once the day is final.
IPFS and Arweave
4everland, through its S3-compatible API. One upload pins to IPFS and syncs to Arweave. The engine reads the object’s metadata afterwards for the IPFS hash and the Arweave transaction id.
Large files
A Season 4 day’s video is about 310 MB. It is hashed and sent to 4everland as a stream and copied between CDN keys on the server side, never held in memory for those steps.
Files per tableau
The full JPEG, an optimized WebP, a thumbnail, a metadata JSON, and the same set again under updated_ once the next day is out.

Metadata

Each tableau’s JSON records the price, the change, the mood, the prompt, the seed, the workflow, the image locations and a generation block: the idea, the LoRA with its strength and look, the tile model, and the ordered list of steps the image went through. The index file lists every tableau and is what the site, the sitemap and the share cards read first.

Credit monitoring

One reading per provider with a status, a remaining amount in that provider’s unit, a burn rate and a runway. A provider that cannot be read reports unknown and never alerts, so a network blip stays quiet. Burn rate counts only decreases, so a top-up never reads as infinite runway. Alerts go to Discord on entering a warning, escalate at once to critical, repeat at most every 12 hours and send one recovery notice. The alert state is committed only after Discord confirms delivery.

  • GPU credits, from an undocumented billing endpoint whose units turned out to be cents.
  • Language model credits.
  • Arweave quota, plus a check of every upload from the last 14 days for a failed or stuck sync. This caught a stretch where every daily image failed to sync.
  • The minter wallet’s ETH, shown as how many tableau entries it can still pay for.

Changelog

The site’s changelog is written in the console, one sentence per entry pinned to a date. Every edit uploads the whole list to the CDN with caching off, and the site reads it from there.

Tests

The engine’s logic is unit tested with Vitest: the reveal gate, the on-chain write decisions, the payload encoders, the prompt parsers, the seam and retouch planners, the Season 4 desk. Model calls and the chain sit behind injected seams so tests run with fakes.

05

Season 1: #1 to #90

The first ninety days. One model extended yesterday's image, a second restyled it, a third hid the join.

Tableau #12, High Bliss, +5.01%

#12 High Bliss, +5.01%

Tableau #54, Extreme Bliss, +10.91%

#54 Extreme Bliss, +10.91%

Tableau #70, High Bliss, +3.47%

#70 High Bliss, +3.47%

Tableau #28, Equilibrium, +0.75%

#28 Equilibrium, +0.75%

Four Season 1 days. The oil look comes from a LoRA applied in the restyle stage.
  1. 01

    Outpaint

    Z-Image Turbo extends yesterday at 640 x 720

  2. 02

    Upscale

    Lanczos to 1920 x 1080

  3. 03

    Restyle

    FLUX.1 Dev with an oil LoRA, 0.6 denoise

  4. 04

    Grade

    Automatic colour adjustment

  5. 05

    Stitch

    SDXL inpaints a 256 px mask over the join

  6. 06

    Clean

    Florence-2 finds, SAM 2 masks, LaMa fills

One Season 1 day, left to right. The coloured edge is the model doing the work: Z-Image Turbo, FLUX.1 Dev, SDXL. The last stage uses three smaller models.

The pipeline

Season 1 ran on a ComfyUI worker deployed to Modal on an H100 GPU, called by the engine with a workflow JSON and base64 images. One graph did most of the work.

  1. 1OutpaintZ-Image Turbo extends the previous tableau at 640 x 720 through a crop-and-stitch inpaint.
  2. 2UpscaleLanczos, to 1920 x 1080.
  3. 3RestyleFLUX.1 Dev with an oil LoRA regenerates the frame at 0.6 denoise, at full size.
  4. 4GradeAutomatic colour adjustment.
  5. 5StitchThe previous right half and the new left half, 960 px each, are placed together. A soft-feathered mask 256 px wide at the centre is inpainted with an SDXL inpainting checkpoint: denoise 1, cfg 2.2, 15 steps, with Differential Diffusion.
  6. 6CleanFlorence-2 finds stray marks and watermarks, SAM 2 masks them, LaMa fills them. A guard skips the step if more than 1% of pixels would change, which protects against a hallucinated detection.
Tableau #54, Extreme Bliss, +10.91%

#54

Mood
Extreme Bliss
Change
+10.91%
Close
$0.2353
Models
Z-Image Turbo, FLUX.1 Dev, SDXL
Seed
797133043013588

Prompt, first sentence

Baroque explosion composition, stormbreak lighting: a sacred procession of massive gilded bulls advances through a columned marble temple precinct, their gilded horns and broad flanks catching a single divine ray that pierces a dense golden cloudbank overhead.

The published record of #54, from its metadata file on the CDN, with the models named.

Genesis

Tableau #1 had no yesterday. It used its own graph with no outpaint and no stitch: text to image, upscale, restyle, grade, clean. It has no marketplace listing and the site treats it as a special case.

Tableau #20Tableau #21Tableau #22Tableau #23Tableau #24Tableau #25
Six consecutive Season 1 days, #20 to #25, as joined. Each was outpainted from the one before it, so the ground runs through from a valley to a pond without a cut.

Two prompt flavours, two workflows

A second workflow outpainted with SDXL and a ControlNet at full size, then refined with FLUX at 0.5 denoise. It was tried for a month in mid-season, 179 candidate runs, and none was published. Each workflow had its own prompt template, 80 to 200 words for FLUX and 60 to 120 for SDXL, with one shared master seed feeding every sampler.

The worker

  • A CUDA 13 image with ComfyUI, about twenty pinned custom node packages, and a custom blend node written for the seam.
  • Models on a Modal volume: Z-Image Turbo with its ControlNet, FLUX.1 Dev, an SDXL checkpoint and ControlNet, LaMa, GroundingDINO, SAM, SAM 2.1, Florence-2, an upscaler.
  • One container at most, four concurrent inputs, scaled to zero after five minutes idle. The engine warmed it up minutes before each reveal.
  • The engine could switch at run time between this worker and Comfy Cloud, each with its own copy of the graphs and its own node id map.

Kept, not deleted

The Season 1 path is inactive but still in the engine, so a Season 1 style image can be generated again. Its graphs are registered on-chain and downloadable from each tableau’s page.

06

Season 2: #91 to #180

Ninety technologies from human history, one a day, each at the mood the price sets. With DeltaSauce. A new model, a new way to write, a new way to join.

Tableau #107, Equilibrium, +0.28%

#107 Equilibrium, +0.28%

Tableau #121, Mild Joy, +2.94%

#121 Mild Joy, +2.94%

Tableau #132, Equilibrium, -0.75%

#132 Equilibrium, -0.75%

Tableau #175, Deep Suffering, -3.43%

#175 Deep Suffering, -3.43%

Four Season 2 days: the telescope, the assembly line, the rocket, the self-driving car. Each technology is shown at whatever mood its day was given.

What changed

Season 1 outpainted each day from the last one, so the model that extended yesterday also decided today. Season 2 separated the two. Each tableau is generated alone, as an independent tile with no knowledge of the image before it, and a second job joins it to yesterday. The tile can then follow its prompt fully, and the join is a small, controlled repair.

Two calls to write one prompt

  1. 1IdeationThe first call writes the day’s idea as a situation with a point: a kind of place and era, the kinds of people there, what they are doing with the technology, and what the situation shows about it. Two to four sentences, 40 to 90 words, deliberately without small details. It returns JSON with a title, the story and a presence.
  2. 2Image writerThe second call owns everything visual. It makes the idea concrete, then writes one paragraph of 60 to 100 words: the subject and its emotion, the real setting of that era, light and colour described the way a cinematographer would, and a short view phrase.

The seven moods are written as three kinds of picture. Equilibrium, Mild Joy and Mild Suffering are this world: a place that existed, at real scale. High Bliss and Deep Suffering are the world transfigured: the idea must name a departure from the real, and the impossible thing must be the largest thing in the frame. The two extremes are the world broken, at the scale of a city. Two neighbouring moods never differ only in tone, weather or palette.

  • Ideation is told yesterday’s story so today does not continue or repeat it.
  • The image writer gets a crop of yesterday’s right edge, 384 px wide, and reads only its geometry: the horizon, the ground plane, the scale, lines running off the frame. It inherits no weather, light, palette, objects or people.
  • Parallel jobs on the same desk are each told the ideas already there, and each plain new idea is assigned a different presence, so three jobs started together do not converge on one scene.
  • A prompt never mentions text, a medium or a style. The look comes from the LoRA and a fixed look phrase.
Tableau #160, Equilibrium, -0.19%

This world

Equilibrium, Mild Joy, Mild Suffering

A place that existed, at real scale.

#160 Equilibrium, -0.19%

Tableau #148, High Bliss, +3.18%

The world transfigured

High Bliss, Deep Suffering

One impossible thing, the largest in the frame.

#148 High Bliss, +3.18%

Tableau #180, Extreme Bliss, +10.39%

The world broken

Extreme Bliss, Extreme Anguish

At the scale of a city.

#180 Extreme Bliss, +10.39%

The three kinds on three days from the last third of the season, after the rule was written: video calling in a near-empty library, a search result opening as a doorway in a bedroom, artificial intelligence as a whole city in flower.

Four writers, one registry

Four kinds of writer run in Season 2, each with its own versioned profiles, model settings and default: ideation, the image writer, the seam prompt writer, and the Ideate agent. A fifth, the Editor, is a chat with an agent that rewrites the other four on request. It answers with exact find-and-replace edits, each landed as a new version, and refuses a passage it cannot match uniquely.

trigger

The LoRA's own word. Fixed.

scene

60 to 100 words from the image writer: who, where, the light. Never a medium or a style.

look

The medium in words. Fixed per LoRA.

What the tile model receives. Only the middle part is written per day.
Tableau #134, High Bliss, +5.21%

#134

Mood
High Bliss
Change
+5.21%
Close
$0.3005
Technology
Space travel
Tile
FLUX.2 Klein, generated alone
Join
Klein fills the band, SDXL cleans it
Seed
431268888548613

Prompt, first sentence

A close-up view from inside a spacecraft hatch shows an astronaut leaning outward against the open door, one arm extended down to grip a strut, the gloved hand resting on a dark handle.

The published record of #134, from its metadata file on the CDN, with the models named.

The tile

Model
FLUX.2 Klein 9B on Comfy Cloud, 1920 x 1080.
Production
The distilled checkpoint: 4 steps, cfg 1. The default.
Base
The base checkpoint: 20 steps, cfg 4. Selectable per generation.
Prompt sent
trigger. scene. look: the LoRA’s trigger words, the writer’s scene, then the look in words.
Default look
“a painted film still, soft simplified shapes and smooth blended colour, natural colours, film grain”. It names the medium only. A look that named colours turned all seven moods the same colour.

An early look phrase named two colours, cobalt blue and marble white. Every mood came out blue: bliss, suffering, all seven. The look now names the medium only, and colour is left to the mood.

Style LoRAs

A LoRA was trained for the season on a curated, captioned dataset of the artists’ reference images. The console keeps a registry of LoRAs: each entry is a file, trigger words, a strength and an optional look. A generation names its LoRA and strength, the server resolves it once when the job is queued, and the choice is recorded on the candidate, in the published metadata and in the on-chain step. Editing or deleting a registry entry never rewrites what an existing tableau used.

Tableau #131, a supermarket at blue hourTableau #132, a rocket on its way to the pad at night
#131 and #132 as they stand joined. The dashed band is the 640 px that was regenerated: 320 px of each day. Everything outside it is each day's own tile, untouched.
The right edge of tableau #131, as revealed

As revealed

The right edge of tableau #131, as joined

As joined

The right third of #131, twice. Left: as revealed on its own day. Right: after #132 was joined to it the next day. This is why a tableau is final a day late.

The seam

Joining is a second ComfyUI job. Yesterday’s right half and today’s left half are placed side by side and a band across their shared edge is regenerated in two passes.

  1. 1Green fillThe band, 640 px wide by default (320 px of each day), is filled green and FLUX.2 Klein 4B with an outpaint LoRA is told to fill the green according to the image.
  2. 2SDXL refineAn SDXL inpainting model with Differential Diffusion refines a narrower strip across the join.
  3. 3BlendThe regenerated band is faded back into both images.

The band can be widened, to 960 px for example, and given its own prompt. A seam can be regenerated without touching the tile: the new take keeps the tile’s seed under a new seam seed.

Grain

Film grain is applied after the seam, to both days, and only to the display copy. The stored master stays clean, so grain never compounds when a tableau is joined again. The default strength is an engine setting, 0.02 on a scale to 0.2.

Retouch

When no single seam take is right, the Retouch editor mixes several by hand. Every re-run of a seam on the same tile is an aligned take. The artist brushes regions of one take over another on the 3840 x 1080 pair, with round or square brushes, hard or soft. The document is an ordered list of strokes, and the rasterizer exists twice, once in the browser and once in the engine, kept identical so the preview is the saved image.

  • Heal edges: where two takes meet with different content, a band around that edge is regenerated with SDXL inpainting so the surroundings meet what was brushed.
  • Region regeneration: the artist brushes a selection, writes what belongs there, and gets one to four variants from Klein green fill or SDXL inpainting.
  • The left half of yesterday is locked. Only the day’s seam may rewrite yesterday’s right half.
  • Every stroke, heal and regenerated region is recorded with its seed and settings and published in the tableau’s step list.

The Ideate agent

Each fresh idea starts a thread. Everything revised from it, every regenerated tile, new seam and clean-up, shares that thread. The artist talks to it. The agent reads the tableau on the easel and answers with speech and a list of up to six actions: revise the idea, revise the prompt, regenerate, re-run the seam, write a new seam prompt, clean. Its direction to the writers is a self-contained brief that carries forward every constraint of the thread still in force.

  • A bare mechanical command such as “try again three times” never reaches the model. It is parsed and run as written.
  • Long threads are summarized on a rolling basis once they pass 80% of a token budget. The last eight messages always stay raw, and nothing is deleted.
  • Up to four reference images can be attached to a message.

Studies

Studies are tableaus made outside the daily cycle with the same two-step writer: standalone, or continuing from any published day. They are never published. They are how prompts, LoRAs and models were tested before a season depended on them.

07

Season 3: #181 to #210

Nothing Remains the Same, with Pale Kirill. Six zones of five days. Each day carries one of his thirty themes. Two image models, chosen per day.

Tableau #181, creator, from the Interface zone

Interface

#181 to #185

Tableau #187, river, from the City zone

City

#186 to #190

Tableau #192, castle, from the Suburb zone

Suburb

#191 to #195

Tableau #196, lamb, from the Village zone

Village

#196 to #200

Tableau #202, hut, from the Nature zone

Nature

#201 to #205

Tableau #208, death, from the Abstract zone

Abstract

#206 to #210

The six zones in order, each with one of its days. Each zone has its own trained LoRA on each of the two models.

Structure

Zones
Interface, City, Suburb, Village, Nature, Abstract. Five days each.
Kinds
Within a zone the days run figure, place, event, object, feeling.
Themes
Thirty, from Creator on #181 to Love on #210.
On-chain
Theme, Zone and Kind are token traits, on revealed and unrevealed tokens.

Interface

#181 to #185

creator

#181 figure

home

#182 place

internal error

#183 event

blueprint

#184 object

passion

#185 feeling

City

#186 to #190

architect

#186 figure

river

#187 place

loading

#188 event

hoop

#189 object

nostalgia

#190 feeling

Suburb

#191 to #195

knight

#191 figure

castle

#192 place

strategy

#193 event

sword

#194 object

hope

#195 feeling

Village

#196 to #200

lamb

#196 figure

garden

#197 place

childhood

#198 event

flowers

#199 object

silence

#200 feeling

Nature

#201 to #205

angel

#201 figure

hut

#202 place

searching

#203 event

monument

#204 object

faith

#205 feeling

Abstract

#206 to #210

soul

#206 figure

basketball court

#207 place

death

#208 event

family tree

#209 object

love

#210 feeling

The season's thirty days. Each zone runs figure, place, event, object, feeling, in that order. In the auction, rank 1 took #181 and each rank below it the next day along.

Before the season, about a thousand tiles were generated and scored against a panorama the two artists had made by hand. The winning prompts were the shortest ones: “ussr brutalism buildings fly above the black river, light pink sky, red lights sunrise”.

Short prompts

Season 2’s long cinematic prompts were dropped. Every Season 3 prompt on Klein is short, in Pale Kirill’s own register: a subject in its place, then the sky and light, 5 to 14 words. This came out of a test of about 1,000 tiles scored against an anchor panorama the artists had made by hand. Short prompts with the zone’s look scored far above long composed text.

  1. 1BriefThe zone, theme, kind and mood, the zone so far (each earlier day’s theme, story line and prompt), and today’s story line.
  2. 2RollA sky and light is rolled from four vivid phrases per mood, and a view: eye level most days, now and then top down or floating above the ground. The artist can pin either.
  3. 3WriteThe prompt writer writes the prompt, a title and a note, avoiding what is already on the desk.
  4. 4Generatetrigger. prompt. look with the zone’s LoRA.

The mood reaches the picture through the sky, never through mood words. A zone’s first day has the story line “the <theme>”. Later days get a line written once from the zone so far, which either artist can rewrite. A change to an existing tableau goes to a prompt editor that rewrites exactly the named change, keeps every other phrase word for word, and keeps the seed.

Tableau #190, Mild Joy, +1.43%

#190

Mood
Mild Joy
Change
+1.43%
Close
$0.2792
Theme
nostalgia, City
Tile
FLUX.2 Klein Base
LoRA
S3 City, trigger word pnrm3c
Seed
980175010435684

Prompt, whole

damaged film photo, soft overexposed flare, green summer microdistrict, tops of five-storey panel blocks, everything in shade except a thin sun ray on balconies and drying clothes, thick foliage, quiet USSR yard

The published record of #190, from its metadata file on the CDN, with the models named.

No people in focus

A prompt with a person in focus is sent back once. The check looks for a word for a person, face, head or silhouette, or a figure theme such as knight or angel, that is not next to tiny, small, distant or far. Small distant faceless figures are allowed.

Tableau #181, Deep Suffering, -5.39%

#181 Deep Suffering, -5.39%

Tableau #195, Mild Joy, +1.1%

#195 Mild Joy, +1.1%

Tableau #200, Equilibrium, +0.21%

#200 Equilibrium, +0.21%

Tableau #209, Equilibrium, -0.66%

#209 Equilibrium, -0.66%

Four Season 3 days from four zones: Interface, Suburb, Village, Abstract. The mood shows in the sky.

Six LoRAs on Klein

One LoRA per zone, trained on Klein 9B Base over clusters of images the artist picked for that zone’s look, each with its own trigger. Interface generates on the 4-step checkpoint, because on Base its LoRA buried half the frame in black pixel blocks. Every other zone generates on Base.

Krea 2

The day’s model is a per-token setting shared by both artists: Klein or Krea 2 Turbo. Krea 2 runs on its own pinned graph: 8 steps, cfg 1, 1920 x 1088 cropped to 1080.

  • Six Krea 2 zone LoRAs, trained on Krea 2 Raw and run on Turbo at strength 1.5, over each zone’s picked images. Captions name only the medium and what is there, never colours or light, so the LoRA carries the look.
  • One all-zones LoRA, trained on Turbo with a training adapter over all 165 images, run at strength 0.6. At 1 it loosens the distillation and tiles go soft.
  • No made-up trigger word. Krea 2 prints unknown tokens as lettering.
  • Krea 2 reads long, coherent prompts. With a zone LoRA the prompt is that LoRA’s caption opening followed by one paragraph of 130 to 180 words. A paragraph under 100 words is sent back once.
  • Every Krea 2 prompt ends with a fixed no-text sentence, added in code.

Measured by CLIP similarity to the nearest dataset images, where the dataset against itself scores 0.795: plain Krea 2 scored 0.725 to 0.736, the Raw-trained LoRA 0.75 to 0.78, the Turbo-adapter LoRA 0.77 to 0.79.

Tableau #193Tableau #194Tableau #195Tableau #196Tableau #197Tableau #198
Six consecutive Season 3 days, #193 to #198, as joined. The first three are in Suburb, the last three in Village.

Three tile guards

Static
The base model diverging into noise, about 1 tile in 100. Detected from the 10th percentile of block Laplacian energy on a small grey copy. Generated again with the next seed, at most twice.
Black frame
Every pixel 0. It comes from the exact text, on every seed, so it is generated once more with one word varied.
Dead frame
An even mush or a flat grey field. Detected from brightness and colour spread. In testing it caught all 9 dead frames and none of 873 real tiles.

When a varied text is used, the candidate stores the text and seed that actually produced it, so the published record stays exact.

Signals

A bidder in the Season 3 auction could attach a message of up to 280 bytes for the day their bid would win. Signals are write-once and stored on-chain in their own contract. A day’s signal is the winning bid’s, else one the holder adds later. The engine shows the signal to the artists in the console. It is never fed to a writer or a model.

08

Season 4: #211 to #270

Sixty days with Dav. A day is a tableau, a piece of music and a build that joins them into a scene drawn live in the browser.

What a day is

The premise and the picture are described on the Season 4 pages. This section is the machinery. A Season 4 day has three parts made separately: a picture, a music render, and a build that puts any picture with any music and runs the steps that turn them into the day’s scene. It is published as the day’s still and a video recorded from the build, and on-chain as the still plus the data the scene is drawn from. The Season 2 tile and seam never run for these tokens.

A street scene as the image model generated itThe same street drawn as fine points of colour in depth
Left: a tableau as the image model generated it. Right: the same street as the page draws it, rebuilt as strokes in depth and laid as fine points. Studio previews from the Season 4 trailer, made before the season began.
A figure in a yellow raincoat with a suitcase walks past coloured shopfronts among dark passers-by

The Newcomer

#211 to #220

A man in a flat cap walks across a dark street towards a black taxi

The Night Worker

#221 to #230

A woman in a green apron carries a dish above a crowded, lantern-hung dining room

The Caretaker

#231 to #240

A woman in a crimson coat with a guitar case stands among embers in a dark hall

The Performer

#241 to #250

A hooded figure in dark blue walks along railway tracks between grey charcoal walls

The Runaway

#251 to #260

A skater in a violet jacket waves at a woman in a crimson coat in a crowd under bright murals

The Young One

#261 to #269

The six who lead the season, in order, with the days each leads. The lead sets the sounds of its days’ music. Trailer stills. More on the six.

The studio

Season 4 was developed in its own repository, the studio, a private Cloudflare Worker. The scene’s page, the story data and a console for making days were written there. The engine and the operator console do not reimplement any of it. Sync scripts copy the console’s code and the scene’s page word for word into the engine, the operator console and this site, and record the studio commit they were copied from in a pin file. The copies are never edited in place.

Steps of a day

  1. 1PromptBuilt from a template: the day’s lead and their look, the scene, the mood. A typed direction is one language model call that rewrites only the scene. The cast, the look and the rules stay the template’s.
  2. 2TableauKrea 2 Turbo on Comfy Cloud, about 20 seconds. Several options to pick from.
  3. 3Cast checkA vision language model reads each new tableau and reports whether the right people are in it. Advisory.
  4. 4JoinThe Season 2 seam, with the cutting moved into the graph. 640 px band by default, 1024 or 1280 on request. About 25 seconds.
  5. 5StrokesThe joined tableau is read for depth and for the direction of its forms and rebuilt as about 52,000 strokes in space, 15 bytes a stroke. People are segmented and identified.
  6. 6GroundThe ground plane is fitted: a horizon and how tall a person stands below it. It can be set by hand.
  7. 7WalkThe lead’s way from yesterday’s tableau into today’s is planned over that ground.
  8. 8PolishLayers for things that stand, and the things that move in life.
  9. 9MusicThe day’s piece is rendered to audio by its own player in a headless browser.
  10. 10BuildThe media folder the scene’s page reads. It points at files the steps already made, so making one copies nothing.
  11. 11VideoThe page is opened in headless Chromium on a GPU and recorded: 1920 x 1080, x264 at crf 24.

Each option remembers a hash of what it was made from. A step is out of date when its pick’s inputs are no longer the current ones. Joining today puts yesterday’s strokes out of date, because its right side changed. One chain per season reads what is missing or stale at every poll and makes it, at most two GPU steps side by side.

Tableau
20 s
Join
25 s
Cast check
15 s
Strokes
35 s
Ground
15 s
Walk
10 s
Polish
55 s
Video
195 s
Seconds per step for one day on warm machines. The video is recorded frame by frame from a headless browser and takes longer than every other step together.

Where it runs

Comfy Cloud
The tableau and the join.
Modal
Everything that needs Python models, Node, ffmpeg or a browser: the cast check, strokes, ground, walk, polish, the music render and the video. A small web function and two step functions, one GPU and one CPU, with a working volume and a model cache volume.
Timings, warm
Cast check 15 s a tableau, strokes 35 s, ground 15 s, walk 10 s, polish 55 s. A cold start is about two minutes. A video is about three minutes a day.
The runner
Holds no key of ours and never calls back. The console sends inputs, starts a step, asks how it is doing, then pulls the results.
Records
One JSON object per season and per job, written only on a matching etag, so two operators' changes both land.

A video is large

The scene is drawn as fine points of colour, which barely compress. A day’s video runs about 70 Mbit/s: some 310 MB on average and about 500 MB for the longest. Frames sit on the season’s 1/30 second grid with no fades, so consecutive days’ videos tile.

The desk

In the engine each token has a desk. It holds the day’s brief, a lane per open mood, every picture and music render, the builds, and what is filed under each mood.

  • Season 4 lanes have no cycle and no safety switch. A lane is a console season of its own: the story up to that day, with the day in the lane’s mood.
  • A driver in the engine moves every season with work on its way one notch every 3 seconds, so work goes on with no page open.
  • Every new picture is joined to the published yesterday by itself, one option at 640 px, as soon as it lands.
  • Day 1 is joined to #210, the last tableau of Season 3. The band lies on day 1’s side only, so #210 is never regenerated.
  • A build is a picture of any lane with a music of any lane. The day plays in the music’s mood.
  • Tools on a build make a new version. Nothing earlier is overwritten.

Decisions and the reveal

A build is filed under a mood. When both artists have picked it, the chain records the videos for that day and for the day before, whose right side was remade. A picked build locks its chain. The reveal publishes only a build that is ready: both picks, fresh videos for both days, the music still the chain’s, and the filed version still the newest.

Publishing a day

  • The build is copied to an immutable, numbered folder on the CDN. A folder is never written twice.
  • The day’s still is published like any tableau’s, in three sizes under its date.
  • The video is published as video_<date>.mp4, a server-side copy, so the file is not sent twice.
  • The day pack, the data the scene is drawn from, is published as daydata_<date>.bin.
  • Yesterday is published again under updated_ names: its still, its remade video and its final day pack.
  • The metadata’s animation_url is the video. The renderer and the on-chain viewer derive every address from the token’s date.

The scene's page

The scene is a WebGL 2 page built on three.js. It lays every stroke at its depth, moves each by its depth as the view travels, and reads the music’s notes to move the picture. It runs standalone, as a recorder’s subject, and as a layer of another page.

  • Embedded in this site’s canvas, the host drives it: the canvas scroll is the scene’s camera one to one, and the host hands it an audio context made in the viewer’s own click, since a frame gets no user activation from its parent.
  • With sound on, the music takes the playhead when the hand lets go and the canvas scrolls to follow the scene’s camera.
  • A device that cannot run it keeps the stills and is offered the recordings. The check reads WebGL 2 support, memory and cores, and the renderer can give up at run time if it is too slow.
  • The page measures what a device can carry and adds finer shadows and fuller light above a base picture that is the same everywhere.

The day pack

One file per day: strokes, depth, the look maps, the walk, the layers. About 426 KB a day on average. The same input always produces the same bytes, which matters because its hashes go on-chain. The day’s music is not in it.

Music, from Panorama's side

Every sound is Dav’s, made by his own contracts on Ethereum. Panorama stores no audio and bundles no player. The interface between the two systems is small.

Panorama gives
For a token: who leads the day (leadOf), the mood index (moodOf) and a list of RPC addresses to read through (getRpcUrlsFor). All three are views on PanoramaSeason4Storage.
Panorama asks
The day’s music, arrangement and melody sound as data, the player’s JavaScript, and up to 16 traits for the token’s metadata.
On a token's page
The page asks the storage which contract is the music controller, reads the day from it at one block, runs the player it returns and plays through the page’s own audio context.
In the picture
The page turns the piece into the notes the strokes answer: kick and snare, hats, the chord layers, the bass, the melody.
At the reveal
The day’s music data is written to the music controller first, then the steps and the entry. After the entry lands the engine reads the music back and compares it with what the video was recorded from. A difference is announced and stops the job.

Before anything is written, a take is played by simulation: the engine answers the reads as the music contracts would with that take on them, using eth_simulateV1, and sends nothing. Music goes on-chain only at a reveal.

09

Smart contracts

Solidity 0.8.34, Foundry, Solady. The token is small and fixed. Everything that had to grow lives in contracts it points to.

Design

Panorama is one ERC-721 with at most 365 tokens. It holds ownership and nothing else of substance. Rendering is delegated to a renderer contract that has no storage and can be replaced. Data lives in storage contracts. That split is why six renderers could ship without touching a single token, and why Season 4 could add a whole new kind of token data beside an immutable storage contract.

Mint controller

A cap per season. Raising it opens a season.

Sale contracts

Each holds the operator right only while it sells.

Panorama

ERC-721. Ids 1 to 365, minted in order. Holds ownership.

Renderer V6

Builds metadata and pages. No storage. Replaceable.

PanoramaStorage

One entry per tableau, images, workflows, viewer template. Immutable.

Season 4 storage

Scene code, day data, holder switches.

Workflow ledger

The ordered steps behind every tableau.

MURI operator V2

Storage links a holder or delegate can manage.

The token in the middle never changes. On the left, who may mint through it. On the right, what it points to: each can be replaced or added to without touching a token.

Addresses on mainnet

Panorama

  • Solady ERC-721. Token ids 1 to 365.
  • mintTo(to, quantity) by the owner or an authorized operator. Ids go out in order. Sales are contracts given the operator right for as long as they need it.
  • The total it will mint is bounded by PanoramaMintController, which holds a cap per season. A season is opened by raising its cap.
  • tokenURI(uint256) returns a token’s metadata. tokenURI() with no argument returns the whole artwork as one token: the coin’s metadata, with an interactive viewer as its animation.
  • EIP-4906 metadata update signals, single and batch, so marketplaces refresh after a reveal or a holder’s change.
  • The SuperRare coin names Panorama as its render contract, which is how the coin shows the artwork.
  • A holder can burn a token. Supply is minted less burned.

Panorama, by function

FunctionWhoNotes
mintTo(address)owner, operatorReverts MaxSupplyReached past the cap.
mintTo(address, uint256)owner, operatorSeveral ids in order.
mintCap()view365 with no controller, else the lower of the controller's cap and 365.
burn(uint256)holder or approvedCounts toward totalBurned.
tokenURI(uint256)viewDelegates to the renderer. Reverts TokenDoesNotExist or RendererNotSet.
tokenURI()viewThe whole artwork.
signalMetadataUpdate()owner, operatorBatchMetadataUpdate over every minted token.
signalMetadataUpdate(uint256)owner, operatorMetadataUpdate for one token.
signalBatchMetadataUpdate(from, to)owner, operatorA range.
setAuthorizedOperatorownerGrants or revokes the operator right.
setRendererownerThe switch every renderer upgrade used.
setStorageContract, setMuriOperator, setMuriProtocol, setPanoramaERC20, setMintControllerownerEach signals a full metadata update.

Name Panorama, symbol PANO. The storage contract, the MURI operator and the renderer count as operators, which is how a storage change can signal a refresh.

PanoramaStorage

One entry per tableau, added in order: price, change in basis points, timestamp, mood index, workflow id, season, seed, prompt, name, description, and the image’s fragment hashes and pointers. It also holds the registered ComfyUI workflows, the viewer’s HTML template in two halves, and the CDN configuration. Large values are stored with SSTORE2, as contract bytecode. This contract is immutable and has no spare field, which shaped everything added later.

A tableau entry, field by field

FieldTypeHolds
priceuint256PANO/USD at the close, 18 decimals.
changeBpsint256The day's change in basis points.
timestampuint40The reveal time. Every file address is derived from it.
moodIndexuint80 Extreme Bliss to 6 Extreme Anguish.
workflowIduint8A registered ComfyUI graph.
seasonuint81 to 4.
seeduint256The generation seed.
promptstringThe prompt as sent.
name, descriptionstringOptional overrides.
imageFragmentHashesbytes32[]keccak256 of each fragment.
imageFragmentPointersaddress[]Where each uploaded fragment lives.
uploadedFragmentCountuint256Progress toward fully on-chain.

A registered workflow holds its name, the graph’s JSON, the GPU and CUDA version it ran on, the sha256 of every model, the name, version and sha256 of every custom node, and the model download links. Ten are registered.

  • Events: EntryAdded, WorkflowAdded, WorkflowUpdated, ImageFragmentHashesSet, ImageFragmentUploaded, TableauFinalized, AuthorizedOperatorUpdated.
  • An upload checks, in order: hashes are configured, the index is in bounds, the fragment is not already uploaded, and the data hashes to the committed value. Errors NoFragmentsConfigured, FragmentIndexOutOfBounds, FragmentAlreadyUploaded, FragmentHashMismatch.
  • The last fragment emits TableauFinalized and signals the token.
  • Per-field setters exist for every field of an entry, for corrections. Escape hatches can set, remove or clear fragment pointers.
  • A hash commit costs about 87K gas plus 26K per fragment. The first 300 image uploads on mainnet averaged 5.0M gas each.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1. Commit

keccak256 of every fragment. About 87K gas plus 26K per fragment.

2. Upload

Any wallet, any order. About 5.3M gas per full fragment.

3. Finalized

The last fragment flips the token to Status: On-chain.

Tableau #183's image is 17 fragments of 24,000 bytes, the last one shorter. The artist commits 17 hashes in one transaction. After that anyone can upload any fragment, and the contract stores it only if it hashes to its committed value. The filled cells show an upload part way through.

Images on-chain

Any tableau’s image can live fully on-chain. The owner or an operator commits the keccak256 hash of each 24,000-byte fragment of the optimized WebP. After that anyone can upload a fragment, and the contract accepts it only if it hashes to the committed value. So the artist decides what the image is, and the cost of storing it can be carried by anyone, a holder included. A full fragment costs about 5.3M gas.

The renderer resolves a token’s image in priority order: the on-chain copy when every fragment is uploaded, else the MURI protocol’s selected link, else the CDN.

1. On-chain

Every fragment uploaded: the image itself, in the answer.

2. MURI

The link the holder picked: IPFS, Arweave or CDN.

3. CDN

An address derived from the token's date.

The renderer tries each source in order and takes the first that answers.

PanoramaWorkflowLedger

Every tableau’s ordered generation steps, on-chain. Up to 64 steps per token, each a workflow id and a JSON of its parameters stored with SSTORE2. The id points at a ComfyUI graph registered in PanoramaStorage, or is a reserved value for a deterministic step such as a composite or grain. The renderer adds the list to the token’s metadata as workflows, ids and parameters only.

PanoramaMURIOperator

The bridge to the MURI protocol, which keeps several storage links per token and lets the holder pick which one is shown. MURI asks the operator whether an account owns a token before any holder action. V2 of the operator also answers yes for a wallet the holder delegated to on delegate.xyz, checking the v2 registry and then v1, so a holder can keep a token in a vault and manage it from a hot wallet.

PanoramaSeason4Storage

Season 4’s bytes, written in the first storage contract’s style and names. Token ids 211 to 270 only.

Scene renderer
The code that draws any Season 4 day from its data, stored once for every token: an HTML template in two halves and the gzipped code in hash-checked fragments. A token’s dynamic scene is that code in its template with that token’s day data.
Day data
One file per day. Hashes committed by the owner or operator once the day is final, fragments uploaded by anyone.
Holder switch
setView: Static video or Dynamic scene. Set by the holder or a delegate. It stays with the token when sold.
RPC addresses
A list set by the artist for every page and a list a holder sets for their own token, tried first. A page reads on-chain bytes through them when they are too large to fit in its own answer. Each address is validated on-chain: http or https, a length limit, printable ASCII without quotes, backslash, angle brackets or a backtick, because the page is written around it.
Token traits
Up to 16 name and value pairs per token, set by the artists.
Music views
leadOf, moodOf, getRpcUrlsFor and the address of the music controller.
Fragment readers
One fragment a call, for day data and for any tableau’s still, so a page can fetch what its answer could not carry.

Every change signals a metadata update on Panorama. Runtime size 15,999 bytes.

Build settings

Compiler
solc 0.8.34, pinned. Optimizer on, 10,000 runs. No IR pipeline.
EVM version
prague
Bytecode hash
none, so the same source always builds the same deployed code.
Fuzz
1,000 runs by default, 10,000 in CI. Invariants 256 runs at depth 64, 512 at depth 128 in CI.
Size
80 Solidity files: 25 of contracts, 24 of tests, 31 of scripts. 658 test functions.
Libraries
Solady throughout: ERC721, Ownable, SSTORE2, Base64, SafeTransferLib. No OpenZeppelin.

Tests

  • Unit suites per contract, and one suite that takes a token of every part of every season through the CDN, MURI and on-chain image paths with every fallback.
  • Fork tests against mainnet: every live token and the whole artwork rendered by a new renderer and compared with the live one before any switch.
  • Each renderer’s deploy script refuses to switch unless sample tokens render byte for byte as the previous version apart from the intended change.
  • A gas table for the largest answers, each row held under 450M gas.
  • The Season 2 auction has 113 tests of its own: unit, fuzz and invariants.

10

Renderer upgrades

Six renderers in seven months. Each one was a deploy, a comparison against the live one, one call to switch, and one signal to marketplaces.

Reading one large on-chain image through the fourth renderer cost about a billion gas. No node will run that, so the image was on Ethereum and nobody could look at it. The fifth renderer returns the same bytes for 188 million.

Six versions

  1. April 2026

    V1

    Launch. Token metadata and the whole-artwork viewer, built on-chain.

  2. 13 July 2026

    V2

    Season 2. Technology trait, readable price, on-chain status, a viewer for phones and marketplace frames.

  3. 14 October 2026

    V3

    Season 3. Theme, Zone and Kind traits, and each token's generation steps from the ledger.

  4. 22 October 2026

    V4

    An Artist trait on every token.

  5. 18 November 2026

    V5

    Season 4. Video and live scene tokens, megabyte answers, base64 written in place, a linked library.

  6. 18 November 2026

    V6

    Prereveal video for unrevealed Season 4 tokens. Live now.

TraitV1V2V3V4V5V6
Mood
Price
Price change
Season
Seed×
Workflow×
Technology
Status
Theme, Zone, Kind
Artist
Lead
Traits set by the artists
Music controller's traits
Token traits by renderer version. A solid square is the version that added the trait, a faint one a version that kept it, a cross the version that removed it. V2 also changed how price and change are written. V6 added no trait: it changed what an unrevealed Season 4 token plays.

How a switch works

The renderer has no storage, so a new one starts with nothing to migrate. The owner calls setRenderer on Panorama and then signals a metadata update. Every token’s metadata changes at once. Before that, the deploy script renders sample tokens through both renderers and stops if they differ anywhere but the intended change.

V1

All rendering logic. The token metadata, with mood, price and seed as attributes and the prompt. And renderPanoramaHtml(), which builds the whole interactive viewer as a data:text/html;base64 address from the template and every tableau’s entry.

V2: Season 2

  • Price as a readable number with up to 6 decimals. “Change BPS” became “Price Change” as a signed percentage.
  • The Seed trait left the attributes. It stays in the viewer’s data.
  • Season is derived from the token id.
  • A Technology trait for #91 to #180, in reveal order, on unrevealed tokens too. All ninety names are in the contract.
  • Status: On-chain once a token’s image is fully uploaded.
  • Viewer template v2: a layout for phones and marketplace frames, native touch momentum, a tiny-embed mode under 300 px, thumbnail blur-up.

V3: Season 3 and the ledger

  • Theme, Zone and Kind traits for #181 to #210.
  • Month and mood names packed into pipe-delimited strings and read by position, to stay under the 24,576-byte contract size limit.
  • The single Workflow trait was removed. Workflow names stay out of token metadata.
  • Reads the workflow ledger and adds each token’s steps as workflows. A missing, reverting or code-less ledger adds nothing.
  • Verified on a mainnet fork: every token #1 to #180 identical to V2 apart from the removed trait.

V4: the Artist trait

An Artist trait after Season, on every token. Live from 22 October 2026. Checked on a fork against V3 for every token #1 to #210. Runtime 22,950 bytes.

V5: Season 4

The largest change. A token could now be a video or a live scene, and its answer could be megabytes.

  • Lead trait and Season 4 naming for #211 to #270. The Artist trait names both artists of a season from Season 2 on.
  • A revealed Season 4 token always has an animation_url, chosen by its holder: the static video or the dynamic scene. Anything missing falls back to the video.
  • The dynamic scene and the still go on-chain independently. Status: On-chain on a Season 4 token means its dynamic scene is on-chain.
  • Token traits set by the artists, then the music controller’s traits, read with a bounded staticcall. A missing, reverting or malformed controller drops only its own traits.
  • The HTML building moved into a linked library, called by staticcall, because one contract could not hold it. Renderer 23,885 bytes, library 19,904.
V4, 1.27 MB still
1,019M
V5, 1.27 MB still
188M
V5, 500 KB still
49M
V5, 100 KB still
7.5M
V5, live scene with its day inside
197M
V5, the whole artwork
186M
provider limit, 550M
Gas to read a token through Panorama, in millions, measured on a mainnet fork. The line is the most a common RPC provider will run in one call. V4 could not return a large still at all.

Token JSON encoded once

The scene’s HTML page encoded twice

The day’s data encoded three times

The scene’s code stored already encoded, copied as is

A Season 4 token's answer is three things nested, each base64 inside the next. The innermost is encoded three times over. The library writes all of it into one buffer of the final size, each piece encoded where it lands.

V5: base64 in place

An on-chain still used to be read through a helper that built the whole data address in memory. A 1.27 MB still cost about a billion gas that way, more than any node will run. V5 sets the JSON before the image aside and the library writes the still’s base64 where it lands. It builds each answer in one buffer of its final size, with every piece encoded in place: code copied as stored, JSON encoded once, HTML twice since the page sits inside the JSON, day data three times since it sits inside the page. Pieces are padded with spaces to multiples of 3 and 9 so nested encodings line up. The same bytes as before at a fifth to a sixth of the gas.

Still, 100 KB
about 7.5M gas to read
Still, 500 KB
about 49M
Still, 1.27 MB
188M. V4 needed 1,019M for the same image.
Dynamic scene by link
about 15M
Dynamic scene, day inside
113M at 412 KB, 197M at 676 KB
Whole artwork
186M with 256 tableaus and 45 dynamic scenes

Panorama copies an answer twice on its way out, so gas grows with the square of its size. V5 keeps to a budget: the day’s data goes inside its page only while the page’s address stays under 2,000,000 characters, the longest Chromium will open in a frame, and the whole answer stays under 3,600,000 bytes. When a page with its day and the still do not fit together, the still yields first and becomes a link. Then the day does, and the page reads it over RPC.

V3
22,602
V4
22,950
V5
23,885
V6
24,223
limit, 24,576
Deployed size of the last four renderers in bytes. A contract cannot exceed 24,576. V6 has 353 to spare, which is why V5's page building lives in a separate library of 19,904 bytes.

V6: prereveal video

V5 by inheritance, overriding one function. An unrevealed Season 4 token keeps its prereveal still as its image and gets a prereveal video with sound as its animation. It links V5’s already deployed library, so the deploy was the renderer alone. Runtime 24,223 bytes, 353 under the limit. Live since 18 November 2026.

Viewer templates

The viewer is a plain HTML, CSS and JavaScript page with no dependencies, stored in PanoramaStorage in two halves around the point where the renderer injects the data. Each half must fit one SSTORE2 write, 24,575 bytes.

v1
The scrollable panorama with each tableau's panel.
v2
Phone and frame layout, touch momentum, OpenSea and terminal links, Season 2 rows.
v3
Season 3 rows on unrevealed slots and in the panel. Only the second half differs from v2.
v4
Season 4. It gunzips the scene renderer and runs it as a module, lays the revealed Season 4 days out as one live strip, reads a still on-chain when the CDN does not answer, and adds pause and volume. If the code cannot load, the days fall back to stills. Prefix 21,789 bytes, suffix 23,507.

11

On-chain writes

The engine writes to Ethereum every day from one wallet, unattended. Most of this section exists because that once went wrong.

Two queues

Writes are jobs in two persisted queues, each run by a worker that watches gas.

Tableau worker
The generation steps and the tableau entry. Budget-capped: an entry may cost at most 0.001 ETH in total, a step list 0.003 ETH. It runs soon after the reveal.
Low-gas worker
Image fragment hashes, MURI registration, Season 4 day data hashes. It waits for gas under 0.5 gwei.

A job can defer without counting as a failure, fail permanently into a dead letter list, or retry. A job that fails three times, is dead-lettered, or has waited too long alerts on Discord.

What is written per tableau

  1. 1StepsappendSteps on the workflow ledger: the ordered list of what produced the image.
  2. 2EntryaddTableauEntry on PanoramaStorage: price, change, timestamp, mood, workflow id, season, seed, prompt.
  3. 3HashessetTableauImageFragmentHashes, once the tableau is final and gas is low.
  4. 4LinksinitializeTokenData through the MURI operator: the CDN, IPFS and Arweave links and the file’s sha256.

The steps, for reproducibility

From Season 2 on every tableau publishes the steps it went through, in its metadata and on the ledger: the tile with its seed, size, LoRA file, strength and look; the seam with its seed, width and prompt; a clean-up pass if one ran; then each retouch pass with its takes, its strokes simplified to whole pixels, its heals and regenerated regions; and grain. A Season 4 day lists its tableau, join, strokes, ground, walk, polish, music and build, each with a hash of its inputs, and the studio commit the code came from.

Seasons 1 and 2 were backfilled by script from the published metadata and the on-chain seeds, marked as backfill.

Tableau worker

Sends the day’s entry with nonce n and no tip.
Replaced. Never mined. The job reads a receipt and logs success.

Low-gas worker

Sends image hashes with the same nonce n and a tip.
Mined. Its receipt is what the other job was handed.

Five entries went missing this way. The next entry that did land took the first empty slot, so day #187 was written into slot #183.

What happened at 16:00 on five days in October 2026. Two workers, one wallet, the same nonce. The network keeps the transaction that pays more.

The incident

From 22 October 2026 the entries for #183 to #186 and #188 never landed. Both workers were sending from one wallet at 16:00 with no shared nonce. A tipped hash or MURI write took the nonce of an entry sent with no tip. The client’s receipt wait resolves with the replacing transaction’s receipt, so the entry job logged success and was dropped. And because an entry takes the next free slot, day #187 then landed in slot #183.

The rules since

  • One sender for every write from the minter wallet. It sends one transaction at a time, waits for the previous receipt, counts nonces itself as well as from the node, and throws unless the receipt is the sent transaction’s own and it succeeded.
  • An entry job carries its real token id and is sent only when the contract’s entry count is exactly one less. It waits while an earlier slot is empty, is done when its slot already holds it, and refuses with an alert when its slot holds another tableau.
  • The sent transaction hash is saved on the job, so a retry looks it up before sending again. The receipt must carry the entry event for that token.
  • Fragment hashes wait for their entry and skip when equal. Ledger steps are read back after the write. MURI registration skips a token that already holds its links.

The audit

Every 30 minutes an auditor checks the newest 30 tableaus against the index and metadata on the CDN. It builds the expected entry with the worker’s own payload code and compares field by field. It reports an entry missing 45 minutes after publishing, missing ledger steps, missing fragment hashes after 24 hours, and a missing MURI registration or Arweave link 26 hours after the next day is out. It posts when a problem appears, every 12 hours while any remain, and once when all are clear. A failed read never alerts.

The repair

A script plans a repair from the chain and the public CDN alone. Dry run by default.

  • Wrong fields of a slot are corrected through the storage’s setters.
  • Missing entries are added in order, each only when its slot is next.
  • Fragment hashes are committed from the CDN’s image only when that image is proven to be the published bytes, by MURI’s stored sha256 or by hashes already on the slot.
  • It refuses to broadcast while the minter has a transaction pending, checks the base fee before each send, stops if a slot moved under it, reads everything back and writes a report.

The plan that fixed the incident: seven setters and 17 hashes on #183, entries with their hashes for #184 to #188, and the missing steps. Fourteen transactions. All 210 entries now sit in their own slots.

Permanent storage

Up to three links per token are registered with MURI: the CDN, an IPFS gateway address and an Arweave address. If the Arweave copy has not synced after 24 hours the token is registered without it, and a follow-up job re-registers it with the link once the copy exists, but only while the token is exactly as the engine wrote it. If the holder has changed anything, the engine leaves it alone.

Season 4 additions

  • Nothing of a day’s video or data is written on its reveal day. The renderer derives both addresses from the token’s date, so publishing the files is enough.
  • When day N is revealed, day N-1 becomes final: its still’s hashes, a MURI record whose artwork is the video with the still as thumbnail, and the keccak256 of each 24,000-byte fragment of its final day pack.
  • The audit and the repair cover all of it, comparing the chain with hashes recorded in the published metadata.

12

Operator console

A private web app where the artists make each day. It is a view of the engine. Every job, stage and failure is the server's, and the page only shows it.

Shape

A separate Next.js app in its own private repository, served from the same server as the engine. It was split out of this site so that full-resolution image proxies and a long-lived event stream never run on the public site’s hosting. The browser talks only to the console’s own API routes, which proxy to the engine and stream images with range requests.

  • Each artist signs in with their own secret. An artist with no secret configured simply cannot sign in.
  • The pair for a day comes from the season. An artist outside the pair can look at everything and change nothing. The server refuses the mutation as well as the page disabling the button.
  • State arrives over server-sent events. The full snapshot is re-sent every 10 seconds, so a missed event heals without a refresh.

The Workshop

The console’s root for Seasons 2 and 3. Three resizable panes: the work edge to edge, a strip of candidates under it, and one rail on the right.

Lanes
Up to seven, one per mood, open as tabs over one non-publishing cycle. Two artists can work in different moods at once from two browsers.
The easel
The selected candidate joined to yesterday, scrollable, with chips on the image: enlarge, retouch, add to Decisions.
The strip
Every candidate and every job in flight, in order. Windowed: only the tiles in view are mounted. Measured on 400 tiles, a strip update went from about 52 ms to about 7 ms.
Ideate
The chat with the Ideate agent, one thread per idea.
Instructions
The controls by hand: the prompt, seam width and seam prompt, LoRA and strength, tile model, copies, seed, grain.

A Workshop session survives a restart of the engine: lanes, candidates, votes, notes and selections come back. Generation that was in flight does not, and the restore notice says so.

Extreme Bliss
High Bliss
Mild Joy
Equilibrium
Mild Suffering
Deep Suffering
Extreme Anguish
Tableau #109, standing in for yesterdayTableau #110, standing in for the selected candidate
Easel

Strip: every candidate and job in flight

InstructionsIdeate
  • Prompt

  • Seam width

  • Seam prompt

  • LoRA and strength

  • Tile model

  • Copies

  • Seed

  • Grain

The Workshop's layout, redrawn. Seven lanes as tabs, the easel with the selected candidate joined to yesterday, the strip under it, one rail on the right. The easel here holds two published days, #109 and #110, as stand-ins for a candidate and its yesterday.

Decisions

Where options are picked. The seven moods down the left, the open mood on the right with both artists’ picks. An option can be reused in a second mood. When the newest published tableau changes after an option was saved, the option is marked stale.

Retouch

The seam editor described under Season 2: takes as layers, brushes, heal and region tools, undo as snapshots of the stroke list, and keyboard shortcuts for every tool. It keeps a full-resolution composite that is rebuilt only when the stroke list changes and redraws only the dirty region during a stroke.

Prompts

Every prompt the writers run is edited here: profiles with versions, a preview of the exact system message a writer receives, per-writer model settings, and a fold-out of the request body that will be sent. For Season 3 the page is a walk through how a day is made, seven steps each with its prompt editable in place, and a test bench that runs a day without generating an image.

Library pages

Studies
Tableaus outside the daily cycle, as a desk with its own threads.
LoRAs
The registry: file, trigger words, strength, look, season and zone.
Credits
Balances, burn rate and runway of every paid dependency, with editable thresholds.
Changelog
The site's changelog editor.

The day, for Season 4

Once a Season 4 token is next, the console’s root turns into a different page by itself. Mood first: seven tabs, each opening a board with three independent columns.

Pictures
Generate from the brief or from a direction, one, two or four at a time. Each shows who made it and a failed cast check in a few words.
Music
The takes of the day's music in that mood, each with where it stands.
Builds
Any picture with any music. What is filed, both artists' picks, the state of the videos.

Each column opens a studio, a whole page with the work, a strip of everything made in the mood, and a rail with an agent tab and a controls tab.

  • The picture studio shows the panorama from day 1 to today with the open picture joined on. It has the prompt, the join with its band width and options, and a brush to regenerate a region. A failed cast check opens a guided three-step fix.
  • The music studio is the musician’s own lab page in a frame, opened on a take. Nothing in it writes to a contract.
  • The build studio plays the build in the scene’s own page. Its tools: join again, retouch the join, redo any step for today or yesterday, set the ground by hand, map the walk by hand, per-day sliders for the points, and record the videos.
  • The framed page never reloads under the artist. A new version loads in a second frame behind and takes the front once it has drawn.
  • A studio agent answers and acts as the artist who wrote. It never votes.
  • Presence: the page reports where each artist is every 8 seconds and shows who is in which mood.
  • Below 1024 px the whole console restacks for a phone.

13

The site

panorama.garden is a Cloudflare Worker. It reads the CDN for what was made and the chain for who holds it.

Stack

Framework
Next.js 16 App Router with React 19 and TypeScript, built with vinext, Cloudflare’s Vite reimplementation of Next, and served as a Worker.
Styling
Tailwind CSS 4. IBM Plex Sans and Mono. Seven mood colours as CSS variables.
Chain
viem on the server, wagmi in the browser, WalletConnect and injected wallets.
Bindings
A KV namespace for the data cache, the Cloudflare Images binding for share cards, static assets.
Deploys
Every push to the main branch builds and deploys. CI runs a dependency audit, lint, typecheck, build and a smoke test against the built Worker.

Shaped by Workers

  • No native modules. The share card is resized with the Images binding where a Node server would use an image library.
  • Every outbound fetch counts toward a per-request limit, so the server’s chain client batches JSON-RPC calls. A cold sweep of the Season 2 auction is five requests.
  • A Worker cancels a request whose promise is settled by I/O that another request started. So the chain client is made once per request, never at module scope, and no in-flight promise is shared between requests.
  • Remote images from the CDN are served as they are. Only local images go through the optimizer.

Pages

PathWhat it is
/A drifting filmstrip of the real panorama from the CDN index, the mood system, the seasons.
/canvasThe artwork: every tableau edge to edge, scrolled sideways, with the price line under it.
/tableau/[id]One day: the image, its record, its prompt and seed, its holder, and the workflow files to download.
/terminalTrade the coin and see the mood your trade would set.
/statsMood distribution, market figures, how much of the work is on-chain.
/collector-zoneFor holders: on-chain uploads, storage links, signals, Season 4 switches.
/season-4Three pages on the season, its six leads and how a day is made.
/season2-auction-statsA live report on the Season 2 auction, replayed from its event log.
/aboutThe work, the moods and the seasons in plain language.
/changelogWhat changed on the site, by date.

The canvas

Every slot of the year, scrolled horizontally with a virtualizer, so only the tiles near the view are mounted. One hook orchestrates eight smaller ones. Unrevealed slots show what is known about the day: the Season 2 technology, the Season 3 theme and zone, the Season 4 lead.

From #211 the same scroller runs into Season 4 with no switch. A Season 4 slot is wider than a tableau, because the scene draws a day with its own camera: 62% of a day’s height in the frame. A geometry module answers where each slot starts and how wide it is, and the virtualizer, the price line and the scene layer all read it.

  • Over the revealed Season 4 slots sits a pinned copy of the scene’s page in a frame, driven every animation frame by the canvas scroll.
  • At the edge between #210 and day 1, a stretch of fine dabs turns the still into points before the live picture takes over. It is drawn from one 384 px tile of marks repeated as a pattern, without reading pixels back, so the work does not grow with the screen.
  • The frame loads when the view is within 1.5 viewports of the season and is let go past 4.
  • Sound starts by itself where the browser allows it. Where it needs a gesture, a veil asks once.
  • Where the scene cannot run, the canvas keeps the stills and offers the recordings: one video element that moves to the slot under the view, because a phone allows sound per media element and a weak device decodes one film.
Tableau #209 in a 16:9 slot

A tableau, 16:9

A Season 4 street drawn as points, cut to the wider slot

A Season 4 day, 1.61 times as wide

Two slots of the canvas at one height. A Season 4 day is 1.61 tableaus wide, because the scene frames 62% of a day's height. The right slot holds a trailer still, standing in for a live day.

Tableau pages and reproducibility

Every day up to #210 has a page, revealed or not. An unrevealed day shows its prereveal image, what is known about it and its reveal time. A revealed Season 1 or 2 tableau offers the exact ComfyUI graph that generated it as a download, next to its prompt and seed.

Collector Zone

  • Lists the connected wallet’s tokens and those of any vault that delegated to it on delegate.xyz, v2 and v1.
  • Image upload: the page fetches the token’s optimized image, splits it at 24,000 bytes, checks every fragment’s keccak256 against the committed hashes before offering a transaction, then uploads fragment by fragment with pause and resume.
  • MURI controls: add or remove storage links, pick which is shown, pick the thumbnail, the display mode.
  • Season 3: read or add the day’s signal, with an inline confirmation that it is permanent. The write is simulated first.
  • Season 4: switch between static video and dynamic scene, upload the day’s data, upload the still, and set the token’s own RPC addresses, each checked with the contract’s own rule before it is added.

Share cards

The raw tableau files are 1920 x 1080 and 1.4 to 3.1 MB, which X degrades to a small card with no image. So cards go through a route on the site that fetches the image, cover-crops it to a 1200 x 630 JPEG of 50 to 180 KB with the Images binding, and serves it from the site’s own origin. The file name is validated against a fixed pattern, so the route is not an open proxy. Any failure redirects to the brand card, so a share never lands without an image.

Server routes

RouteWhat it doesCache
token-holderLive ownerOf, classified as treasury, auction or collector.30 s
token-metadataA token's metadata through the CDN index.30 s
vendor-stateWhich days have left the treasury, by multicall.30 s
season2-auction-statsReplays the auction's event log into a payload.15 s
season3-winnersThe winning bid per day from the auction's logs.15 s
tx-statusA receipt lookup with an 8 s timeout.none
og/segmentThe share card.1 h to 1 day
opensea/statsCollection stats. The API key stays on the server.60 s
changelogThe changelog from the CDN.none
portraitsPages through the portrait index.1 h

14

Terminal

A trading page where the thing you watch is the picture. Type an amount and see which mood the day would land on if you sent it.

Layout

Four panes in nested, resizable splits whose ratios are remembered per browser: the projection with the chart over it, recent trades and top holders, the trade console, and stats. On a phone they stack. Each pane is mounted exactly once, switched by a JavaScript media query, not hidden by CSS.

Tableau #84, a Mild Joy day, as the projectionProjection: the mood this trade would set

Recent trades

Top holders

Trade console

BuySell

Amount, quote, price impact, slippage

Stats

The terminal's four panes at their default sizes: 70 / 30 across, 70 / 30 down the left, 55 / 45 down the right. The picture is #84, a Mild Joy day. The candles are #181 to #210 from the closes alone, so they have bodies and no wicks.

Since the last reveal

Live price against the newest tableau's recorded price

Your trade

Price impact of the amount typed

Projected change

Against the seven thresholds

A mood, and a picture

A real past day from that mood

The two moves are compounded, so a trade's effect is measured from where the price already is.

The mood projection

  1. 1Live changeThe current PANO/USD from the indexer against the price stored in the newest tableau’s metadata. This is the move since the last reveal.
  2. 2Trade impactThe price impact of the amount typed, from the quote.
  3. 3CompoundThe two are compounded, not added: (1 + live)(1 + impact) - 1.
  4. 4MoodThe projected change maps to a mood with the same thresholds the engine uses.
  5. 5ImageA past tableau from that mood is shown. The pick is seeded and re-rolled each time the mood changes, so a new mood shows a different example. An empty mood walks outward to its neighbours.

The image is decoded off-screen and swapped in only once loaded, so the pane never flashes. After the first image shows, up to six more are preloaded at low priority during idle time, three on a slow connection and none with data saver on.

The chart

  • Daily candles from the indexer, drawn with TradingView’s lightweight-charts.
  • A day runs from 16:00 UTC to 16:00 UTC, the same day the engine uses, and each candle is labelled by its close.
  • Where a tableau exists for a day, its recorded price overrides the indexer’s close, so the chart agrees with the canvas exactly.
  • Each candle’s open is the previous close, so candles have no gaps.
  • A hollow projection candle in today’s slot shows only the typed trade’s effect.
  • The tooltip gives open, high, low, close, the mood that change would be, volume and trade count.

A swap

The pool is PANO/WETH on Uniswap V4 with a fee of 0, tick spacing 60 and SuperRare’s guard hook. Every swap goes through SuperRare’s LiquidRouter, which wraps Uniswap’s Universal Router. The page builds the router commands itself.

Buy
Wrap ETH, then a V4 swap: settle WETH from the router’s balance, swap exact in, take all PANO. Sent with the ETH as value.
Sell
A V4 swap, then unwrap WETH to the sender: swap exact in, settle all PANO, take WETH. The router pulls the PANO, so a sell needs one ERC-20 approval first.
Deadline
600 seconds.
Slippage
1% by default. Presets of 0.5, 1 and 2%. Custom from 0.10 to 50%, with a warning above 5%. The minimum out is rounded down.
Gas reserve
The max button on a buy leaves 0.002 ETH.

Addresses and constants

NameValue
PANO (ERC-20)0x74B8174a862B098DB9A44E0C553A3bFa79EF602d
LiquidRouter0xebd58eda8408d9ea409f2c2be8898bd9738f3583
Uniswap V4 PoolManager0x000000000004444c5dc75cB358380D2e3dE08A90
Uniswap V4 Quoter0x52F0E24D1c21C8A0cB1e5a5dD6198556BD9E1203
WETH0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
Pool hook0x322D4F640a5263Fc4E28C3896009502453d620cC
Pool keycurrency0 PANO, currency1 WETH, fee 0, tick spacing 60
PANO/WETH pool id0xa0366d70dab23ef4afc1d27c72d389068bfc89c2962a0084accd0c3b29431d7a
ETH/USDT pool id0x90078845bceb849b171873cfbc92db8540e9c803ff57d9d21b1215ec158e79b3
Router commandsV4_SWAP 0x10, WRAP_ETH 0x0b, UNWRAP_WETH 0x0c
V4 actionsSWAP_EXACT_IN_SINGLE 0x06, SETTLE 0x0b, SETTLE_ALL 0x0c, TAKE 0x0e, TAKE_ALL 0x0f
Quote probemax(amount / 10,000, 1e12 wei)
Input caps999,999 ETH on a buy, 1,000,000 PANO on a sell

Quote and price impact

Three quotes are simulated on the V4 Quoter at one pinned block, in parallel: the amount, a small probe, and the amount plus the probe. The probe is a ten-thousandth of the amount. Price impact is the ratio of what the probe buys before the trade to what it buys after, computed in scaled integers. That is the trade’s effect on the pool’s spot price, the number the mood depends on. Taking a ratio cancels the hook’s proportional fee. It is not average execution slippage.

  • Quotes debounce by 100 ms, refresh every 12 seconds and are marked stale after 15.
  • Before the wallet opens, the full router call is simulated from the user’s account, so a doomed transaction shows its reason first.
  • Reverts are mapped to one short line: rejected in wallet, price moved, insufficient funds, expired, pool inactive, wrong network, transfer failed.
  • A receipt that cannot be polled reads as confirmation delayed, never as a failure.

Trades, holders, stats

Recent trades poll every 30 seconds, prepend unseen rows and page backwards on scroll. Top holders poll every 60 seconds, with ENS names. Stats show price, the change since the last tableau, market cap against the fixed supply of 1,000,000, 24 hour volume, the pool’s ETH, and the collection’s floor, volume and owners from OpenSea.

RPC

The browser reads the chain through a fallback list of ten public RPC endpoints, scored and ordered, with no per-endpoint retries and a 10 second timeout each.

15

Indexer and stats

A small service that follows the coin's pool block by block and answers the questions the terminal asks.

What it is

A Ponder app with a Hono API on PostgreSQL, running on the project’s server at indexer.panorama.garden. It indexes mainnet from the block the pool was created.

Swap
Every swap in the PANO/WETH pool, from Uniswap's PoolManager, filtered to the pool's id at the RPC level.
Transfer
Every PANO transfer, kept as a running balance per holder.
RouterBuy
Every buy through the router, so a buy is credited to its real recipient.
Block tick
Every 30 blocks, about 6 minutes, a check for a crossed day boundary.

On-chain event

Table

Endpoint

Swap

Every swap in the pool

swap, candle1m, candle1h, candle1d

/price /trades /candles /summary /liquidity

Transfer

Every PANO transfer

holder

/holders

RouterBuy

Every buy through the router

routerBuy

/trades, for the real buyer

Block tick

Every 30 blocks

dailyCloseSnapshot, candle1d

/candles, the day's exact close

Each row is one thing the indexer listens for, the tables it writes and the endpoints that answer from them.

The same price as the engine

PANO/WETH comes from the swap’s own sqrtPriceX96. ETH/USD is read from the same V4 ETH/USDT pool the engine reads, by the same storage read, at the swap’s own block. So the price in a tableau’s metadata and the price on the chart match to the wei. Everything is integer math at 18 decimals, sent as decimal strings.

Schema

TableKeyColumns
swaptransaction hash, log indexblock, timestamp, sender, both token deltas, sqrtPriceX96, tick, liquidity, fee, price in WETH and USD, ETH/USD at that block, volume in PANO, WETH and USD
routerBuytransaction hash, log indexpayer, recipient, ETH in, fee, ETH swapped, tokens received, protocol and beneficiary fees
candle1m, candle1h, candle1dinterval startopen, high, low, close in WETH and USD, three volumes, trade count
dailyCloseSnapshotbucket startthe block and time the close was taken at
holderaddressbalance, updated at. A row that reaches zero is deleted.

Everything starts at block 24,943,702, where the pool was created.

Candles

One-minute, one-hour and one-day candles are updated on every swap. Daily buckets are offset to 16:00 UTC. On the first tick after a boundary the indexer finds the last block at or before it, reads both pools at that block again and overwrites the day’s close with the boundary price, the exact number the engine will use. A day with no trades gets a flat candle.

API

EndpointAnswers
/priceThe latest swap's price, with USD recomputed against live ETH/USD.
/candles1m, 1h or 1d candles, with the current empty bucket synthesized.
/tradesSwaps newest first, with a cursor. Buyer and payer on buys.
/summaryOpen, close, high, low, change and volume over 1h, 24h, 7d or 30d.
/liquidityThe pool's WETH, summed from every swap.
/holdersTop holders and the holder count.
/graphqlPonder's generated GraphQL over every table.

How the site reads it

Each endpoint has a hook backed by a module-level store, so one poll serves every component on the page. Price polls every 12 seconds, trades and liquidity every 30, candles, holders and the summary every 60.

Deploys without a gap

A release is keyed by the hash of the indexer’s own folder, so unrelated commits never re-index. A new release indexes from scratch into its own database schema on a second port while the live one keeps serving. That takes about a minute, thanks to a cache of RPC responses. Once it reports ready it takes over, with about 25 seconds of downtime. The previous release and its schema are kept for a rollback.

The stats page

Mood distribution and the day-by-day ribbon come from the complete metadata on the CDN. Market figures come from the indexer and OpenSea. The permanence block reads PanoramaStorage directly: for every revealed token, how many image fragments are uploaded out of how many, and so how many tableaus are fully on-chain.

16

Sales

Each season was sold a different way. Three of the four needed their own contract.

The coin

PANORAMA is a SuperRare Liquid Editions token, with no custom token contract. All 1,000,000 tokens went into a Uniswap V4 bonding curve at launch. No tax, no burn. The coin’s contract names Panorama as its render contract, so the coin’s own metadata is the whole artwork, served by the no-argument tokenURI().

Season 1

Season 1 launched with SuperRare. Each new tableau was minted to the treasury, the contract’s owner, and collected from there. Secondary trading is on OpenSea.

paid by every winnerrefunded to winnersoutbid, already refundedclearing price
The shape of a uniform-price auction, not real bids. Bids are sorted from highest to lowest. The top 90 win, and all of them pay what the 90th bid offered. The pale part above the line is refunded at settlement. Bids below the line were refunded the moment they were displaced.

Season 2: one clearing price

A custom contract sold #91 to #180 in a multi-unit English auction with a uniform clearing price. Bidders bid the most they would pay. The top 90 bids won and every winner paid the 90th-highest bid. The excess was refunded at settlement.

Escrow
Only the top 90 bids hold funds. A displaced bidder is refunded in the same transaction that displaces them.
Data structure
A 1-based binary min-heap with a position map. The root is the clearing floor. Equal amounts tie-break to the earlier bid.
Per wallet
Up to 4 independent bids, each of which can be raised.
Reserve
0.1 ETH, floored in the contract.
Increment
A new bid into a full book must beat the lowest winner by a set percentage, rounded up, never down.
Anti-snipe
A qualifying bid in the last 5 minutes sets the end to 10 minutes out, capped at 24 hours of total extension. Inside the window a too-small raise reverts, so a raise cannot be split to dodge the rule.
Order
Winners are minted highest bid first: the top bid gets #91, the earliest reveal.
Settlement
Authorize, set the exact cap, finalize in batches, revoke: one closed sequence, so no privileged mint window stays open. About 8.1M gas for 45 winners.
Failsafes
Cancel and refund, permissionless recovery if an outside mint consumes an expected token id, and a permissionless emergency refund after a long grace period.
Payout
Split 58/42 between the two artists on the last batch.

113 contract tests: unit, fuzz and invariants on the heap property, exact solvency through settlement, no over-mint and the per-wallet cap. Playwright end-to-end tests ran the site against a local chain: bidding, displacement, the anti-snipe extension, wallet rejection, batched settlement, refunds. The contract was formally audited in July 2026.

The auction site ran a clock anchored to block timestamps, never the device’s. It locked every write the moment its reads were stale. It simulated every transaction first so a revert showed a decoded reason before the wallet opened. The stats page on this site replays the event log exactly, sampling the clearing price once per transaction, because a displacing bid emits two events and sampling per event would draw a dip that never happened.

Season 3: a bid picks its day

The same contract with changes. Thirty units. Two bids per wallet. Every bid a whole number of 0.001 ETH ticks. And once the book is full, amounts must be unique, so every rank is distinct: rank 1 gets day 1. A bidder could see which day and theme a typed amount would land on. A bid could carry a signal.

The auction settled with 22 winners. The eight days it left open were each put on a reserve auction on Manifold’s marketplace.

Season 4: in order, at a fixed price

#211 to #270 are sold at 0.1 ETH through OpenSea’s SeaDrop. Panorama has no SeaDrop functions, so the drop runs through a mint adapter: SeaDrop treats the adapter as the token contract, and each purchase makes it call mintTo on Panorama. The buyer is the token’s first holder and ids go out in order.

StageWindowWhoLimit
Phase 1Nov 19, 15:00 to 16:00 UTCHolders of Panorama and Ephemera, and Dav’s collectorsUp to 2 a wallet
Phase 216:00 to 17:00 UTCHolders of Normies, The Vessel, The Vessel Sequences and Terraforms, and Pale Kirill’s and DeltaSauce’s collectorsUp to 2 a wallet
Phase 317:00 to 18:00 UTCHolders of FREEDZ, 1337 Skulls, Song a Day, BGANPUNKS V2, Talismans, The Block, CypherDudes and JPEG FrensUp to 2 a wallet
Public18:00 UTC to Dec 31AnyoneUp to 2 a wallet in all
  • Three things bound it: the adapter’s own supply of 60, the mint controller’s cap, and one call on Panorama that stops every stage at once.
  • Allowlists were snapshotted from holders of chosen collections by script, with a check that refuses a wallet repeated across lists that must not overlap.
  • The only contract written for it is the payout: a split with no owner and no storage, payees fixed at deploy, released by anyone. Its transfers cannot be blocked by a payee that refuses ETH.
  • The same tests run locally against real Panorama bytecode and on a mainnet fork.

17

Infrastructure

One server that can be rebuilt from a repository, with Cloudflare in front of everything.

A visitor

Or a marketplace, a wallet, a bot.

Cloudflare

DNS, proxy, TLS.

Workers

This site, the sale sites, the studio, the uptime checker.

R2

The CDN bucket, the candidate archive, studio media.

One server, defined in Ansible

nginx

The only door in.

Engine

Bun, systemd.

Console

Next.js.

Indexer

Ponder on PostgreSQL 18.

Bots

Sales and offers.

Everything public passes through Cloudflare. The server accepts web traffic from nowhere else, and each service listens only on the machine itself.

The server

A single dedicated machine on Ubuntu, configured entirely by Ansible. Nothing is edited on the server by hand: a change is made in the repository, checked as a diff, applied, committed. A rebuild from scratch was tested and came out identical.

Engine
Run by Bun as a systemd service.
Console
A Next.js server, started after the engine.
Indexer
Ponder, with PostgreSQL 18.
Bots
The sales bot and the offer bot.
Proxy
nginx, terminating TLS with a Cloudflare origin certificate. The console's event stream has its own unbuffered location.

Every service runs as an unprivileged user in a sandboxed unit, listens only on loopback, and is reachable only through Cloudflare. Secrets live in an encrypted vault, and a commit hook refuses an unencrypted one.

Deploys

A timer checks the repositories every minute. The changed paths decide which service updates. An update installs from the lockfile, restarts, and checks 15 seconds later that the service is still up with no new restarts. If not, it resets to the previous commit, restarts the old version and records the bad commit so it is not retried until a newer push. Each result is posted to Discord.

Backups

Encrypted, deduplicated snapshots every two hours: the engine’s data and the server’s own configuration. Candidate images are not in them, since they live in object storage. Once a month the newest snapshot is restored into a scratch directory, its key files are parsed, and up to 200 random files are compared byte for byte with the live ones.

Monitoring

  • Every 5 minutes on the server: failed or restarting units, core services, disk, backup age. Alerts only on change.
  • A daily report of logins, privilege use, new listening ports and any added, changed or removed file in the places that matter.
  • From outside, a Cloudflare Worker on a 5 minute cron checks the site, the CDN index, the indexer, and that the console and the engine still demand a login. It also reads the Workers plan’s usage hourly and warns at 70% and 90% of the monthly allowance.
  • Inside the engine: the credit monitor and the on-chain audit.
  • Security updates install unattended. Tool updates are checksum-verified, and a runtime update is followed by a health check with the previous binary put back on failure.

Cloudflare

Workers
This site, the Season 4 studio, the Season 2 and Season 3 sale sites, the uptime checker. Each is declared in a config file, and a deploy enforces it.
R2
The public bucket behind cdn.panorama.garden, a private bucket of every candidate image, and the studio’s media bucket.
KV
The site's data cache and the uptime checker's state.
Images
Share card resizing.
Cache
The engine purges the index's address after each publish.

Rehearsal

The engine has a staging mode that fails closed. It refuses to start unless publishing, the scheduler and on-chain writes are all off, storage is the local filesystem and the market is a fixture, and it refuses outright if any production key is present in its environment. Contract changes are rehearsed on Sepolia and on mainnet forks first. Each Season 2 auction rehearsal consumed its own freshly deployed set of contracts.

Dependencies

Renovate opens grouped updates weekly, waits three days after a release, and never merges by itself. Major versions need approval. CI audits production dependencies and fails on a high finding.

18

Services

What Panorama depends on, and the small programs that run beside it.

Outside services

ServiceUsed for
OpenRouterEvery language model call: ideation, prompt writers, agents, summaries.
Comfy CloudImage generation from Season 2 on: tiles, seams, heals, regions. Jobs in parallel.
ModalThe Season 1 ComfyUI worker and the Season 4 runner.
RunPodTraining the LoRAs.
CloudflareDNS, proxy, Workers, R2, KV, Images.
4everlandOne upload that pins to IPFS and syncs to Arweave.
AlchemyMainnet RPC for the engine, the indexer and fork tests.
EtherscanBlock by timestamp lookups and contract verification.
Uniswap V4The coin's pool and the ETH/USDT pool the price is read from.
SuperRareLiquid Editions, the coin's factory and router.
MURI ProtocolSeveral storage links per token, chosen by the holder.
delegate.xyzVault to hot wallet delegation, v2 and v1, in contracts and on the site.
OpenSeaSecondary market, collection stats, the Season 4 drop.
ManifoldThe marketplace for the eight open Season 3 days.
XReveal posts and sale posts.
DiscordEvery alert from every part of the system lands in one channel.
WalletConnectWallet connections on the site.

Reveal posts

The engine posts each reveal to X as @panoramabot through the official API: the tableau, its mood, and the season’s line for the day.

Sales bot

Listens to OpenSea’s event stream for Panorama sales and to the indexer for coin trades above a threshold, and posts them with the mood so far and a countdown to the next reveal.

Offer bot

Keeps standing offers on the collection through OpenSea’s SDK, paced to the API’s budget.

LoRA training

Datasets are curated and captioned by a vision language model with scripts, then trained on a rented GPU. Season 2 has one LoRA. Season 3 has six on Klein and seven on Krea 2. How a caption is written decides what the LoRA learns: captions that describe the look teach the model to wait for those words, and captions that name only the medium and the content leave the look to the LoRA.

Ways to see

A separate, unpublished site with eleven other views of the same year: wrapped into rows, sorted by hue, bent by the price that made it, laid on a helix in 3D. It reads only the public CDN and the indexer, the same open data anyone can use.

Open data

Everything the site shows is read from public places: cdn.panorama.garden/metadata.json lists every tableau with its metadata address, the indexer’s API is open to read, and the contracts are verified.