ACME Protocol · Art Coded on the Monetary Engine
ARTCORE
Onchain Generative Code Art Directory
Art Repository for Tokenized Code, Onchain Rendering & Execution
Write an algorithm. Mint it on Bitcoin. Let edition numbers become seeds, seeds become artworks, and artworks become permanent — rendered from chain data in any browser, in any decade, with no server left to die. ARTCORE is where Bitcoin‑native code art lives, gets found, and graduates: an open directory curated not by a committee, but by a formula anyone can re‑run.
Preview values — the live page reads /v2/cortex indexer endpoints with proof-bearing responses.
This mark is generative: same seed, same drawing — forever. Click through the editions.
Manifesto
The gallery is a formula.
Generative art solved permanence for images the moment the image stopped being the artwork and the program became the artwork. ARTCORE finishes the thought: the program lives on Bitcoin, the tools it needs live on Bitcoin, and the record of who made it, what it belongs to, and why it matters lives on Bitcoin too — as a graph anyone can read and no one can quietly edit.
Every platform before us made one compromise. The curated houses built prestige and put it behind a committee. The open platforms removed the gate and drowned the signal. The marketplaces stayed neutral and kept curation in their own database, one shutdown away from amnesia. ARTCORE refuses the trade. The floor is open to everyone; the top is scarce and earned; and the mechanism between them is public arithmetic over public signals — likes and mints, priced in sats, scored by a published function, settled at a block height.
Same runtime, same libraries, same seeds for every artist — a shared instrument, minted once, played ten thousand ways. What we remove is everything else: metadata servers, privileged indexers, platform keys, black-box featuring, rent at the door.
Artwork HTML is an ACME asset. Owning the edition means owning the code that draws it.
The runtime, p5.js and THREE.js are on-chain assets. Art loads its instruments from Bitcoin, not from a CDN.
seed = SHA-256("MYCOLL.42"). No reveal ceremony, no oracle — identity is destiny.
Entering, liking and graduating are CORTEX axons — signed, timestamped, weighted, permanent.
LISTED, OPEN CALL, INDEXED — read from the graph, never granted by a database. Kill our website; the directory survives.
The artist journey
From first line of code to permanent collection — five steps, zero permission.
Sketch in p5.js, THREE.js, raw Canvas, SVG or GLSL at acme.pics/artcore. Live preview, seed scrubbing, FPS and size budget as you type.
Your final HTML (bootstrap loader + your code, under 399 KB) becomes an ACME asset. Libraries don't count — they load from their own on-chain assets.
Choose supply N. Editions are subassets MYCOLL.1…N, each with a deterministic seed derived from its own name. The number is the variation.
Each mint settles on Bitcoin; each edition renders in the collector's browser from chain data — dispensers, auctions and the open order book included.
Point one axon at the live Season. Likes and mints do the campaigning; the score does the judging; the Index does the remembering.
Tokenized toolchain
Every artist plays the same instrument.
ARTCORE's framework is itself minted. One shared runtime resolves your seed, seeds your PRNG, records your traits and loads your libraries — by fetching other Bitcoin assets. Your artwork ships as ~1.5 KB of HTML because its instruments are already on-chain, amortized across every artist forever.
The runtime exposes acme.hash, acme.random() (SFC32 —
the same PRNG family used by fxhash and Art Blocks), acme.trait(),
acme.loadLibrary() and acme.import() for composable,
recursive art — one piece importing palettes, easing curves or noise fields minted by another artist.
Updates ship as new assets; nothing you rendered ever changes under you.
Compression is a feature. Libraries are stored gzip-compressed and inflated in the browser via DecompressionStream — the protocol practices the compressionism it preaches.
| On-chain asset | Contents | Weight |
|---|---|---|
ACMERUNTIME010tag · x:generative-library |
ACME Runtime v1.0.0 — seed chain, SFC32, traits, loader, imports | ~1.8 KB gz |
P5JSMIN190window.p5 |
p5.js v1.9.0 minified — the lingua franca of 2D generative art | ~240 KB gz |
THREEJSMIN01580window.THREE |
THREE.js r158 UMD — WebGL, shaders, 3D procedural worlds | ~161 KB gz |
YOURLIBvia acme.import() |
Anything you mint: palettes, geometry helpers, noise, fonts | yours |
MYCOLL + MYCOLL.Nbootstrap ~500 B |
Your artwork HTML + numbered editions | < 399 KB |
// your whole dependency story: await acme.ready; await acme.loadLibrary("P5JSMIN190", { globalVar: "p5" }); const palettes = await acme.import("MYPALETTES"); // another artist's on-chain module
Deterministic seeds
The edition number is the artwork.
No randomness at mint, no reveal, no server assigning traits. The runtime derives each edition's
seed from its own on-chain name — SHA-256("MYCOLL.42") —
and feeds it to a seeded PRNG. Anyone, at any time, on any machine, regenerates edition 42
pixel-for-pixel. Try it: this demo runs the exact runtime pipeline.
Two tiers, one graph
Open at the floor. Earned at the top.
We studied the houses that came before us. The juried house built prestige behind closed doors; the open platform drowned in its own generosity; the neutral marketplace kept curation in a company database. ARTCORE keeps what worked and deletes the failure mode of each.
The Directory
Permissionless listing. One axon from your collection to ARTCORE and you exist here — no application, no gatekeeper, no fee beyond your own transaction.
- Ranked by dendrite weight — references priced in vbytes, so spam costs real sats and quality accrues real gravity.
- Browse by movement, medium, library, supply, heat.
- Weight-ranked, newest, and trending views straight from the public indexer network.
- Anyone may build a rival browser over the same graph. Please do.
The Index
The scarce tier. Membership is decided each Season by a published scoring function over on-chain likes and mints, then written into the graph by a confirming axon. Nobody's taste is in charge — including ours.
- Top X collections per Season graduate — ten, in Season 001.
- Graduation is recorded as a synapse: your submission axon + the Index's certifying axon. Two signatures, one permanent fact.
- A wrong graduation is provably wrong — anyone can re-run the score and flag the mismatch.
- Indexed forever: badge on every edition, featured rotation, priority placement across ACME's DEX and dispensers.
Seasons · the graduation mechanic
Curation without curators.
A Season is an open call minted as an asset: a window in block heights, a capacity, and a scoring formula, all declared before it opens. What happens inside the window is campaigning by the only honest means available — making work people like enough to reference, and mint enough to own.
The Season asset (e.g. ARTCORE.S1) publishes open_block, close_block, capacity and scoring parameters. Rules first, contest second — never the reverse.
Your collection declares { ref:"ARTCORE.S1", rel:"collection" }. That single CORTEX edge is the whole application. Permissionless, timestamped, irrevocable — a claim awaiting its confirmation.
Likes are reaction axons — inscriptions that cost sats, weighted by vsize, one per address, artist self-likes excluded via profile bindings. Mints are the purest signal there is: someone paid to own an iteration. Both live on-chain, in public, in real time.
At close_block the leaderboard freezes into a pure function of Bitcoin history. Anyone can compute it. Everyone gets the same answer. That's the whole point.
For each of the top X, the Index mints an entry certifying the collection — rel:"certifies", note pinned with season, rank, score. Submission axon + certifying axon = synapse = INDEXED. The operator executes curation; it does not decide it.
score = 100·log₂(1+U) + 40·log₂(1+M) + 10·log₂(1+L/100)
U unique minter addresses · M editions minted · L like-weight (vsize, capped per address)
// log damping: whales hit diminishing returns · sybils pay tx fees per identity ·
// unique collectors outweigh raw volume · parameters live in the Season asset
Season parameters shown are the proposed Genesis configuration; the minted Season asset is canonical.
Why you can't buy the podium
One collector minting 500 editions scores log₂(501) ≈ 9 on volume but only log₂(2) = 1 on collectors. A hundred collectors minting one each score log₂(101) ≈ 6.7 on the dominant term — worth 100× the weight. Splitting into sybil wallets buys that same term at full transaction-fee price per identity, plus dust to distribute. Cheating is legal here. It's just a terrible deal.
Four wings
Movements the graph understands.
Taxonomy on ARTCORE isn't a dropdown — it's a sub-collection you join by axon. Four wings anchor the directory; works may claim several, and the graph remembers who arrived where, and when.
Constraint as medium. Kilobytes as canvas. Work that treats Bitcoin's block space the way a sculptor treats marble: the limit is the form. Whole worlds under the witness budget; every byte arguing for its life.
ARTCORE.COMPRESSIONISM · rel=collectionThe token is the program. Source inscribed on Bitcoin, executed in the collector's browser. Collectors don't own a picture of the work — they own the work, which happens to be able to draw itself.
ARTCORE.CODEART · rel=collectionOne algorithm, N editions. The artist authors a possibility-space; edition numbers sample it through deterministic seeds. Rarity isn't assigned by a spreadsheet — it precipitates out of the mathematics.
ARTCORE.GENERATIVE · rel=collectionWorlds from rules: noise fields, L-systems, particle physics, raymarched geometry. Imagery computed rather than drawn — described in a few honest kilobytes, unfolding into detail no file that size should contain.
ARTCORE.PROCEDURAL · rel=collectionThe directory
Browse the graph.
A preview of the directory view — every thumbnail below is drawn live, in your browser, from a deterministic seed, exactly as editions render on-chain. Sample listings; the production page hydrates from the indexer network.
GET /v2/assets/ARTCORE/dendrites?rel=collection&sort=weight
Mint yours in the Studio ↗
For artists
Submission, in full.
Everything required to stand in the open call. No forms, no waitlist, no committee — the checklist is the whole ceremony.
- Build deterministic. All randomness through
acme.random(), noise throughnoiseSeed(acme.hash). Same seed must mean the same artwork, every run, on every machine. - Stay inside the budget. Final HTML (bootstrap + your code) under
399 KB. The Studio's size meter tracks you as you type; the runtime and libraries load from their own assets and cost you nothing. - Mint the collection, declare supply.
MYCOLLplus editionsMYCOLL.1…N, artist axon to your CORTEX profile — attribution is automatic when work and profile share an issuing key. - List, then enter. One axon to
ARTCOREmakes you LISTED. One more to the live Season —ARTCORE.S1— and you're in the call. Add movement wings as you see fit. - Campaign with the work. Share the pieces; likes and mints are the only ballots. At close, the score is arithmetic and the top ten are graph facts.
$ Determinism lint
- ✓ acme.random() for every random draw
- ✓ noiseSeed(parseInt(acme.hash.slice(2,10),16))
- ✓ windowResized / resize handlers — art adapts to any frame
- ✓ acme.trait() for palette, density, structure — collectors filter by them
- ✗ Math.random(), random() — different art every load
- ✗ Date.now(), new Date(), performance.now() in init paths
- ✗ External URLs, CDNs, fonts, textures — on-chain or generated only
- ✗ import statements — libraries are UMD globals via acme.loadLibrary()
What entering costs
A Bitcoin transaction. That's the fee schedule, complete. No listing charge, no platform take at the gate, no privileged path into a block. Your work should not need a favor to be included — in a block, or in a directory.
For collectors
Own the algorithm. Verify everything.
An ARTCORE edition is not a JPEG with paperwork. It is the program, its seed, its traits and its whole context — artist, collection, season, graduation — inscribed as one connected record.
Your edition renders from Bitcoin data in any browser. Its provenance is a CORTEX graph walk: the work claims its artist, the artist's profile confirms the work, the Index's certifying entry seals its rank — claims and confirmations distinguished honestly, one-way assertions displayed as exactly that. Rarity queries, trait filters and trending views come from open, proof-bearing endpoints. If every ARTCORE interface vanished tomorrow, your edition would still draw itself, and still prove itself.
Protocol surface
Responses ship with verification material — Merkle-anchored state, not polite assurances. Run your own indexer; get the same answers.
Questions
Frequently asked.
Is listing really permissionless?
rel:"collection" axon at ARTCORE is listed, ranked by dendrite weight. There is no application, no review queue and no listing fee — only your Bitcoin transaction. The curated tier (the Index) is the part you can't buy or apply into: you graduate by score, or not at all.How exactly does a collection graduate to the Index?
reaction inscriptions, vsize-weighted, one per address) and mints (editions + unique minters) accumulate. At close_block, artcore-score-v1 ranks all entrants deterministically; the top X graduate; the Index mints a certifying entry per graduate. Your submission axon plus the Index's certifying axon form a synapse — INDEXED status is that synapse, computed by any indexer, owned by none.Can a whale or a bot farm buy the podium?
Where do seeds come from?
acme.hash in priority order: an explicit URL parameter (Studio preview), a x:generative-seed CORTEX tag, or — for numbered editions — SHA-256(assetId), e.g. SHA-256("MYCOLL.42"). The hash feeds an SFC32 PRNG, the same family used by fxhash and Art Blocks. Edition 42 renders identically forever, for everyone, everywhere.What do collectors actually own?
What happens if acme.pics disappears?
Who holds the Index key, and why should I trust them?
Can I use my own library, or reference art on other chains?
acme.import() — palettes, noise fields, geometry kits — composable across artists, forever. And CORTEX's cross-chain reference syntax (/o/…, /eth/…, /a/…) lets collections cite Ordinals, Ethereum or Arweave ancestors as one-way assignments, displayed honestly as unconfirmed by the foreign side — because a Tezos edition can't sign an ACME axon, and pretending otherwise would be theater.What is compressionism, and why does ARTCORE care?
When does Season 001 open?
ARTCORE.S1 with its block window is the canonical announcement, published at least a week of blocks in advance. Watch the Studio, the Directory, or GET /v2/assets/ARTCORE/dendrites?rel=parent if you prefer your announcements raw.Progressive decentralization
Machinery first. Meetings later.
Studio, runtime and libraries minted; Directory and Index live; scorer source on-chain; Foundation key executes graduations that anyone can audit.
Index key moves to a Federation multisig; independent indexers re-compute season scores and co-sign graduations before they're minted.
Anyone runs the scorer against canonical state; mismatched graduations are publicly provable; operators become replaceable parts.
Weights, capacity, cadence, featured policy and curator keys under community control. Vox populi, vox dei — with a formula in hand.