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.






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
Season 11
Season 22
Season 33
Season 44
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 parts
| Part | What it does | Built with |
|---|---|---|
| Engine | Reads the price, runs generation, publishes, writes to Ethereum, serves the console's API. | Node, TypeScript, Bun, Express, viem |
| Operator console | Where the artists make and pick each day. | Next.js, server-sent events |
| Contracts | The token, its renderers, storage, the step ledger, the sales. | Solidity 0.8.34, Foundry, Solady |
| This site | The canvas, tableau pages, terminal, collector tools. | Next.js on Cloudflare Workers, wagmi |
| Indexer | Follows the coin's pool: price, candles, trades, holders. | Ponder, PostgreSQL, Hono |
| Season 4 studio | The live scene's page, its console and its GPU runner. | three.js, Cloudflare Workers, Modal, Python |
| Sale sites | The Season 2 and Season 3 auctions, each its own site and contracts. | Next.js, Foundry, Playwright |
| Bots | Reveal posts, sale and trade posts, standing offers. | TypeScript, X API, OpenSea SDK |
| Infrastructure | One 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.
How a tableau moves through it
- 1MarketThe coin trades on a Uniswap V4 pool. The indexer follows it for the terminal. The engine reads it once a day.
- 2MakeThe artists prepare options for each mood in the console. Language models write, image models generate, a seam joins each to yesterday.
- 3RevealAt 16:00 UTC the price picks the mood and the engine publishes the option both artists picked for it.
- 4RecordThe files go to the CDN, IPFS and Arweave. The entry, the steps and the image hashes go to Ethereum.
- 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
- 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.
- 2MoodThe change maps to one of seven moods. The price itself never reaches a prompt.
- 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.
- 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.
- 5IndexThe metadata index, one JSON file listing every tableau, gets the new entry and the CDN cache is purged.
- 6ChainThe on-chain jobs are queued: the generation steps, the tableau entry, later the image hashes and the storage links.
- 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
- 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
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
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.

Extreme Bliss
+11.75% on #139

High Bliss
+8.68% on #119

Mild Joy
+2.89% on #84

Equilibrium
+0.96% on #33

Mild Suffering
-2.92% on #64

Deep Suffering
-8.92% on #44

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

#12 High Bliss, +5.01%

#54 Extreme Bliss, +10.91%

#70 High Bliss, +3.47%

#28 Equilibrium, +0.75%
- 01
Outpaint
Z-Image Turbo extends yesterday at 640 x 720
- 02
Upscale
Lanczos to 1920 x 1080
- 03
Restyle
FLUX.1 Dev with an oil LoRA, 0.6 denoise
- 04
Grade
Automatic colour adjustment
- 05
Stitch
SDXL inpaints a 256 px mask over the join
- 06
Clean
Florence-2 finds, SAM 2 masks, LaMa fills
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.
- 1OutpaintZ-Image Turbo extends the previous tableau at 640 x 720 through a crop-and-stitch inpaint.
- 2UpscaleLanczos, to 1920 x 1080.
- 3RestyleFLUX.1 Dev with an oil LoRA regenerates the frame at 0.6 denoise, at full size.
- 4GradeAutomatic colour adjustment.
- 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.
- 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.

#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.
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.






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.

#107 Equilibrium, +0.28%

#121 Mild Joy, +2.94%

#132 Equilibrium, -0.75%

#175 Deep Suffering, -3.43%
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
- 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.
- 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.

This world
Equilibrium, Mild Joy, Mild Suffering
A place that existed, at real scale.
#160 Equilibrium, -0.19%

The world transfigured
High Bliss, Deep Suffering
One impossible thing, the largest in the frame.
#148 High Bliss, +3.18%

The world broken
Extreme Bliss, Extreme Anguish
At the scale of a city.
#180 Extreme Bliss, +10.39%
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.

#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 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.



As revealed

As joined
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.
- 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.
- 2SDXL refineAn SDXL inpainting model with Differential Diffusion refines a narrower strip across the join.
- 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.

Interface
#181 to #185

City
#186 to #190

Suburb
#191 to #195

Village
#196 to #200

Nature
#201 to #205

Abstract
#206 to #210
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
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.
- 1BriefThe zone, theme, kind and mood, the zone so far (each earlier day’s theme, story line and prompt), and today’s story line.
- 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.
- 3WriteThe prompt writer writes the prompt, a title and a note, avoiding what is already on the desk.
- 4Generate
trigger. prompt. lookwith 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.

#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
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.

#181 Deep Suffering, -5.39%

#195 Mild Joy, +1.1%

#200 Equilibrium, +0.21%

#209 Equilibrium, -0.66%
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.






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.



The Newcomer
#211 to #220

The Night Worker
#221 to #230

The Caretaker
#231 to #240

The Performer
#241 to #250

The Runaway
#251 to #260

The Young One
#261 to #269
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
- 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.
- 2TableauKrea 2 Turbo on Comfy Cloud, about 20 seconds. Several options to pick from.
- 3Cast checkA vision language model reads each new tableau and reports whether the right people are in it. Advisory.
- 4JoinThe Season 2 seam, with the cutting moved into the graph. 640 px band by default, 1024 or 1280 on request. About 25 seconds.
- 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.
- 6GroundThe ground plane is fitted: a horizon and how tall a person stands below it. It can be set by hand.
- 7WalkThe lead’s way from yesterday’s tableau into today’s is planned over that ground.
- 8PolishLayers for things that stand, and the things that move in life.
- 9MusicThe day’s piece is rendered to audio by its own player in a headless browser.
- 10BuildThe media folder the scene’s page reads. It points at files the steps already made, so making one copies nothing.
- 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.
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_urlis 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.
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
| Function | Who | Notes |
|---|---|---|
mintTo(address) | owner, operator | Reverts MaxSupplyReached past the cap. |
mintTo(address, uint256) | owner, operator | Several ids in order. |
mintCap() | view | 365 with no controller, else the lower of the controller's cap and 365. |
burn(uint256) | holder or approved | Counts toward totalBurned. |
tokenURI(uint256) | view | Delegates to the renderer. Reverts TokenDoesNotExist or RendererNotSet. |
tokenURI() | view | The whole artwork. |
signalMetadataUpdate() | owner, operator | BatchMetadataUpdate over every minted token. |
signalMetadataUpdate(uint256) | owner, operator | MetadataUpdate for one token. |
signalBatchMetadataUpdate(from, to) | owner, operator | A range. |
setAuthorizedOperator | owner | Grants or revokes the operator right. |
setRenderer | owner | The switch every renderer upgrade used. |
setStorageContract, setMuriOperator, setMuriProtocol, setPanoramaERC20, setMintController | owner | Each 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
| Field | Type | Holds |
|---|---|---|
price | uint256 | PANO/USD at the close, 18 decimals. |
changeBps | int256 | The day's change in basis points. |
timestamp | uint40 | The reveal time. Every file address is derived from it. |
moodIndex | uint8 | 0 Extreme Bliss to 6 Extreme Anguish. |
workflowId | uint8 | A registered ComfyUI graph. |
season | uint8 | 1 to 4. |
seed | uint256 | The generation seed. |
prompt | string | The prompt as sent. |
name, description | string | Optional overrides. |
imageFragmentHashes | bytes32[] | keccak256 of each fragment. |
imageFragmentPointers | address[] | Where each uploaded fragment lives. |
uploadedFragmentCount | uint256 | Progress 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
TableauFinalizedand 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. 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.
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.
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,getRpcUrlsForand 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.
Retired renderers
| Version | Address | Shipped for |
|---|---|---|
| V1 | 0xE1Ff8BdCD18a121585c25019D58Ce3Be85076372 | Launch |
| V2 | 0xbd6DD3AEfC293F28165fDa82C142013d2EF089E3 | Season 2 |
| V3 | 0x42089a75bA25b542A78e99D928AAa7537Beb031D | Season 3 |
| V4 | 0xc63Be334aa97cD4CD49d9c184491a22460e60aEE | Artist trait |
| V5 | 0x4f99e9099d59b7DE62635D81548534E9789FeF9B | Season 4 |
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
- April 2026
V1
Launch. Token metadata and the whole-artwork viewer, built on-chain.
- 13 July 2026
V2
Season 2. Technology trait, readable price, on-chain status, a viewer for phones and marketplace frames.
- 14 October 2026
V3
Season 3. Theme, Zone and Kind traits, and each token's generation steps from the ledger.
- 22 October 2026
V4
An Artist trait on every token.
- 18 November 2026
V5
Season 4. Video and live scene tokens, megabyte answers, base64 written in place, a linked library.
- 18 November 2026
V6
Prereveal video for unrevealed Season 4 tokens. Live now.
| Trait | V1 | V2 | V3 | V4 | V5 | V6 |
|---|---|---|---|---|---|---|
| Mood | ||||||
| Price | ||||||
| Price change | ||||||
| Season | ||||||
| Seed | × | |||||
| Workflow | × | |||||
| Technology | ||||||
| Status | ||||||
| Theme, Zone, Kind | ||||||
| Artist | ||||||
| Lead | ||||||
| Traits set by the artists | ||||||
| Music controller's traits |
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-chainonce 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-chainon 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.
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
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.
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
- 1Steps
appendStepson the workflow ledger: the ordered list of what produced the image. - 2Entry
addTableauEntryon PanoramaStorage: price, change, timestamp, mood, workflow id, season, seed, prompt. - 3Hashes
setTableauImageFragmentHashes, once the tableau is final and gas is low. - 4Links
initializeTokenDatathrough 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
Low-gas worker
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.
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.


Strip: every candidate and job in flight
Prompt
Seam width
Seam prompt
LoRA and strength
Tile model
Copies
Seed
Grain
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
| Path | What it is |
|---|---|
/ | A drifting filmstrip of the real panorama from the CDN index, the mood system, the seasons. |
/canvas | The 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. |
/terminal | Trade the coin and see the mood your trade would set. |
/stats | Mood distribution, market figures, how much of the work is on-chain. |
/collector-zone | For holders: on-chain uploads, storage links, signals, Season 4 switches. |
/season-4 | Three pages on the season, its six leads and how a day is made. |
/season2-auction-stats | A live report on the Season 2 auction, replayed from its event log. |
/about | The work, the moods and the seasons in plain language. |
/changelog | What 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.

A tableau, 16:9

A Season 4 day, 1.61 times as wide
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
| Route | What it does | Cache |
|---|---|---|
token-holder | Live ownerOf, classified as treasury, auction or collector. | 30 s |
token-metadata | A token's metadata through the CDN index. | 30 s |
vendor-state | Which days have left the treasury, by multicall. | 30 s |
season2-auction-stats | Replays the auction's event log into a payload. | 15 s |
season3-winners | The winning bid per day from the auction's logs. | 15 s |
tx-status | A receipt lookup with an 8 s timeout. | none |
og/segment | The share card. | 1 h to 1 day |
opensea/stats | Collection stats. The API key stays on the server. | 60 s |
changelog | The changelog from the CDN. | none |
portraits | Pages 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.
Projection: the mood this trade would setRecent trades
Top holders
Trade console
Amount, quote, price impact, slippage
Stats
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 mood projection
- 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.
- 2Trade impactThe price impact of the amount typed, from the quote.
- 3CompoundThe two are compounded, not added: (1 + live)(1 + impact) - 1.
- 4MoodThe projected change maps to a mood with the same thresholds the engine uses.
- 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
| Name | Value |
|---|---|
| PANO (ERC-20) | 0x74B8174a862B098DB9A44E0C553A3bFa79EF602d |
| LiquidRouter | 0xebd58eda8408d9ea409f2c2be8898bd9738f3583 |
| Uniswap V4 PoolManager | 0x000000000004444c5dc75cB358380D2e3dE08A90 |
| Uniswap V4 Quoter | 0x52F0E24D1c21C8A0cB1e5a5dD6198556BD9E1203 |
| WETH | 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 |
| Pool hook | 0x322D4F640a5263Fc4E28C3896009502453d620cC |
| Pool key | currency0 PANO, currency1 WETH, fee 0, tick spacing 60 |
| PANO/WETH pool id | 0xa0366d70dab23ef4afc1d27c72d389068bfc89c2962a0084accd0c3b29431d7a |
| ETH/USDT pool id | 0x90078845bceb849b171873cfbc92db8540e9c803ff57d9d21b1215ec158e79b3 |
| Router commands | V4_SWAP 0x10, WRAP_ETH 0x0b, UNWRAP_WETH 0x0c |
| V4 actions | SWAP_EXACT_IN_SINGLE 0x06, SETTLE 0x0b, SETTLE_ALL 0x0c, TAKE 0x0e, TAKE_ALL 0x0f |
| Quote probe | max(amount / 10,000, 1e12 wei) |
| Input caps | 999,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
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
| Table | Key | Columns |
|---|---|---|
swap | transaction hash, log index | block, 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 |
routerBuy | transaction hash, log index | payer, recipient, ETH in, fee, ETH swapped, tokens received, protocol and beneficiary fees |
candle1m, candle1h, candle1d | interval start | open, high, low, close in WETH and USD, three volumes, trade count |
dailyCloseSnapshot | bucket start | the block and time the close was taken at |
holder | address | balance, 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
| Endpoint | Answers |
|---|---|
/price | The latest swap's price, with USD recomputed against live ETH/USD. |
/candles | 1m, 1h or 1d candles, with the current empty bucket synthesized. |
/trades | Swaps newest first, with a cursor. Buyer and payer on buys. |
/summary | Open, close, high, low, change and volume over 1h, 24h, 7d or 30d. |
/liquidity | The pool's WETH, summed from every swap. |
/holders | Top holders and the holder count. |
/graphql | Ponder'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.
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.
| Stage | Window | Who | Limit |
|---|---|---|---|
| Phase 1 | Nov 19, 15:00 to 16:00 UTC | Holders of Panorama and Ephemera, and Dav’s collectors | Up to 2 a wallet |
| Phase 2 | 16:00 to 17:00 UTC | Holders of Normies, The Vessel, The Vessel Sequences and Terraforms, and Pale Kirill’s and DeltaSauce’s collectors | Up to 2 a wallet |
| Phase 3 | 17:00 to 18:00 UTC | Holders of FREEDZ, 1337 Skulls, Song a Day, BGANPUNKS V2, Talismans, The Block, CypherDudes and JPEG Frens | Up to 2 a wallet |
| Public | 18:00 UTC to Dec 31 | Anyone | Up 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.
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
| Service | Used for |
|---|---|
| OpenRouter | Every language model call: ideation, prompt writers, agents, summaries. |
| Comfy Cloud | Image generation from Season 2 on: tiles, seams, heals, regions. Jobs in parallel. |
| Modal | The Season 1 ComfyUI worker and the Season 4 runner. |
| RunPod | Training the LoRAs. |
| Cloudflare | DNS, proxy, Workers, R2, KV, Images. |
| 4everland | One upload that pins to IPFS and syncs to Arweave. |
| Alchemy | Mainnet RPC for the engine, the indexer and fork tests. |
| Etherscan | Block by timestamp lookups and contract verification. |
| Uniswap V4 | The coin's pool and the ETH/USDT pool the price is read from. |
| SuperRare | Liquid Editions, the coin's factory and router. |
| MURI Protocol | Several storage links per token, chosen by the holder. |
| delegate.xyz | Vault to hot wallet delegation, v2 and v1, in contracts and on the site. |
| OpenSea | Secondary market, collection stats, the Season 4 drop. |
| Manifold | The marketplace for the eight open Season 3 days. |
| X | Reveal posts and sale posts. |
| Discord | Every alert from every part of the system lands in one channel. |
| WalletConnect | Wallet 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.