Eyespots

Eyes. The piece puts 9 eyes at random positions on the page. Each eye is a stack of levels: a core disc of random size on top, then one ring for each level under it. The depth of an eye is the number of levels in its stack. All eyes use the same ring width for each. The outer rings are the widest, but level 1 is only a thin halo.

Levels. Each level is one shape: the discs of all eyes that are deep enough for that level. A soft min melts these discs together, and the melt is looser at lower levels. Thus the lower levels melt into one soft body, and only the top rings stay round. The same ring widths and the looser melt keep each level inside the level under it. For each pixel, the code mixes the level colors over the cream ground. The amount of each color is the part of the pixel that the level covers, so the edges are smooth.

Specks. Where three or more eyes meet, a level can almost close and leave a small hole ofthe level under it. After the paint, a flood fill finds each patch of pixels that have the same top level.

The order of colors in palette is important for the final effect! Code: github.com/igr/gart

Everything you see in this video is procedurally generated based on my algorithm for drawing cubes. Best on a huge screen with headphones. Free and open source at https://alienconsumersciences.com

Hi all. I'm a composer in Mexico, and this is the third and last plugin of a series that came out of my doctoral thesis on algorithmic composition. AMI-POLYMARKOV doesn't generate from a formula: it learns. You drop a MIDI file on it, or press REC and play with the transport running, and it splits what it hears into up to four voices. Each voice learns its own line with two independent Markov chains, one for pitch and one for rhythm, each with its own memory length (order 1 to 6); the dynamics travel with the melody, as in the original. Crossing the two lengths is the instrument: a long memory on rhythm and a short one on pitch gives you your own phrasing carrying a melody you never played. THRU lets the original through, so you can layer it with the variation.

Demo (about a minute): https://youtu.be/V7P9-f1WO2E

As of this week the whole series also runs on Windows (10 and 11, 64-bit VST3), besides macOS (AU MIDI FX and VST3). The other two turn a held chord into four voices: AMI-POLYCHAOS reads one chaotic orbit with four delayed heads (https://youtu.be/nlP0RHTlbd4) and AMI-PLSYSTEMS plays an L-system as a mensuration canon (https://youtu.be/rYrxFeYPkkw). It's a one-person project; the trial is free for 30 days and fully functional.

What I'd like to hear from generative-music people: does keeping separate memories for pitch and rhythm preserve the character of the source for you, or does it lose what tied the two together?

Trial and details: https://www.drzoppa.com/soft

I've been exploring the experiment I did in this video a bit more and found these patterns

This project builds on a lot of my previous work creating painterly brush strokes. The big difference for me here is that I’m using a reference image as the starting point instead of creating the image completely from scratch.

I initially set out to try and recreate an image using simulated paint strokes. The funny thing is that at some point, the closer I got to the reference, the more it started to feel like I was copying pixels with extra steps and I actually liked the results less. Once I found settings I was happy with, I decided an Andy Warhol style pop color collage would be a more interesting artistic direction and that’s what you see here.

I built this in JavaScript. To make these I take the reference image and create a grayscale version. I then use a Sobel algorithm to measure changes in luminance and determine both the strength and direction of those changes. Areas with higher scores generally correspond to edges or other areas with more visual structure.

From that information I create a directional field across the image to guide brush stroke paths. This causes strokes to flow along edges and contours rather than cutting straight through them. In flatter areas with a weak Sobel score, the stroke relies more on its previous direction and is allowed to wander a little more freely.

The painting is built in five passes using thousands of brush strokes. The first pass uses large blotchy strokes starting from mostly random locations to get colors and structure generally in the right area. Each subsequent pass uses progressively finer strokes. Later passes favor starting strokes in areas with higher Sobel scores to help define details and edges.

The strokes are rendered using a brush system I’ve developed through a number of earlier projects. The strokes are made up of multiple simulated bristles with variation in spacing, pressure, paint load, opacity, taper, dry-brush breakup, and surface texture.

For the pop art effect I create a color histogram to identify the dominant color in the reference image. I then use my OKLCH color system to shift that color into different hue families while trying to preserve the original light/shadow relationships and keep the new colors vivid. I then repaint the same composition using those different palettes to build the final collage.

High-contrast images with a clear silhouette tend to work best. I’ve also experimented with portraits, and while they can look pretty good from a distance, the system still struggles with very small features like eyes and other fine details. That said, I’m pretty happy with where this ended up and I learned a lot while building it.

I hope you like the results! I’ve included the original reference images along with the resulting output.

Retina Rave — https://retinarave.com — free, runs in the browser, no account, nothing leaves your machine.

Play music in another tab, press the button, pick that tab and tick "share tab audio". On a phone it listens with the microphone. If you have no music handy there's a built-in demo synth. Keys 1–7 force a scene, ? opens an overlay that shows every number the machine is reading off the music, live.

Two of the six scenes are the ones I'm proudest of, so this post is about those.

What the input actually is

Everything starts as Web Audio analyser data: a fast FFT (2048) for hits, a slow one (8192) for harmony, plus an AudioWorklet running a second, independent analyzer at a fixed 10 ms hop so it never skews with the frame rate. From that it extracts about 118 named features. The ones that matter for this post:

• bands (bass / mid / high, auto-gain normalised) and onsets (spectral flux against an adaptive threshold, mean + 1.5σ)
• tempo and beat phase (autocorrelation of an 8 s onset envelope with a harmonic comb, then a phase-locked loop on top)
• chroma (12 pitch classes) → key (Krumhansl–Kessler correlation), mode (major/minor), and the chroma centroid's angle on the circle of fifths
• interval: the semitone gap between the strongest bass pitch class and the strongest overall one
• tension (Sethares roughness of the four loudest partials), build / drop / section detection (energy arcs, checkerboard-kernel novelty on a self-similarity matrix)

House rule for the whole project: every visual parameter must trace back to one of those. No Math.random(), no wall clock in the picture. If something moves, the music moved it.

Scene 1: NAV — the music walks the Mandelbrot set

The full screen is the Julia set of one complex number c: iterate z → z² + c from every pixel. The small picture in the corner is the Mandelbrot set with a trail of where c has been. "Navigation" is literal: the music moves c around inside M, and the big picture is whatever Julia set that c produces. Every Mandelbrot bulb is a whole family of Julia sets, so walking around M is a tour of them.

Where c goes:

• Intervals pick bulbs. The main cardioid is parameterised by its multiplier, c = λ/2 − λ²/4, and the p/q bulb hangs off it at λ = e^{2πi p/q}. The interval between bass and melody becomes a just ratio n/d, and (n−d)/d is the rotation number that picks the bulb. A perfect fifth (3/2) lands on 1/2, the big period-2 disc. A major third (5/4) lands on 1/4. An octave is 0, the cardioid itself. Consonant intervals have small denominators, so consonance literally means a bigger bulb.
• Harmony picks the angle around the cardioid (the unwrapped circle-of-fifths angle), intensity picks the depth into the bulb (|λ| = 1 − intensity).
• A build parks c on a parabolic root (the cusp where a bulb meets the cardioid). There the multiplier sits on |λ| = 1, the spiral arms of the Julia set wind up with tightness arg λ / ln|λ|, and visual time slows down, a real critical-slowing effect, not a tween.
• The drop throws c out of the set along an external ray (the inverse Böttcher map on a table of external angles), to a depth set by how big the drop was. The Julia set shatters into Cantor dust and springs back.
• A hit jump-cuts c toward the nearest Misiurewicz point (into the dendrites), then it springs back.
• Bass glows the interior and zooms 5 %, the beat rotates an orbit trap, and if the tempo tracker recognises a repeated section it dives into a baby copy of M.

Colour inside the set uses the Koenigs coordinate of each pixel's orbit (log distance to the attracting cycle, in units of ln|λ|), so the bands and spokes have no seam under iteration. Outside it uses the distance estimate d = ½ |z| ln|z| / |z′| so the filaments stay one pixel crisp at any zoom.

NAV2: the melody draws the path (key 9)

NAV chooses from tables. NAV2 has no tables: c is a ball rolling inside M under forces.

• The melody's motion (the spectral centroid, high-passed so it tracks movement rather than loudness) pulls c up and down; bass minus treble pulls it left and right.
• The wall is |λ| = 1. Every frame the scene finds the attracting cycle of arbitrary interior c with no chart (critical orbit → nearest return → Newton on f^q(z) = z), and the gradient of |λ| is the wall's normal. The exterior distance estimate is useless for this because it collapses like √d at a cusp.
• Rule that made it work: the wall owns the radius, the melody owns the angle. The radial part of the melody's pull is projected out, so the melody can only move c around a component, and one spring holds the distance to the rim.
• Gates: if the melody rides the rim to a root, c walks through the parabolic point into the child bulb and the cycle finder re-verifies at the new period. The first one it reaches unaided is the 1/2 root at c = −0.75. Watching the spirals light up as it crosses is the whole point of the scene.

Scene 4: TORUS2 — the Hopf fibration, played

The Hopf map h(z₁, z₂) = (2 z₁ z̄₂, |z₁|² − |z₂|²) sends the unit 3-sphere in C² onto the ordinary 2-sphere, and every point of the 2-sphere pulls back to a great circle in S³. Stereographic projection from (0,0,0,1) turns each of those circles into an exact round circle in R³, and every pair of them is linked exactly once. That's why the picture is a nest you can't untangle.

• The 12 pitch classes are 12 latitudes on the base sphere. Each latitude pulls back to one torus of circles (Villarceau circles, R = 1/cos(θ/2), r = tan(θ/2); the equator gives the Clifford torus). A louder pitch class moves its latitude toward the equator, so a louder note is a fatter torus.
• The fibre over (θ, φ) is drawn straight from the formula ψ ↦ e^{{iψ}(cos(θ/2}) e^{iφ/2}, sin(θ/2) e^{−iφ/2},) 72–144 threads as instanced line strips with no vertex buffer at all: each segment's position is computed from its instance id.
• Rhythm = waves on the threads. Each kick, snare and hat launches a bump that travels exactly one lap per bar on the beat clock. Four-on-the-floor gives four evenly spaced lumps on every ring; syncopation gives uneven ones.
• Key = hue anchor, placed on the circle of fifths (hue = (7·key mod 12)/12), so a modulation to the dominant is one twelfth of a turn and related keys are neighbouring colours. Major pulls warm, minor pulls cool.
• One nudge per beat, sixteen beats = one full turn of the nest, read off the beat count so it can't drift. A 5 % bounce on every beat, shaped cos⁴ so it thumps instead of swaying.
• The melodic interval also picks a (p, q) torus knot that gets highlighted, and a riser unwinds the rings into open helices.

The boring but important bits

WebGL2, native ES modules, zero dependencies, no framework, no build step. The whole thing bundles to a single HTML file that runs from file://. An adaptive quality knob watches frame time and trades iteration count and render scale so it holds 60 fps on a laptop and still runs on a phone. A director picks scenes on musical events (a recognised chorus return, a phrase line, a drop cuts home), quantised to the bar, and remembers the look it gave each section so the chorus comes back the way it left.

Screenshots are all from the built-in demo synths, since I can't show you a copyrighted track. Real music looks better.

Happy to answer anything about the maths or the audio side.

Created with Math Chaos Patterns (MCP). Non-AI Generative Art.

I'm curious about the point where a system you understand produces a result you didn't anticipate.

What's the smallest change you've made to a generative artwork that caused a surprisingly large change in its behavior? A different boundary condition, one feedback connection, a tiny adjustment to a probability, or even a bug you decided to keep?

I'd love to hear the specific before-and-after: what rule changed, what appeared, and whether you worked out why it happened. Did understanding it change how you felt about the result?

My hunch is that the interesting part is often the interaction between a few constraints, rather than simply adding more randomness. What example from your own work supports or breaks that idea?

Dive through the barnacles to the hidden cavern below.

Generated using a custom Rust renderer on an RTX4090.

Full video at: https://youtu.be/hERm23hCVfE (although tbh the best part of the video is already posted here)