A working catalogue of the ij8 · studio.

Premise

ij8 is a generative creative studio for serious artists. Image, video, 3D, code, sound, classroom work, and gallery distribution converge in a single chat-driven canvas. The studio is in active development; the gallery and minting infrastructure are live. Its stance toward AI is a middle way — a collaborator the artist directs and authors with, not a system that replaces the work, and not a pace the artist must match. The human brings the vision, the taste, and the questions; the AI brings the speed and the hands. The same position carries into how it teaches.

Image generation

The image surface is multi-backend by design: Gemini first, OpenAI fallback, and a ComfyUI workflow library for specific model families and edit modes.

Image editing

The editing layer is region-aware. Masks, bounding boxes, popovers, inpaint variants, background removal, crop, outpaint, upscale, and code-to-raster conversion are treated as normal studio operations.

• Mask painter

  MaskEditor, MaskToolbar, and BoundingBoxOverlay support precise selection, freehand masks, region selection, and bounding-box overlay.

• Inpaint

  Three inpaint paths are wired: Gemini multi-turn, Kontext Flux through ComfyUI, and a ComfyUI inpainting workflow. The inpaint variation picker is backed by sessionStorage across turns. Within the ComfyUI path, inpaint likewise prefers Flux Fill over the selected checkpoint whenever its components are available.

• Canvas edits

  Outpaint, crop, zoom-enhance, upscale, remove-region, and region popovers are available operations. Outpaint always runs Flux Fill — a true inpainting model that conditions on the original pixels — regardless of which 2D model is selected: the selected model is the generation engine, not the outpaint engine. Extension proceeds one edge per pass with computed feathering and a smoothstep soft-stitch that composites the true original back over the render, so the preserved region is untouched and the seam is structural, not cosmetic. The same workflow runs identically on the local GPU and on HPC, with a preflight that verifies all four Flux Fill components before committing. Outpaint runs as an async job so long passes outlive Cloudflare's ~100s ceiling.

• Background removal

  rembg runs as a Python subprocess with four variants: general, anime, precise, and birefnet.

• Region popovers

  A selected region opens a popover for a localized prompt, prompt enhancement, and an applied inpaint edit — refining one area without reprompting the whole image.

• Code raster

  convert-to-2d captures code-rendered output as a raster image so sketches can re-enter the visual pipeline.

Video

Video generation spans local ComfyUI workflows, Minimax API models, masked video inpaint, animation pipelines, and frame-level timeline inspection.

3D

The current 3D target is HunYuan3D 2.1. The pipeline separates shape and texture generation, prepares 2D sources for silhouette extraction, and presents meshes in a browser viewer.

• HunYuan3D 2.1

  Current target. Dual-pass shape generation followed by texture generation. ComfyUI restarts between the shape and texture passes to clear VRAM — the two stages do not fit simultaneously on the single 24GB GPU.

• HunYuan3D 2.0

  Alternate target retained in the 3D path.

• Prep prompt

  build3DPrepPrompt re-renders the 2D source as a sculpture on a light-gray background. Black voids were producing shredded silhouettes. The Convert-to-3D path sends tPose and prepFor3D flags so the source is re-rendered as a sculpture before HunYuan3D conversion.

• Job queue

  The 3D queue is durable, has startedAt for stale-recovery, and scopes fulfill jobs per user.

• Multi-view

  Single-image 3D must hallucinate what it cannot see — the flat-back problem. An MV picker locks the current image as the front view and fills back/left/right either from hand-picked session images or from a single "Generate views" click that synthesizes turntable rotations. With two or more views, the shape pass runs the HunYuan3D multi-view checkpoint, conditioning the mesh on every labeled view.

• Mesh viewer

  model-viewer supports turntable yaw and APNG rotation export.

• Fulfill worker

  The async fulfill worker sits behind an internal-secret-gated route. Jobs are cancelable mid-pipeline: cancel is ownership-checked and idempotent, interrupts the in-flight ComfyUI workflow, and the fulfill worker observes cancellation between every stage — prep, T-pose, shape, texture — with per-stage timeouts.

Animation + rigging

Rigging combines conventional retargeting, UniRig auto-rigging, a geometric morphology classifier, free-form RigSpec authoring, and Blender-driven bakes streamed over SSE for long jobs.

• Retargeting

  retarget-mixamo.ts runs Mixamo FBX retargeting through a Blender subprocess.

• UniRig

  unirig.ts provides auto-rigging.

• Morphology

  scripts/classify_morphology.py and classify-morphology.ts use a Fibonacci-sphere ray probe to identify radial, stalk, body-tail, and pulse-mass archetypes.

• RigSpec

  lib/rig/spec.ts and lib/rig/topology.ts define a free-form AI rig schema and topology archetypes. scripts/bake_rig.py and bake-rig.ts bake through Blender.

• Behaviors

  Continuous behaviors include sway, pulse, softbody, and rotate.

• Long bakes

  /api/rig/auto-smoke is SSE-streamed to survive Cloudflare’s 100s upstream timeout for dense radial bakes with 100+ bones across 240 frames and multiple chains.

• Weighting

  The hub bone gets influenceRadius via a chain to prevent global hub dominance through manual_distance_weights. Orphan vertices fall back to the nearest bone to prevent static appendage islands.

• Debug surface

  /rig-test is the debug surface for rigging work.

Code generation

The code surface supports creative coding, shader sketches, validation in Chromium, forked sketches, and conversion of code output into images.

Sound

Sound is a shipped medium, not a planned one. Music, sound effects, and video-to-audio foley generate through ComfyUI; Tone.js is wired as a fourth creative-coding framework so audio can be authored alongside a visual sketch.

Storyboards

A storyboard is a sequence of panels — image, video, 3D, code, or text — assembled inside the same chat-driven canvas, with a scaffolded outline, real per-panel playback, an optional ambient soundtrack, and a Present mode for review and sharing.

• Sidebar tab

  Storyboards live in their own sidebar tab (alongside Folders and Collections). The dropdown switcher above the tab list is the entry point on narrow widths.

• Brainstorm

  Brainstorm scratchpad with Refine and Send to storyboard seeds an outline; AI fills the outline progressively via the update_outline tool and always offers a "your own direction" option.

• Outline → panels

  The scaffolder writes one placeholder panel per outline beat and auto-navigates to the new storyboard. Generate-this on a placeholder replaces it with the real artifact for its declared media type.

• Panels in canvas

  3D panels render textured and animated like the canvas itself (not as static frames). Video and code panels run their real previews. Any result can be sent to a storyboard from the viewer toolbar's collection picker.

• Captions

  Panel captions are auto-written from the outline plus image descriptions via Gemini; saved with the panel.

• Soundtrack

  An ambient music bed is generated inline (kind: 'music') from the storyboard title + outline. The track loops in Present mode and has a volume slider and a mute toggle.

• Present mode

  Narrate toggle, auto-advance, and loop. A render-loop cancellation fix from the May rollout keeps narration + auto-advance from dying between panels.

• Scenes

  Panels group into named scenes — add, rename, reorder, and per-panel scene assignment are all in the storyboard UI. Storyboard is also a collection mode (see Distribution).

Apps + classroom

The studio itself is the app surface: chat, canvas, collections, and classroom. The classroom layer adds authoring, cohorts, lesson sessions, AI grading, and exportable reports. The middle way carries into teaching: ij8 teaches AI literacy, computational thinking, design, and creative innovation by having students make — self-paced, with full instructor control and visibility. The full teaching reference is at classroom.ij8.ai; institutional pilots and partnerships are at pilots.ij8.ai.

• Scaffolding

  course-scaffold.ts creates AI course scaffolds. /api/courses/syllabus/parse parses syllabi.

• Authoring

  CourseAuthorWorkspace and the course wizard modal support course authors.

• Lessons

  /api/lessons/sessions/[id]/next advances lesson sessions step by step. Lessons are self-paced: the mastery score is live feedback toward a visible goal, never a lock on the next lesson.

• Grading

  lesson-scoring.ts uses gemini-3.1-flash-lite as the judge. The v2 algorithm splits weight by code-eligibility: code lessons earn engagement points across turns and apply / edit channels; non-code lessons (text, image, audio, 3D) reallocate apply-channel weight back to turns so a writing or sound lesson can reach the full 100. The judge sees the actual rendered artifact alongside the student's prompts, code, and explanations.

• Roles

  Roles are admin, dev, teacher, student, and user. Cohorts and cohort memberships are part of the data model.

• Commons

  The Commons course pool is shared across teachers. Course reports and CSV export are available.

• Shell

  AppShell, Sidebar, LearnPanel, and LessonScoreHud integrate into the chat-canvas surface.

• App Lab

  lib/ai/app-lab/ is the guided-prototype framework: context-pack.ts bundles the refined prompt, requirements, constraints, variables, and an output sample; prototype-generator.ts generates a single-file React-CDN HTML prototype (React 19 UMD + ReactDOM + Tailwind + Babel Standalone, hash-routing, localStorage, mock FakeAuthProvider); inspect.ts validates structure and Babel syntax; virtual-files.ts isolates context; detect-underspecification.ts flags incomplete briefs; up to two repair attempts on validation failure; soft cap 750 KB, hard cap 1.5 MB. Prototypes are teaching-grade — readable and annotated — not production.

• Lesson media types

  Lessons declare which media types are allowed: image, video, 3d, code, app, text, and audio (which subsumes music, SFX, and foley). Text-mode chat is inlined; artifacts save explicitly. When both text and other modes are allowed, the lesson defaults to non-text so the canvas isn't crowded out.

• Teacher controls

  Teachers can override lesson sessions with Mark complete and Reopen. Restarting a lesson snapshots the prior outline as a tile in the new session so the student keeps a thread to what came before.

• Tutorials

  Alongside lessons: 50 official AI-led tutorials, each teaching one tightly scoped concept on an Explain → Show → Play → Make arc, with the canvas as the blackboard — every idea illustrated by a live, runnable sketch that was vetted before any student sees it. Ungraded by design, open to every signed-in account, searchable by tag and difficulty. Teachers author their own tutorials with AI co-authoring and accept-to-freeze illustration review, and courses interleave lessons and tutorials in one ordered curriculum. The full teaching treatment is at classroom.ij8.ai.

• Student showcase

  Students publish curated work to a public, teacher-curated class gallery (apps/showcase, served at showcase.ij8.ai) — cohort-scoped and wallet-free, distinct from the NFT gallery. Submissions move student → teacher curation (approve, cohort↔public, scene) → public reader; approved code sketches render live via /api/sketches/[id]/wrapped.

Hybrid approaches

The platform is strongest when a work moves between modes. The following cross-pipeline flows are routine or directly implied by wired surfaces.

1. Image to 3D mesh

   Generate or import a 2D image, run the 3D prep prompt, extract shape, texture, and inspect in the model viewer.

2. Mesh to rigged animation

   Generate a mesh, classify morphology, author or infer a RigSpec, then bake continuous behavior in Blender.

3. Sketch to image

   Generate p5.js or GLSL, run it, capture the canvas frame, and store the result as an image.

4. Image to mask to video

   Select a region, create a mask, and send the image/mask pair into VACE or another video pipeline.

5. Mask to inpaint variation

   Paint a mask, generate multiple inpaint variants, and retain picker state across turns.

6. Image to background removal to 3D

   Batch remove background with rembg variants, then feed the cleaner silhouette to HunYuan3D.

7. Animation frame to image edit to re-animation

   Scrub to a frame, edit it as an image, then use the altered frame as a new animation source.

8. Code to APNG

   Run a sketch or shader, capture frames, and export a lightweight loop.

9. Sketch to sound

   Pair Tone.js into a visual sketch with the audio-visual toggle so sound is authored alongside the canvas rather than added afterward.

10. Video to foley

    Generate or scrub a video, then run HunyuanVideo-Foley to synthesize a matching audio track for it.

11. Course session to minted collection

    Use classroom-guided production to generate work, curate outputs, then publish through collections.

12. Drawing to artifact

    One freehand pad, two destinations: render the drawing as a finished image, or hand it to the code model as vision guidance and get the form back as live geometry in code.

13. Still to regional motion

    Mask a region of a finished image and animate only that region into a looping video; the rest stays the literal photograph.

14. Views to solid mesh

    Hand-pick or synthesize back/left/right views of a subject, then condition the 3D shape pass on all of them to kill the flat-back problem.

15. Generative reserve to fulfill

    An on-chain reservation triggers background image generation, IPFS pinning, and on-chain fulfillment.

16. Image edit to gallery drop

    Use conversational editing and background removal to refine a work, then place it inside a scheduled gallery release.

17. Codegen collection

    Fork a sketch, validate it in Chromium, mint or surface it as a codegen lane collection.

Distribution: gallery, collections, NFT

The distribution layer is live: artist pages, collection pages, scheduled drops, IPFS pinning, Ethereum contracts, royalties, blind reveals, regenerative fulfill, and gallery surfacing.

• Contracts

  IJGCollection.sol V1, IJGCollectionV2.sol generative reservation, IJGCollectionV3.sol regeneration + refund + cloneable, and IJGCollectionFactory.sol EIP-1167 minimal-proxy clones.

• Chain + tests

  Solidity 0.8.28, Cancun EVM, OpenZeppelin v5.4, 66 contract test cases across 3 suites (V1, V2, V3), Hardhat tooling. Sepolia V1 deploy: 0x92B10e1f7107D7A2436445B4842a8077d041151e, verified.

• Collection modes

  open, closed, edition, generative, blind, codegen, storyboard, and showcase. Creative lanes: ai, code, hybrid. Storyboard and showcase are deliberately non-NFT modes: storyboard is a project workspace that hides all minting and contract UI; showcase carries per-item curation state (pending/approved, cohort/public) for teacher-curated class galleries.

• IPFS + fulfill

  Pinata REST API handles IPFS pinning. Generative drops move from on-chain reserve to non-blocking image-gen fetch to IPFS pin to on-chain fulfill, with recovery and regen-status routes for orphans.

• Blind drops

  Blind drops use the same Closed contract mode, with an API/UI redaction layer that reads tokenSold() on-chain and nulls filePath, title, and prompt for unsold items on a five-second cache.

• Regeneration (V3)

  V3 collections expose regenerate(tokenId) bounded by a maxRegenerations counter. The full state machine is reserved → generating → pinning → fulfilling → fulfilled, with refundGenerative() closing the loop when a generation fails. Recovery and regen-status routes pick up orphaned reservations.

• Storyboard collections

  The storyboard collection mode is a non-NFT project surface: panels render live in the studio canvas and in the class-showcase reader — 3D panels textured and animated, video and code panels running their real previews, an optional ambient soundtrack looping in Present mode. It deliberately hides minting and contract UI.

• Royalty + fee

  ERC-2981 royalty is 7.5% on secondary sales. Platform fee is 10% on primary sales.

Backends + routing

Generation is routed per request across four ComfyUI backends. For most users the choice is silent — they see generation time, not infrastructure. Users granted remote access get an explicit Compute backend toggle. Per-user and per-cohort opt-in gates HPC access; audio always pins to local.

• Local 4090

  Studio host, no tunnel. Default for every user. Audio (music, SFX, foley) pins here unconditionally — remote round-trip exceeds generation time.

• SMU SuperPOD A100

  Reached via an SSH -L tunnel from the studio host. Env: COMFYUI_URL_HPC. Opportunistic partition scheduling prefers the short partition (4-hour cap) over contended batch and auto-retargets pending jobs as queues shift. Cannot serve commercial / paid work — gated by cohort + user flag.

• RunPod

  Secondary remote target for commercial / paid work and for capacity overflow. Env: COMFYUI_URL_RUNPOD or COMFYUI_RUNPOD_URLS.

• RunComfy API

  Managed-template backend with bearer-token auth. Suited to workflows already curated by RunComfy (e.g. HunYuan3D 2.1). Cold-start latency on min_instances=0 templates is ≈ 8.5 minutes — pre-warm before class. RunComfy also serves 2D generation now: Flux 2 Dev, Qwen-Image 2512, Flux 2 Klein, and Z-Image Turbo are mapped to serverless model endpoints.

• Routing

  comfyui-backend.ts uses AsyncLocalStorage — a comfyBackendStore typed as ComfyBackendContext: the per-request preference is resolved at the route layer and inherited by every downstream getComfyUrl() call. No global state, no parameter threading through 20 callees.

• Liveness

  Two-stage probe per backend: a 700ms TCP connect (detects whether an SSH tunnel is up at all), then a 3s HTTP GET /queue (alive but allows for heavy generations). 15-second cache. Timeouts on the HTTP stage are treated as alive-but-slow so polling does not falsely demote a backend mid-generation.

• Access

  Per-user users.hpcAccess and per-cohort cohorts.hpcAccess opt-in HPC routing. Preference field settings.preferredComfyBackend = 'local' | 'hpc' | 'runpod' | 'api' | 'auto'; 'auto' normalizes to local; 'api' selects the RunComfy managed-template path.

• Health

  /api/health reports each backend independently: DB (SELECT 1), ComfyUI /queue probe, HunYuan 3D model presence, and API-key presence for Gemini / OpenAI. Latency captured per backend. Status: ok / degraded / down.

• Provider settings

  /api/admin/providers exposes platform-level provider toggles and per-platform key overrides; platform_provider_settings + user_provider_settings tables back per-user keys (platform and per-user settings both have shipped UI; users can supply their own provider keys in the settings panel).

Routing policy is intentionally policy-driven rather than availability-driven: paid / commercial requests must not be routed to SMU. Free / educational requests can fall back to local if HPC is unreachable.

Roadmap

Roadmap items are marked by current state. Sound has shipped and has its own section; word remains a planned medium, not yet a shipped feature.

Open questions / what artists shape

Founding-cohort artists are invited to influence which roadmap items get prioritized and what bespoke workflows are developed around their practice. The relationship is closer to founding members than customers: the tools should be tested against real methods, not generic usage funnels.

Open questions include which hybrid flows matter most, where bespoke artist tools should become shared primitives, which distribution formats should sit beyond NFT, and how word should enter the same canvas — and how sound should deepen — without becoming ornamental add-ons. Drawing as a first-class input — one pad feeding both image and code — and storyboard authoring are the most recent shapes under active redesign; the questions there are about how much narrative scaffolding to bake in before it stops feeling like an open canvas.

Index / colophon

Complete enumeration of named models, backends, contracts, and infrastructure in this reference.

Self-hosted Inter. No tracking. No external scripts. Single-page static output for tooling.ij8.ai. Last rendered June 12, 2026.