Liminal — I/O Catalog & Reference Gallery

Input Formats

All the data formats Liminal can ingest, from text prompts to binary blobs.

#	Format	Description	Handler	Status
1	Text	Prompts via `--prompt`, TUI, chat mode	`src/index.ts`, `src/tui/`	Done
2	JSON	Config files (`~/.liminal/config.json`)	`src/config/ConfigLoader.ts`	Done
3	JSON (legacy)	`~/.atelier/config.json` — auto-migrated	`ConfigLoader.migrateLegacyConfig()`	Done
4	.env	Key-value environment variables	`dotenv` in `bin/liminal`	Done
5	JSON (spec)	Composition layer specs	`src/composite/Compositor.ts`	Done
6	Audio	MP3, WAV, OGG, M4A, FLAC	`src/audio/`	Partial
7	JSON (aesthetic)	Aesthetic preset config	`src/aesthetic/`	Partial
8	Markdown	Narrative video scripts	`src/narrative/BlogToVideoPipeline.ts`	Done
9	Multi-format	Compost heap: code, images, audio, video, 3D, text	`src/compost/`	Done
10	SQLite	Event store databases	`src/compost/EventStore.ts`	Done
11	ZIP	Project archive imports	`src/composition/ProjectSerializer.ts`	Done
12	URL	Remote project JSON	`ProjectSerializer.importFromURL()`	Done
13	Float32Array	Raw audio sample buffers	`src/audio/AudioExtractor.ts`	Done

Output Formats

Every format Liminal can produce — code, images, audio, video, data, and text.

#	Format	Description	Producer	Status
1	p5.js JS	Creative coding canvas sketches	`src/generators/p5/` (6 generators)	Done
2	Three.js HTML	3D WebGL scenes	`src/generators/three/`	Done
3	GLSL	Fragment shader source code	`src/generators/glsl/`	Done
4	Hydra JS	Analog video synth code	`src/generators/hydra/`	Done
5	Strudel JS	Live music patterns (TidalCycles)	`src/generators/strudel/`	Done
6	Tone.js JS	Web Audio synthesis code	`src/generators/tone/`	Done
7	Revideo TS	Generative motion graphics	`src/generators/revideo/`	Done
8	HTML	Standalone wrapped docs (9 templates)	`src/utils/htmlWrapper.ts`	Done
9	ASCII	Character-based visual art	`src/generators/ascii/`	Done
10	Gen. Text	Concrete poetry, word art	`src/generators/textgen/`	Done
11	Markdown	Digest reports, video scripts	`src/compost/DigestGenerator.ts`	Done
12	PNG	Canvas screenshots	`src/render/Renderer.ts`	Done
13	JPEG	Canvas screenshots	`src/render/Renderer.ts`	Done
14	MP4	Rendered video (FFmpeg / Revideo / HyperFrames)	`src/render/CanvasRecorder.ts`	Done
15	WebM	Video export (FFmpeg)	`src/export/VideoExporter.ts`	Done
16	GIF	Animated GIF (FFmpeg)	`src/export/VideoExporter.ts`	Done
17	ZIP	Project bundles	`src/export/Exporter.ts`	Done
18	JSON	API responses, metadata, organisms	`src/render/PreviewServer.ts`	Done
19	SSE	Server-Sent Events (live preview)	`src/render/PreviewServer.ts`	Done
20	Scores	Visual & audio quality (0–1)	`src/render/VisualScorer.ts`	Done
21	Embeddings	Float32Array semantic vectors	`src/embeddings/EmbeddingService.ts`	Done
22	SQLite	Event & project databases	`src/compost/EventStore.ts`	Done

Stubbed / Not Yet Implemented

Started but blocked on external dependencies.

Module	What's Missing	Blocker	Status
`SemanticExtractor.extractImage()`	Image → text from compost	Needs vision-capable LLM	Stub
`SemanticExtractor.extractAudio()`	Audio → text transcription	Needs Whisper or similar STT	Stub
`SemanticExtractor.extractVideo()`	Video → text extraction	Needs frame sampling + vision model	Stub

Infrastructure & Architecture Map

What each I/O format means in terms of runtime dependencies, external services, and system architecture. Every format carries infrastructure weight.

Text Prompt

→

ConfigLoader

→

LLMClient

→

Generator

→

Code Output

→

Renderer

→

PNG / MP4 / GIF

Audio File

→

AudioAnalyzer

→

VisualMapper

→

Generator

→

Hydra / p5.js

Compost Files

→

Shredder

→

CollisionEngine

→

SeedBank

→

Seeds / Digest

Dependency Map by I/O Format

p5.js JavaScript

Runtime: Node.js + LLM API call to generate code
Output rendering: Puppeteer or Playwright headless browser
Screenshot: Canvas .toBuffer() → PNG/JPEG
Dependencies: p5 (CDN in HTML wrapper) CDN
Video: Frame sequence → FFmpeg FFmpeg
Infrastructure weight: Medium — needs headless browser + optional FFmpeg

Three.js HTML

Runtime: Node.js + LLM API call
Output: Complete standalone HTML with import maps
Rendering: WebGL via Playwright (GPU-accelerated headless)
Dependencies: three (import map / CDN) CDN
Infrastructure weight: Medium-High — WebGL requires GPU-capable headless browser

GLSL Shaders

Runtime: Node.js + LLM API call (shader source generation)
Output: Plain text .frag / .glsl files
Rendering: WebGL2 via HTML wrapper — requires GPU for preview
Dependencies: None for generation; WebGL2 for rendering
Infrastructure weight: Low for generation, High for rendering (GPU)

Hydra JavaScript

Runtime: Node.js + LLM API call
Output: JavaScript source for hydra-synth
Live execution: Browser-only — Hydra uses WebRTC + Canvas
Dependencies: hydra-synth npm or CDN CDN
Infrastructure weight: Low for code gen; Live preview needs browser

Strudel JavaScript

Runtime: Node.js + LLM API call
Output: JavaScript pattern code (TidalCycles mini-notation)
Audio rendering: Web Audio API via Strudel REPL in browser
Dependencies: @strudel/repl or embedded REPL npm
Headless audio: Playwright + WebAudio capture → Float32Array Optional
Infrastructure weight: Low for code gen; Medium for headless audio capture

Tone.js JavaScript

Runtime: Node.js + LLM API call
Output: JavaScript using Tone.js scheduling + synthesis API
Audio rendering: Web Audio API in browser or headless Playwright
Dependencies: tone npm or CDN CDN
Headless audio: Playwright captures Float32Array from AudioContext Optional
Infrastructure weight: Low for code gen; Medium for audio capture

Revideo TS + MP4

Runtime: Node.js + LLM API call + @revideo/renderer
Output: TypeScript motion graphics + rendered MP4 video
Build pipeline: @revideo/core + @revideo/2d → @revideo/renderer (in-process renderVideo)
Dependencies: @revideo/core, @revideo/2d, @revideo/renderer Optional
Infrastructure weight: Medium — Revideo uses in-process rendering without a separate bundler

PNG / JPEG Screenshots

Rendering: Puppeteer or Playwright headless browser
Process: Load HTML wrapper → wait for canvas render → screenshot
Scoring: Pixel analysis via png-js or sharp (color variety, edges, contrast)
Dependencies: Puppeteer or Playwright Binary
Infrastructure weight: Medium — headless browser is the main cost

MP4 / WebM / GIF Video

Pipeline A (Canvas): Puppeteer frame capture → PNG sequence → FFmpeg
Pipeline B (Revideo): TypeScript motion graphics → @revideo/renderer (in-process)
Pipeline C (HyperFrames): HTML+GSAP compositing → @hyperframes/producer
Transcoding: FFmpeg handles MP4, WebM, GIF conversion + resize + audio merge
Dependencies: ffmpeg binary, fluent-ffmpeg npm Binary
Infrastructure weight: Heavy — FFmpeg binary + headless browser + large temp storage for frames

Audio Input (MP3, WAV, OGG...)

Analysis: meyda for MFCC, spectral centroid, chroma Optional
Pitch detection: pitchfinder for frequency + clarity Optional
Metadata: music-metadata for BPM, key, duration Optional
Formant analysis: Custom DSP for vowel/consonant classification
Infrastructure weight: Low — pure JS DSP, no external services. Optional deps increase install size.

Compost Pipeline (Multi-format)

Storage: Filesystem heap + SQLite (better-sqlite3) for events/assets
Text extraction: Direct file read + LLM summarization
Code parsing: AST analysis via tree-sitter or regex heuristics
Binary processing: SHA256 hash + hex dump + base64 (files < 100KB)
LLM collision: Semantic merging of cross-domain fragments via LLMClient
Infrastructure weight: Medium — SQLite + filesystem + LLM API calls for collisions

Embeddings & Semantic Search

Model: @xenova/transformers (local SBERT, no API needed)
Output: Float32Array vectors (384-dim typical)
Operations: Cosine similarity, Euclidean distance, KNN search
First run: Downloads ~30MB model weights (cached locally after)
Infrastructure weight: Low-Medium — runs locally, one-time model download, CPU-bound

SSE + Preview Server

Transport: HTTP server (Express or native http)
Live updates: Server-Sent Events (text/event-stream)
Endpoints: Gallery API, sandbox execution, export, CSRF tokens
Sandbox: Isolated code execution in sandboxed iframe or VM
Infrastructure weight: Low — standard Node.js HTTP server, no external deps

ZIP Archives

Export: archiver npm — bundles project.json + iterations + HTML
Import: JSZip — parses uploaded project archives
Contents: project.json, iterations/*.js, index.html, sketch.js
Infrastructure weight: Minimal — pure JS compression, no binaries

Visual & Audio Scores (0–1)

Visual scoring: Pixel-level analysis — color variety, edge complexity, composition balance, contrast
Audio scoring: Signal analysis — frequency variety, dynamics, rhythm detection, harmonic richness
Output: JSON score objects used by RalphLoop and quality gates
Infrastructure weight: Minimal — pure JS computation on existing render buffers

SQLite Persistence

Library: better-sqlite3 (native binding, synchronous API)
Tables: events, snapshots, branches, assets (content-addressable blobs)
File: project.liminal in project root
Infrastructure weight: Low — single file DB, native binding requires build toolchain

Infrastructure Dependency Summary

Dependency	Type	Used By	Install Impact
`LLM API`	External	All generators, SemanticExtractor, CompostSoup collisions	API key + network
`Puppeteer / Playwright`	Binary	Renderer, HeadlessRenderer, CanvasRecorder, VisualScorer	~300MB Chromium download
`FFmpeg`	Binary	VideoExporter, CanvasRecorder, all video/GIF output	System binary via brew/apt
`@revideo/*`	Optional	RevideoGenerator, RevideoRenderer, VideoPipeline	optionalDependencies
`@hyperframes/producer`	Optional	HyperFramesGenerator, HyperFramesRenderer, VideoPipeline	optionalDependencies
`better-sqlite3`	Runtime	EventStore, AssetStore, ProjectStore	Native build (node-gyp)
`@xenova/transformers`	Optional	EmbeddingService	~30MB model on first run
`meyda`	Optional	AudioExtractor (MFCC, spectral features)	Pure JS, no binary
`pitchfinder`	Optional	PitchExtractor (frequency, clarity)	Pure JS, no binary
`music-metadata`	Optional	BPMKeyDetector	Pure JS, no binary

Reference Gallery

Real-world examples of each creative coding output domain from across the internet.

p5.js Creative Coding Sketches

JavaScript canvas library for generative art, interactive installations, and data visualization. Liminal has 6 p5 generators including ParticleSystem, CellularAutomata, and FlowField.

🎨

p5.js

Lauren McCarthy — p5.js Itself

Created in 2013 as a reinterpretation of Processing for the web. Won a Golden Nica at Ars Electronica. Designed with an explicit focus on accessibility and reaching beyond traditional CS audiences.

p5js.org →

🚂

p5.js

Daniel Shiffman — The Coding Train

The largest creative coding educational resource on the internet. Millions of views covering genetic algorithms, flocking, fractal trees, and more — all built in p5.js.

thecodingtrain.com →

✈️

p5.js / Processing

Aaron Koblin — Flight Patterns

FAA flight trajectory data visualized over the US, revealing hidden patterns in air traffic. Exhibited at MoMA and the V&A. A landmark in data-driven generative art.

aaronkoblin.com →

🔤

p5.js / openFrameworks

Zach Lieberman — Daily Sketches

Year-long daily coding experiments exploring typography, optical illusions, and computational poetry. Co-creator of openFrameworks and MIT Media Lab professor. Inspired thousands to start daily creative coding practices.

instagram.com/zach.lieberman →

GLSL Fragment Shaders

GPU-accelerated visual art written in GLSL fragment shaders. Liminal's ShaderGenerator produces standalone WebGL2 shader code.

⛰️

GLSL

Inigo Quilez — "Elevated"

Co-creator of Shadertoy. "Elevated" is legendary — a fully procedural 3D terrain with lighting, atmosphere, and water, computed entirely in a single fragment shader. The canonical reference for raymarching and SDFs.

shadertoy.com/view/4dsGD2 →

🔮

GLSL

Kali — Fractal Explorations

Extraordinarily complex fractal shaders rendering alien landscapes and recursive geometries in real-time at 60fps. Pushes the mathematical limits of per-pixel GPU computation.

shadertoy.com/user/Kali →

🌊

GLSL

BigWIngs — "Painting with Math"

The best shader tutorial content available. Covers raymarching, voronoi patterns, fluid simulation, and organic motion. His YouTube channel "Art of Code" is the go-to curriculum for learning GLSL.

shadertoy.com/user/BigWIngs →

Hydra Analog Video Synthesis

Browser-based visual synthesis inspired by analog video mixers. Functional chaining syntax for real-time live-coded visuals. Liminal's HydraGenerator produces hydra-synth compatible code.

📺

Hydra

Olivia Jack — Hydra Itself

Created in 2018, inspired by the Sandin Image Processor and Rutt-Etra analog synthesizers. Democratized live coding visuals worldwide. A staple of Algoraves, transmediale, MUTEK, and STRP.

hydra.ojack.xyz →

🤸

Hydra

Naoto Hieda — Hydra + Body Tracking

Live-coded visuals combined with PoseNet/MoveNet body tracking. The performer's movements directly shape the visuals — expanding Hydra into full-body live performance art.

naotohieda.com →

🎵

Hydra

Alexandra Cardenas — Algorave Visuals

Prominent live coder using Hydra for real-time visuals alongside TidalCycles audio. Performances at MUTEK, Network Music Festival, and ICLC showcase Hydra as a live instrument.

tremens.lvctrl.net →

Strudel Live Coding Music

Browser-based live music coding with TidalCycles mini-notation. Liminal's StrudelGenerator produces pattern code compatible with the Strudel REPL.

🎶

Strudel

Strudel REPL — Official Playground

The main interactive environment. All examples are immediately playable in the browser — from simple beats to Euclidean rhythms, scale transformations, and complex algorithmic compositions.

strudel.cc →

🎹

Strudel / TidalCycles

Alex McLean (yaxu) — Creator

Originator of TidalCycles and Strudel. Live performances showcase the most advanced pattern mutation, polyrhythms, and sample manipulation. Coined the term "Algorave."

yaxu.org →

🕺

Live Coding

Algorave — Global Live Coding Festival

Global movement of live-coded music performances. Artists use Strudel, TidalCycles, and Sonic Pi in front of audiences. Dozens of recorded performances on YouTube and Twitch.

algorave.com →

🎛️

TidalCycles / Strudel

Kindohm (Mike Hodnick) — Algorithmic Techno

Notable live coder known for algorithmic techno performances. Pushes the rhythmic complexity of live-coded music with dense, evolving pattern structures.

kindohm.com →

Three.js 3D WebGL Scenes

Complete HTML documents with WebGL 3D rendering. Liminal's ThreeGenerator produces full standalone HTML pages with import maps and Three.js setup.

🧊

Three.js

Mr.doob — Three.js + "The Wilderness Downtown"

Ricardo Cabello created Three.js, the dominant WebGL library. His Arcade Fire Chrome experiment was a watershed for interactive web 3D — won a Cannes Lions Grand Prix.

threejs.org →

🌌

Three.js

Matt DesLauriers — Generative Art + 3D

Bridges generative art and interactive 3D. Art Blocks projects, real-time event visuals, and the canvas-sketch tooling. Conference talks at React Europe and Full Stack Fest.

mattdesl.com →

🏔️

Three.js

Gerard Ferrandez — Procedural Landscapes

Intricate procedural 3D scenes — fractal landscapes, particle systems, organic forms. Consistently among the most technically impressive pure Three.js demos on CodePen.

codepen.io/ge1doot →

Tone.js Web Audio Synthesis

Browser-based audio synthesis with scheduling, transport, effects chains, and polyphonic instruments. Liminal's ToneGenerator produces Tone.js code for generative music.

🎹

Tone.js

Tone.js Official Examples

Built-in demos: browser synth, step sequencer, multi-player, envelope shaping. The definitive starting point for understanding the framework's range.

tonejs.github.io/examples →

🌊

Tone.js

Tero Parviainen — Generative Music

Widely cited as the best educational resource for Tone.js generative music. Covers probability, Markov chains, and self-evolving ambient systems.

tero.parviainen.com →

Revideo Generative Motion Graphics

TypeScript-based motion graphics rendered to MP4 via @revideo/renderer. Liminal's RevideoGenerator produces programmatic animation code with full control over timing, easing, and visual elements.

🎬

Revideo

Revideo — Programmatic Video Framework

TypeScript-first motion graphics with React-like components. In-process rendering via @revideo/renderer — no external bundler required. Supports 2D shapes, text animation, and export to MP4/GIF.

revideo.io →

📊

Revideo

Revideo GitHub — Source & Examples

Open-source codebase with examples covering parametric animation, data-driven motion, and programmatic video generation. Apache 2.0 license.

github.com/redotvideo/revideo →

🏢

Revideo

Revideo Docs — Guides & API Reference

Comprehensive documentation covering project setup, rendering pipeline, component API, and deployment patterns. Includes tutorials for generative art workflows.

docs.revideo.io →

ASCII Character-Based Visuals

Text art using character density to represent images. Liminal's ASCIIArtGenerator produces character art from prompts.

🖼️

ASCII

ASCII Art Generator — Image to Characters

Image-to-ASCII conversion with adjustable density, width, and inversion. A benchmark for conversion quality.

ascii-art-generator.org →

🔤

ASCII

Text-Image.com — Reference Converter

High-quality image-to-ASCII with colored HTML output and various character sets. A long-standing reference implementation.

text-image.com →

🐢

ASCII

kr15h — Generative ASCII Landscapes

Procedural generation combined with character rendering to create animated, evolving ASCII landscapes. Open-source experiments on GitHub.

github.com/kr15h →

Gen. Text Concrete Poetry & Word Art

Algorithmic text art, generative poetry, and typographic experiments. Liminal's TextGenerativeGenerator produces concrete poetry from prompts.

🌿

Gen. Text

Nick Montfort — "Taroko Gorge" (2009)

One of the most well-known generative poetry generators. Produces endless nature poetry in the browser. Remixed dozens of times. A foundational reference for computational poetry.

nickm.com/taroko_gorge →

📝

Gen. Text

Allison Parrish — Word-Vector Poetry

Computational linguistics art using word embeddings for poetic generation. "Articulations" and the Pronouncing library are landmark achievements in computational literature.

decontextualize.com →

📖

Gen. Text

NaNoGenMo — National Novel Generation Month

Annual community event generating novels algorithmically. Founded by Darius Kazemi. Hundreds of novel-length outputs from Markov chains, LSTMs, and constraint systems.

github.com/NaNoGenMo →

PNG / JPEG Generative Art as Still Images

Generative art minted and experienced as static images on platforms like Art Blocks and fxhash. Liminal renders PNG/JPEG screenshots via Puppeteer and Playwright.

🎨

PNG / Art Blocks

Tyler Hobbs — "Fidenza"

Flow field compositions with painterly quality achieved entirely through algorithms. Over $50M in sales. A landmark in generative art history — each output is a unique still image.

tylerhobbs.com →

🦢

PNG / Art Blocks

Dmitri Cherniak — "Ringers"

"Ringers #109" ("The Goose") sold for over $5M. Masterful constrained randomness — unique geometric compositions from limited parameters, each a static image of stunning variety.

dmitricherniak.com →

🏔️

PNG / fxhash

fxhash Platform — Generative Art Gallery

The largest Tezos-based generative art platform. Thousands of projects viewable as galleries of still images, each generated on-chain. William Mapan, Zancan, and more.

fxhash.xyz →

GIF Generative Looping Animations

Generative art shared as looping animated GIFs. Liminal exports GIF via FFmpeg from canvas frame sequences.

🔁

GIF

Saskia Freeke — Daily Generative GIFs

Years-long daily generative art practice. Geometric transformations, rotation, and color theory in tight looping format. A model of creative consistency.

saskiafreeke.com →

📚

GIF

Are.na — Generative GIF Collection

Curated collection of generative and experimental GIF art from dozens of artists. Public, browseable reference. Free platform, no login required.

are.na →

MP4 / WebM Creative Coding Video

Generative art rendered to video — from real-time visualizations to fully computed films. Liminal produces MP4 via Revideo, HyperFrames, or CanvasRecorder+FFmpeg, and WebM via FFmpeg.

pendulum

MP4 / Video

Memo Akten — "Simple Harmonic Motion"

Pioneer of real-time generative visuals and ML art. Pendulum wave physics as mesmerizing visual compositions. Exhibited globally at museums and festivals.

memo.tv →

🌌

MP4 / Video

Refik Anadol — "Unsupervised" at MoMA

Large-scale generative installations projected onto buildings. Machine hallucination series processing vast datasets into flowing, dreamlike video landscapes.

refikanadol.com →

🌿

MP4 / Video

Inconvergent (Anders Hoff) — Algorithmic Simulations

Algorithmic drawings and simulations recorded as video. Mathematical rigor behind organic growth algorithms, recursion, and natural systems.

inconvergent.net →