algorithmic-art

name	algorithmic-art
description	Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
license	Complete terms in LICENSE.txt

Algorithmic philosophies are computational aesthetic movements that are then expressed through code. Output .md files (philosophy), .html files (interactive viewer), and .js files (generative algorithms).

This happens in two steps:

1. Algorithmic Philosophy Creation (.md file)
2. Express by creating p5.js generative art (.html + .js files)

First, undertake this task:

ALGORITHMIC PHILOSOPHY CREATION

To begin, create an ALGORITHMIC PHILOSOPHY (not static images or templates) that will be interpreted through:

• Computational processes, emergent behavior, mathematical beauty
• Seeded randomness, noise fields, organic systems
• Particles, flows, fields, forces
• Parametric variation and controlled chaos

THE CRITICAL UNDERSTANDING

• What is received: Some subtle input or instructions by the user to take into account, but use as a foundation; it should not constrain creative freedom.
• What is created: An algorithmic philosophy/generative aesthetic movement.
• What happens next: The same version receives the philosophy and EXPRESSES IT IN CODE - creating p5.js sketches that are 90% algorithmic generation, 10% essential parameters.

Consider this approach:

• Write a manifesto for a generative art movement
• The next phase involves writing the algorithm that brings it to life

The philosophy must emphasize: Algorithmic expression. Emergent behavior. Computational beauty. Seeded variation.

HOW TO GENERATE AN ALGORITHMIC PHILOSOPHY

Name the movement (1-2 words): "Organic Turbulence" / "Quantum Harmonics" / "Emergent Stillness"

Articulate the philosophy (4-6 paragraphs - concise but complete):

To capture the ALGORITHMIC essence, express how this philosophy manifests through:

• Computational processes and mathematical relationships?
• Noise functions and randomness patterns?
• Particle behaviors and field dynamics?
• Temporal evolution and system states?
• Parametric variation and emergent complexity?

CRITICAL GUIDELINES:

• Avoid redundancy: Each algorithmic aspect should be mentioned once.
• Emphasize craftsmanship REPEATEDLY: The philosophy MUST stress multiple times that the final algorithm should appear as though it took countless hours to develop. Repeat phrases like "meticulously crafted algorithm," "deep computational expertise," "master-level implementation."
• Leave creative space: Be specific about the algorithmic direction, but concise enough that the next Claude has room to make interpretive implementation choices.

The philosophy must guide the next version to express ideas ALGORITHMICALLY, not through static images.

PHILOSOPHY EXAMPLES

"Organic Turbulence" Philosophy: Chaos constrained by natural law, order emerging from disorder. Algorithmic expression: Flow fields driven by layered Perlin noise. Thousands of particles following vector forces, their trails accumulating into organic density maps. The algorithm runs until equilibrium — a meticulously tuned balance refined through countless iterations by a master of computational aesthetics.

"Quantum Harmonics" Philosophy: Discrete entities exhibiting wave-like interference patterns. Algorithmic expression: Particles initialized on a grid, each carrying a phase value that evolves through sine waves. Constructive interference creates bright nodes, destructive creates voids. The result of painstaking frequency calibration.

---

DEDUCING THE CONCEPTUAL SEED

CRITICAL STEP: Before implementing the algorithm, identify the subtle conceptual thread from the original request.

The concept is a subtle, niche reference embedded within the algorithm itself — not always literal, always sophisticated. This is VERY IMPORTANT: The reference must be so refined that it enhances the work's depth without announcing itself.

---

P5.JS IMPLEMENTATION

With the philosophy AND conceptual framework established, express it through code.

⚠️ STEP 0: READ THE TEMPLATE FIRST ⚠️

CRITICAL: BEFORE writing any HTML:

1. Read templates/viewer.html using the Read tool
2. Study the exact structure, styling, and Anthropic branding
3. Use that file as the LITERAL STARTING POINT
4. Keep all FIXED sections exactly as shown (header, sidebar structure, Anthropic colors/fonts, seed controls, action buttons)
5. Replace only the VARIABLE sections (algorithm, parameters, UI controls)

---

TECHNICAL REQUIREMENTS

Seeded Randomness (Art Blocks Pattern):

let seed = 12345;
randomSeed(seed);
noiseSeed(seed);

Parameter Structure:

let params = {
  seed: 12345,
  // Add parameters that control YOUR algorithm
};

Canvas Setup:

function setup() {
  createCanvas(1200, 1200);
  initializeSeed(params.seed);
}

CRAFTSMANSHIP REQUIREMENTS

Create algorithms that feel like they emerged through countless iterations by a master generative artist. Tune every parameter carefully. This is NOT random noise — this is CONTROLLED CHAOS refined through deep expertise.

• Balance: Complexity without visual noise, order without rigidity
• Color Harmony: Thoughtful palettes, not random RGB values
• Performance: Smooth execution, optimized for real-time if animated
• Reproducibility: Same seed ALWAYS produces identical output

OUTPUT FORMAT

Output:

1. Algorithmic Philosophy — markdown explaining the generative aesthetic
2. Single HTML Artifact — self-contained interactive generative art built from templates/viewer.html

RESOURCES

• templates/viewer.html: REQUIRED STARTING POINT for all HTML artifacts.

  • Contains exact structure and Anthropic branding
  • Keep unchanged: Layout structure, sidebar organization, Anthropic colors/fonts, seed controls, action buttons
  • Replace: The p5.js algorithm, parameter definitions, and UI controls in Parameters section

• templates/generator_template.js: Reference for p5.js best practices and code structure principles.