<!-- Verified: 2026-08-28 -->

# 256ART

**In one line** — Ethereum, fully onchain: code, traits and metadata all served
from the chain. No IPFS, no server.

## Mental model

- **Two deliverables**: the artwork code and a weighted trait table (write the table first — `../features.md`).
- Libraries come **only from an onchain filesystem**; the live list is in the Artist Portal, never a CDN.
- A **platform-provided PRNG** whose use is expected.
- The input object mixes **mint-fixed** values (hash, token id) with **live chain state** (owner, balances, block data) — optional fields may be absent: degrade, never throw.
- Preview waits for an **explicit signal** and times out without it — the top cause of blank thumbnails.

**The decision this platform forces**: using live-state fields makes the work
non-reproducible from the hash alone and unverifiable by any determinism test.
Legitimate and deliberately exposed — but a decision to take up front and state
in the description, not to stumble into because a field was there.

## Docs — start at `https://docs.256.art/artist-documentation/`

| Page | Answers |
|---|---|
| `artist-documentation/generative-art-template/` | File structure, input object, provided PRNG, trait table, sizing, render signal |
| `artist-documentation/testing-your-project/` | Pre-deployment checklist, common rejections |
| Artist Portal | The **live** library list — the portal is current, docs may not be |

Community template: `https://github.com/Martibis/256ART-generative-art-template`

## Check before you code

Input object fields (which fixed, which live) · provided PRNG's API · onchain
library list and versions · trait table format and its summation rule · exact
render-done signal · whether minification is expected.

## Traps by design

Reading a live field without realising it · throwing on a missing optional
field · trait weights failing the summation rule (usually a rounding error) ·
assuming a library exists because npm has it.

<!-- Verified: 2026-08-28 -->

# Art Blocks

**In one line** — Ethereum; the curated reference platform. Your script is
stored onchain and executed by an onchain generator that assembles the page.

## Mental model

- **One JS file, one library max**, from a **closed registry** of pinned versions, injected by the generator — a `<script src>` you write will never run.
- Hash + token id arrive in an **injected global**; the token id encodes project and invocation number.
- Features are set **synchronously on a global** and must be computable **outside a browser** (no canvas) — traits decided while drawing cannot onboard.
- **Bytes cost gas**: deployment cost is proportional to script size; the practical ceiling is far below any technical limit.
- Preview: a configured delay, or an explicit ready signal with a placement requirement that catches people out — check it.
- **Engine / Flex** = same protocol, different curation; Flex adds external assets (changes the "no network" default). Prohibition (Base), Bright Moments and Plottables (own sheet: `plottables.md`) are Engine deployments — this contract applies there too.

## Docs — start at `https://docs.artblocks.io/`

| Page | Answers |
|---|---|
| `creator-onboarding/artists/1-building-your-project/` | The core contract: injected globals, libraries, size, features, preview |
| `creator-onboarding/artists/2-staging-and-testing/` · `3-mainnet-launch/` · `faq/` | Staging, launch, edge cases |
| `creator-onboarding/artists/flex-assets/` | Engine/Flex external assets |
| `protocol/on-chain-generator/` · `protocol/postparams/` | Page assembly; post-mint params |
| `developer/mcp-server/quick-start/` · `developer/mcp-server/capabilities/` | Art Blocks' own MCP server — connect it and ask it what it exposes, rather than reading its surface off a page |

Community starter (unofficial): `https://github.com/ArtBlocks/artblocks-starter-template`

## Check before you code

Injected global's name and fields · invocation derivation · approved libraries
and versions **today** · features API and accepted types · preview mechanism
and where the opt-in must live · size guidance and cost model · expected
testing (how many hashes, which browsers).

## Traps by design

Traits computed during render (fails headless) · a second library (there is
none) · bundling instead of declaring a library · assuming last year's approved
version · forgetting the generator injects its own page styles.

<!-- Verified: 2026-09-04 -->

# Artpoint

**In one line** — a Paris digital-art agency, not a mint platform: you deliver a
finished video file and it plays on client screens (offices, hotels, retail) on
a monthly rotation. No chain, no hash, no code of yours runs on their side.

## Mental model

- **You ship a cut, not a generator.** The edition logic stays yours: pick the seeds, render, hand over files. `../determinism.md` still pays — it is what lets you re-render a master a year later, at a bigger size or a different ratio.
- **Put the recipe in the filename.** It is the only metadata that survives someone else's asset library — no sidecar, no README, no email thread. Piece, hash, sketch commit, size, fps, frames: `dunes_0x8f3a91c2_a41b9de_3840x2160_30fps_1800f.mp4`.
- **The output device is a screen in a room where people work.** Same inversion as the plotter in `plottables.md`: ambient, muted, glanced at rather than looked at. Slow beats eventful, legible at distance and off-axis, contrast that survives a bright lobby. A screen nobody can look away from is a screen the client turns off.
- **Time becomes an input.** A still becomes video by animating the system, or by travelling across seeds. Drive it from a frame counter, never the wall clock — `../tooling.md` §Video.
- **A loop's seam gets many chances.** A one-minute piece replays hundreds of times a day, and a seam that passes once may not pass the fortieth (`../tooling.md` §Perfect loops). A visible cut is a legitimate choice; the seam nobody chose is not.
- **One master by default — ask what they do to it themselves.** Rescaling and rotating is routine, reframing is not something to assume. A 9:16 that is not a cropped 16:9 is a second *render*, not a second export: deliver both when the composition demands it, and keep the framing yours.
- **They need words too.** Works are shown with curatorial texts on a companion page: supply the description, or the key facts and let them write it.

## Delivery spec

Artpoint publishes no artist specification. This is what the team asked for in
2026-09 — **reconfirm with your contact**; it is private and it will drift.

| | |
|---|---|
| Container | `.mp4`, H.264 preferred |
| Resolution | UHD, Full HD floor |
| Ratio | 16:9 and/or 9:16 |
| Duration | 3–5 min if it does not loop, around 1 min if it does |
| Frame rate | 30 fps |
| Weight | 1.5 GB per file max, 30 MB/s max |

## Docs

`https://www.artpoint.fr` — the offer, the catalogue, the artist sign-up form.
No artist documentation, no public spec: **your contact is the spec** — write
the answers down and date them.

## Check before you render

Container, resolution, ratio and weight caps · whether it must loop, which
decides the duration · sound, or is every screen muted · which orientations are
in the client's rooms · what they do to the file themselves: rescale, rotate,
reframe · how long it stays up and how often it repeats in a day · the licence
granted, its duration and territory, and the AI-training exclusion
(`../ethics.md`) · what the curatorial text needs from you.

## Traps by design

Screen-recording the sketch (dropped frames, variable timestep, nothing
reproducible) · a loop that accumulates (`x += v`) or damps, and so never
closes · exporting at the preview size instead of re-rendering at UHD
(`../resolution.md`) · a 16:9 cropped to 9:16 by someone who did not compose it
· a delivered master nothing in its filename can regenerate · sound designed
in, played on a muted screen · a rhythm that reads well in a 30-second review
and is unbearable on day nine.

<!-- Verified: 2026-08-28 -->

# bootloader.art

**Ask which bootloader first** — the platform is a family of runtimes with
incompatible constraints. Never "bootloader" in the singular.

| | `svg-js` | `p5-js` | `generic-web` |
|---|---|---|---|
| What | inline JS → SVG | p5 sketches | HTML/CSS/JS projects |
| Storage | **onchain** | IPFS | IPFS |
| Deliver | code in a wrapper | a sketch | a zip + manifest |
| Libraries | **none** — SVG DOM | p5, provided | anything in the zip |
| Mint-time params | no | no | **yes**, typed schema |

**In one line** — Tezos, by ObjktLabs. Open, experimental, non-curated, code
visible next to the work by design.

## Mental model

Common: seeded PRNG + edition number handed to your code; generators
**versionable** (bug fixes after launch); collectors can regenerate keeping
their seed; a detectable preview/cover mode.

- **`svg-js`** — SVG DOM only, billed per byte onchain, node count is the budget. Stored **unminified**: your formatting is part of the work's visible provenance — the one place where "strip and minify" is wrong (`../tooling.md`).
- **`p5-js`** — p5 provided and **already seeded**, inverting the usual bridge-your-own-PRNG advice. Check what that means for `random()`/`noise()` before wiring anything.
- **`generic-web`** — zip + manifest declaring capture and animation; the only place in this corpus where **mint-time parameters** exist (typed schema, UI widgets).

## Docs

`https://bootloader.art/` → `/resources`, `/help`, and one page per runtime
(`/bootloaders/svg-js`, `/bootloaders/p5-js`, `/bootloaders/generic-web`).
**The site rejects plain fetches** (403 / empty SPA shell) — open in a browser.
Runtime source of truth: `https://github.com/objkt-com/bootloader-monorepo`
(newer runtimes may live on a feature branch). Third-party sandbox:
`https://github.com/Tezumie/bootloader-sandbox`.

## Check before you code

Which runtime and version · injected object's fields (PRNG, seed, edition,
preview flag, root element) · features mechanism if any · render-done signal ·
`svg-js`: current cost per byte · `generic-web`: manifest options (capture,
animation, params) · dev harness params (seed, edition, capture).

## Traps by design

Assuming a canvas in `svg-js` · porting canvas work to `svg-js` (vector cost
scales with nodes, not resolution) · minifying `svg-js` code · double-seeding
p5 · referencing outside the zip in `generic-web` · treating these docs as
settled — youngest platform here, the sheet most likely to be stale: read the
site and the monorepo.

<!-- Verified: 2026-08-28 -->

# Choosing a platform

Qualitative on purpose — nothing here to go stale. Once chosen: open the
sheet, fetch its docs.

| | Chain | Storage | You deliver | Hash reaches you via | Libraries | Mint-time params | Minify? |
|---|---|---|---|---|---|---|---|
| **Art Blocks** | Ethereum | onchain | one script | injected global | closed registry, one of them | post-mint params exist | yes, bytes cost gas |
| **256ART** | Ethereum | onchain | code + trait table | injected object, plus live chain state | onchain filesystem only | no | yes |
| **Verse** | Ethereum | IPFS | a web page | URL parameter | free | no | optional |
| **bootloader `svg-js`** | Tezos | onchain | inline JS → SVG | injected object | **none** | no | **no — formatting is the work** |
| **bootloader `p5-js`** | Tezos | IPFS | a p5 sketch | injected object, p5 pre-seeded | p5, provided | no | optional |
| **bootloader `generic-web`** | Tezos | IPFS | a zip + manifest | injected object | free, inside the zip | **yes, typed schema** | optional |
| **Highlight** | EVM multi-chain | IPFS | a web page + platform script | platform script, pre-seeded | free | no | optional |
| **Plottables** (AB Engine) | Ethereum | onchain | one script (Art Blocks contract) | injected global | closed registry | no | yes |
| **Self-hosted** | — | your choice | a web page | your choice | free | roll your own | optional |

The table is shaped for mint platforms. **Artpoint** (`artpoint.md`) is a
different animal — a screen-diffusion agency: no chain, no hash, no code of
yours running anywhere. You deliver a finished video file.

## Choosing by what constrains you

- **Smallest possible code, maximum permanence** → Art Blocks or 256ART. Both
  put bytes on Ethereum and both will make you fight for kilobytes.
- **Vector work, plotter output, code as part of the piece** → bootloader
  `svg-js`. No canvas, no libraries, and the source is read alongside the work.
- **Heavy 3D, large assets, a real bundle** → Verse, bootloader `generic-web`, or
  self-hosted. Onchain platforms are the wrong shape for this.
- **The collector should choose something at mint** → bootloader `generic-web`.
- **The piece reads live chain state on purpose** → 256ART, which exposes it
  deliberately. Read the trade-off in that sheet before committing.
- **p5, quickly, with the seeding already handled** → bootloader `p5-js`, or
  Highlight, whose platform script hands you seeded draws.
- **Self-serve on an EVM chain, no application** → Highlight.
- **Pen plotter as the real output device** → Plottables (and read the plotter
  section of `../tooling.md`).
- **No platform, full control** → `self-hosted.md`.
- **The deliverable is a video on someone's screen, not a token** →
  `artpoint.md`.

## Porting between platforms

Four things change: how the hash arrives (isolate it in one function on day
one and porting is an afternoon) · how features are declared · how the
render-done signal is sent · **which libraries are allowed** — the fatal one: a
piece built on a library the target does not offer is a rewrite, not a port.

<!-- Verified: 2026-08-28 -->

# Highlight

**In one line** — EVM multi-chain, self-serve, no application: a web project
bundled with a required platform script, wired to the mint by the platform.

## Mental model

- The **platform script (`hl-gen.js`) is the whole interface**: seeded randomness, token data, trait declaration, preview capture. Your code talks to it, never to the chain.
- The **seed derives from the mint transaction + token** — random functions arrive pre-seeded. Keeping your own PRNG (for portability) is fine, but seed it from the script's data and **never consume from both streams**.
- **Mint context is exposed** (minter, chain data) — the 256ART trade-off in milder form: deliberate use is legitimate, accidental use is the bug.
- Curated vs open flows assign hashes differently — check which applies.

## Docs

`https://github.com/highlightxyz/generative-art` — the canonical repo: the
script, README, FAQ, examples. **Read the script's source; it is short and it
is the contract** — prefer it over any summary, including this one.
`https://support.highlight.xyz` — creator knowledge base (generative flow,
upload, testing).

## Check before you code

What the script exposes (random, token data, mint context, traits, capture) ·
seed derivation and the curated-flow difference · bundle contents and entry
point · trait typing and when traits are read · capture trigger and size ·
available chains.

## Traps by design

Consuming from your PRNG *and* the platform's (two streams, order bugs) ·
reading mint context unintentionally · testing only one of curated/open ·
forgetting the platform script in the bundle (local stub works, upload fails).

<!-- Verified: 2026-08-28 -->

# Plottables

**In one line** — Ethereum, Art Blocks Engine, pen-plotter generative art: the
token is a generator whose outputs are meant to be physically drawn.

## Mental model

- **The contract is Art Blocks** — read `artblocks.md` and follow its sequence; this sheet only adds what plotting changes.
- **The real output device holds a pen.** Screen rendering is a preview, which inverts several defaults: strokes only (no fills, opacity, blending); **line density is the whole game** (too few wastes the ink's presence, too many drowns the paper — tuned by plotting physical prototypes, early and often); color = choice of pens per layer, not RGB; paper has a real ratio and a size in millimetres.
- Expose vector output a plotter toolchain can consume — the SVG section of `../tooling.md` (real units, one path per stroke, no fills). Generate the SVG and the preview **from the same stroke list**, or they will disagree.
- The token usually carries the plotting privilege: the generator is the artwork, a plot is an instantiation.

## Docs

`https://plottables.io` (platform, releases, applying) ·
`https://github.com/plottables` (Engine templates, plotting tools) ·
everything in `artblocks.md`.

## Check before you code

The `artblocks.md` checklist, plus: expected vector format and export path ·
standard paper sizes and ratios · how the plotting privilege is granted ·
line-count / plot-time expectations.

## Traps by design

Designing on screen, discovering on paper (opacity stacking and dense fills
turn to mud) · fills or raster effects anywhere in the pipeline · vector export
bolted on after the canvas render.

<!-- Verified: 2026-08-28 -->

# Self-hosted / no platform

No platform contract to satisfy — so this is the one prescriptive sheet: a
minimal contract worth adopting anyway, because porting, the verification
scripts and long-term survival all need the same three things: an external
seed, declared features, a done signal.

## The minimal contract

**Seed and size in, from the URL** (fallback random in dev, written back into
the URL so every output is a shareable, reproducible link):

```js
const q = new URLSearchParams(location.search);
const hash = q.get("hash") ?? "0x" + crypto.randomUUID().replace(/-/g, "").repeat(2);
const W = +(q.get("width") ?? 800);     // tools pass a size the same way —
const H = +(q.get("height") ?? 800);    // honour it, then freeze it (resolution.md)
```

(That `crypto` call is the one legitimate unseeded random in a generative
piece: choosing which piece to look at, never how to draw it.)

**Features out** — one flat object on a global, from the hash alone, before
rendering.

**Done signal** — set once the frame is genuinely complete:

```js
window.rendered = canvas;
document.dispatchEvent(new CustomEvent("genart:done"));
```

**One render entry point** — `window.render = (hash) => { … }`. Costs nothing;
enables re-rolling without reload and the A-B-A contamination test in
`../verification.md`, and forces the render to be a pure function of the hash —
the property you wanted anyway.

**Self-contained** — one entry HTML, everything inlined (fonts base64, shaders
as strings), no CDN, no fetch. Test with the network disabled: that is the
actual requirement.

## Concepts you will meet, named neutrally

- **Mint-time parameters** — the collector picks values within declared ranges before minting; the piece takes two inputs. Implemented today by bootloader `generic-web` (`bootloader.md`).
- **Preview trigger** — the piece declares "capture this frame" instead of the tooling guessing after a delay; roll your own with the done signal.

## Hosting and posterity

IPFS with a pinning service you actually pay for, or Arweave. A personal
domain is mortal. Document yourself what nobody else will: seed format,
feature weights used, capture size/ratio, target browser, the artwork's
licence and the licences of everything bundled (`../ethics.md`).

<!-- Verified: 2026-08-28 -->

# Verse

**In one line** — Ethereum; HTML+JS deployed to IPFS, hash generated at sale
time and handed to the page.

## Mental model

- **The hash arrives through the URL**, encoded, with edition info — the only platform here using a query param rather than an injected global. First thing to handle when porting in or out: a missed param silently falls back to a random seed and everything looks fine locally.
- You ship a **web page** (entry HTML + assets) to IPFS — self-containment still applies: what is not in the bundle will not exist in ten years.
- Features on a global object; preview captured automatically after sale but steerable (aspect ratio, explicit trigger, supplied image); animation accepted.
- The artist owns the contract.

## Docs — start at `https://docs.verse.works/`

Paths have **no `/docs/` prefix** (a stale prefixed link 404s and looks like
the page is gone): `/projects/generative-verse/` (the generative JS model),
`/guides/new-project/`, `/for-developers/`, `/contract/basics/`,
`/sales-mechanics/…` (edition types change the data your page receives).

## Check before you code

URL parameter name and decoded content · features object name · capture API
and aspect ratio control · expected IPFS bundle structure · which sales
mechanics affect the payload.

## Traps by design

Porting from an injected-global platform and missing the URL param · a CDN
reference left in the bundle · stale `/docs/`-prefixed links.