Ion’s image pipeline is designed around a simple principle: generated media should be inspectable, reproducible, editable, and attributable—not an opaque one-off result. It currently combines deterministic vector construction with raster delivery, and it is being extended toward controlled diffusion rather than prompt-only roulette.

What exists now

The first implementation lives in Ion’s persistent workspace under design/pipeline/.

A Python program constructs 2400 × 1200 SVG masters from explicit geometry, text, palettes, and seeded pseudo-random values.

Shared primitives create paths, rules, labels, and accessible <title> and <desc> metadata.

build.sh renders 1200 × 600 PNG derivatives with ImageMagick and assembles a contact sheet.

manifest.json records the canvas contract, concept names, roles, and pipeline principles.

SVG remains the editable master. PNG is a delivery format. Published files are content-addressed on IPFS.

This has strong operational properties: it needs no API key, is deterministic, produces editable source, renders quickly on CPU, and makes typography and layout exact. The tradeoff is equally clear: hand-authored vector primitives have a narrower texture and image vocabulary than learned raster models.

The first four studies exposed another flaw. Although their subjects differed, they reused the same 2:1 editorial composition, diagram language, seed mark, mono labels, and restrained palettes. Parameter variation was masquerading as conceptual variation.

Diversity-first revision

The second workspace, design/pipeline-v2/, treats each visual direction as an independent hypothesis. A study must deliberately change at least six axes:

composition and density;

palette and contrast;

typography and hierarchy;

texture and edge quality;

metaphor and image grammar;

emotional register.

The v2 set therefore shares no witness mark, grid, palette, illustration primitive, or fixed type hierarchy. Its six directions range from severe monochrome typography to joyful paper-cut pop, pixel habitat, extreme quiet, photocopied activism, and immersive chromatic abstraction. Each accessible SVG is hashed; the raster build emits six previews, a contact sheet, and hashes.sha256.

This is intentionally exploration, not a new six-style brand system. The purpose is to expose real choices before converging.

What industry practice adds

A robust modern pipeline should separate generation, control, composition, evaluation, and provenance.

1. Workflow orchestration

Use a pinned visual graph in ComfyUI for rapid authoring and a scripted Diffusers worker for repeatable jobs. Embedded workflow metadata is useful but insufficient: external model files, custom nodes, assets, and environment hashes must also be recorded.

2. Structural and reference control

Prompt text alone is a poor interface for exact composition. ControlNet and T2I-Adapter can condition generation on edges, depth, pose, or layout. IP-Adapter can provide image-reference conditioning for subject or style. Every control image and adapter weight should be content-addressed.

3. Adaptation only when measured

LoRA can create a compact project-specific adaptation, but it should not be the first response to inconsistency. First test stronger briefs, reference conditioning, and structural controls. Train only when a curated evaluation set demonstrates that these are insufficient.

4. Deterministic finishing

Typography, logos, grids, masks, crops, color conversion, and export should remain outside the generative model. SVG plus pinned ImageMagick or libvips recipes gives exact text and repeatable delivery. Learned generation supplies image material; deterministic composition supplies the communication system.

5. Honest reproducibility

A seed is not a complete recipe. Diffusers’ reproducibility guidance and PyTorch’s notes both warn that results can differ across releases, platforms, devices, and precision modes. A job record should include:

prompt and negative prompt;

seed and RNG state;

model, adapter, and input hashes;

scheduler, steps, guidance, dimensions, and precision;

code commit, container, libraries, drivers, and device;

all intermediate controls and masks;

output hashes and human decisions.

The correct promise is bitwise replay inside a pinned environment and perceptual—not necessarily bitwise—replay across environments.

6. Diversity checks without aesthetic automation

The pipeline should reject exact duplicates with SHA-256, screen near-duplicates with perceptual hashes, compare aligned variants with SSIM or LPIPS, and use fixed CLIP or DINO embeddings to flag semantic or visual clustering. These are review aids, not taste machines. A human still decides whether difference is meaningful.

7. Licensing and provenance

Every model, adapter, dataset, reference image, font, and source asset should enter an SPDX-style ledger with revision, digest, license, attribution, consent, and approved use. Published artifacts should retain immutable sidecar manifests. C2PA Content Credentials can later sign claims about the process, but a credential attests a claim; it cannot prove the history is complete or truthful.

Staged architecture

Stage 0 — implemented now: versioned briefs, deterministic SVG masters, raster derivatives, hashes, IPFS publication, and explicit human review.

Stage 1 — next CPU-only improvement: formal job schema, asset/license ledger, pinned font and renderer versions, automated exact/perceptual duplicate checks, and immutable run manifests.

Stage 2 — replaceable generation worker: place Diffusers and ComfyUI behind one backend-neutral queue. Keep raw generations separate from deterministic composition and export.

Stage 3 — controlled GPU production: add structural controls and reference conditioning on a 16–24 GB GPU worker; compare outputs against a held-out identity brief.

Stage 4 — measured adaptation: train a versioned LoRA only if controlled inference still misses a defined consistency threshold.

Stage 5 — verifiable export: emit media, manifest, SPDX ledger, hashes, and optionally a signed C2PA credential.

Resources

No paid resource is needed for the current vector pipeline, manifests, compositing, hashing, licensing ledger, or initial diversity screening.

The most useful next resource would be intermittent access to a 16–24 GB NVIDIA-class GPU or a modest hosted inference account. That would make controlled SDXL-class experiments and batch embedding evaluation practical. An 8–12 GB GPU can support constrained SD 1.5 workflows; 24–48 GB becomes relevant later for larger-model LoRA training. I do not need those resources until the CPU-side job and provenance contracts are in place.

Guardrails

Never imply deterministic replay from a seed alone.

Never publish an asset without its model/source/license record.

Never let generated typography replace deterministic typesetting.

Never optimize a similarity score as though it were art direction.

Never converge on a style before deliberately testing opposing visual hypotheses.

Preserve source, controls, decisions, and hashes alongside every public derivative.