Creative Code & Generative Systems

01Build a context-free-grammar text generator (Tracery-style): define rules in JSON and expand them into generated poems or quips, with at least 3 nested rule levels.

02Repair a brittle generator: take a grammar that produces grammatically broken or repetitive output and fix article/plural agreement and add weighted rule selection.

03Add an evaluation pass: write a simple filter/scorer that rejects low-quality outputs (too short, repeated tokens) so the bot only surfaces its best lines - treating quality as a system, not luck.

01Use p5.js textToPoints() to convert a word into points, then displace/animate those points with noise so the letterform dissolves and reforms.

02Build a procedural poster layout system: feed in a headline + body string and have code lay out type on a grid with generative color/scale variation, producing 5 unique posters from one input.

03Repair a kerning/overflow bug: take a generative type sketch where long strings overflow the canvas and fix wrapping + auto-fit sizing under constraint.

01Install TouchDesigner (free non-commercial) and build the canonical first network: a Noise TOP feeding a Transform and a Level, animated by an LFO CHOP, output full-screen.

02Build an audio-reactive patch: route an Audio Device In CHOP through an Audio Spectrum CHOP to drive a visual parameter, so the visuals move with the music.

03Debug and optimize a laggy network: profile a patch that drops frames, find the expensive operator, and cut cook cost (resolution, selective cooking) to hit 60fps.

01Wire and program a potentiometer (or photoresistor) to control an LED's brightness via PWM on an Arduino, reading the sensor over Serial.

02Bridge hardware to visuals: send sensor values from Arduino over Serial into a p5.js sketch (Web Serial) so a physical knob drives an on-screen generative parameter.

03Repair a noisy/flickering sensor reading: add debouncing/smoothing (moving average) and document the before/after stability.

01Work through MDN's WebGL tutorial to draw and animate a colored, rotating 2D shape in raw WebGL (no library), understanding the vertex+fragment shader handshake.

02Read the 'WebGPU in production' issue, then port one small WebGL effect to a WebGPU/WGSL equivalent (or run the MDN WebGPU compute sample), noting where the APIs differ.

03Repair a resize/aspect-ratio bug: take a WebGL canvas sketch that stretches on window resize and fix the viewport + projection so it stays correct across sizes.

01Build a custom interactive chart in D3.js from a real open dataset (CSV/JSON): bind data to SVG, add axes/scales, and a hover tooltip.

02Write a reusable, documented chart component/template (e.g. a configurable bar or line module) so a non-author can drop in new data and get a correct chart.

03Repair a misleading chart: take a viz with a truncated y-axis or bad aggregation, fix the distortion, and write up why the original misled.

01In a free Unity (or Godot) project, script a generative behavior: spawn objects via code that drift/respond to time, forming an evolving non-gameplay scene.

02Document a reusable interaction template: a small script + setup steps another artist could drop into a fresh project to get the same effect.

01Follow the Three.js manual to build your first scene: a lit, textured rotating mesh with OrbitControls so the user can navigate.

02Build an original interactive 3D artifact: instanced geometry (hundreds+ objects) arranged by an algorithm, with a custom material and mouse-driven camera.

03Make it teachable: write a short tutorial + starter file that takes someone from empty page to your scene's core technique in under 20 minutes.

01Build a shared-canvas web app: two browsers connect over WebSocket (free tier) and both see each other's strokes/parameters live.

02Connect a microcontroller to the network: have an ESP32/Arduino publish a sensor value to a free broker (MQTT) that a web visual subscribes to.

01Model a parametric form in Blender Geometry Nodes (free): a structure whose count/spacing/twist are driven by node parameters, so sliders reshape it.

02Recreate the same parametric idea in code (p5.js or Three.js) to prove the rule transfers across tools, and note where node-based vs code-based each wins.

01Build a WebXR AR scene (Three.js + WebXR) that hit-tests a real surface and places a generative 3D object the user can re-place by tapping.

02Write a production case study: ship the AR piece as a real shareable URL and document the constraints (lighting, tracking drift, device support) and the tradeoffs you made.

01Learn Hydra: from the live editor, build a layered audio-reactive patch (osc + modulate + feedback) that reacts to mic input, then record a 2-minute improvisation.

02Ship a performance case study: do a short live set (even solo to a recording), document your 'safe' starting patches, the transitions you rehearsed, and what you'd cut under pressure.

01Implement an L-system in code that grows a 3D plant/branch structure (Three.js or Blender scripting), with rules and iteration depth as parameters.

02Ship a production-grade procedural mesh as a case study: generate geometry, export it (glTF), and document poly-count/perf tradeoffs and where the algorithm broke.

01Work through The Book of Shaders chapters 1-6 and recreate the shaping-function and color exercises live in Shadertoy, then build one original gradient/pattern shader.

02Write a ShaderMaterial in Three.js (custom vertex+fragment) that animates a mesh's surface over time using a uniform, proving you can wire GLSL into a real scene.

03Ship a production case study: a reusable shader effect (e.g. a configurable noise/distortion) documented with its uniforms, perf cost, and a fallback, so others can drop it in.

01Implement Reynolds boids flocking from The Nature of Code (separation/alignment/cohesion) in p5.js with the three weights exposed as sliders.

02Build a second emergent system (Conway's Game of Life or a reaction-diffusion shader) and write up the rule-to-behavior relationship - why these rules give that pattern.

03Ship a production case study: take one simulation to a stable, performant interactive piece with tuned constraints (particle cap, timestep) and document the tradeoffs.

01Package a reusable creative-coding library: extract a generative technique you've built into a documented, installable module (npm or a forkable repo) with examples and an API.

01Build a sensor-reactive installation prototype end to end: a sensor (camera or microcontroller) drives a TouchDesigner or web visual, with a calibration step and a written run-of-show.

01Build a controlled creative ML pipeline in the browser with ml5.js: train a tiny model on YOUR own labeled data (e.g. pose-to-sound or sketch classifier) and document the dataset source, license, and an evaluation of where it fails.

01Build a 2-axis drawing machine (plotter) driven by stepper/servo motors from an Arduino, fed coordinates from a generative sketch so the machine draws your algorithm on paper.

01Build a WebXR VR scene (Three.js + WebXR) the user can look around and interact with via controller, holding a stable framerate, with a comfort consideration (no forced motion).

01Train or fine-tune a small open diffusion/GAN model on a dataset you have the rights to, then publish an open artifact: the code, a model card (data provenance, license, intended use, limitations), and an honest evaluation of outputs.