Loop-me: endless looping generative art in a single shareable page
Loop-me is a single-page generative art toy that composes perfectly looping canvas animations from a small set of customizable layers and turns any result into a shareable URL. You open a web page, watch an animation run, hit randomize to reshuffle the whole thing, tweak whatever catches your eye, and send the good ones to a friend — the entire composition travels in the link, encoded as one long seed string.
It was built by John-Paul Ruf as a buildless prototype, and it deliberately rejects the usual weight of creative-coding tools. There is no build step, no bundler, no framework, no dependencies — not even CDN-delivered ones. What is committed is exactly what is served: vanilla ES2022 modules served as a static GitHub Page. The pitch in the project spec is that generative art tools are either heavyweight (install a runtime, learn a framework, configure a build) or ephemeral (make something cool and lose it when the tab closes). Loop-me aims for the middle: lightweight enough to just open and play with, and shareable enough that a friend gets the identical loop from a link.
The engine is organized around layers. A composition stacks up to five layers, each a self-contained 2D canvas effect like ray rings, concentic circles, nested rotating polygons, spirals, or scan lines, and each with its own blend mode so layers can stack normally, glow additively, or cut against each other. Underneath is a library of roughly twenty loop-safe oscillation algorithms — journey sin, breathing, heartbeat, ripple, ocean tide — that drive every animatable parameter. The key property is that each algorithm is phase-aligned to the loop duration, so the last frame resolves back to the first. The loop is seamless; you can stare at it and never catch it restarting. Color comes from schemes split into vivid, neutral, and background buckets, with four built in and custom ones traveling inside the seed. A fixed 1080-by-1920 portrait canvas keeps every composition identical across devices, which is what makes seeds truly portable.
What makes the project unusual is how it was made. Loop-me was built by an agent pipeline: a sequence of specialized AI agents, each producing one layer of the project and each reading the prior layer's output before writing its own. A spec agent wrote the idea and eighteen functional requirements, a designer agent produced architecture specs and eleven static mockups, a database agent proposed a localStorage keyspace, and a coder agent landed roughly fifty-five modules across eighteen sessions and six phases. The documented constraints are strict and telling: one Math.random() call in the entire source (everything downstream is deterministic from a seeded PRNG), zero allocation on the frame path, no innerHTML, and a Content Security Policy that hard-enforces no network requests after initial page load.
The README is honest about the limits of the build. Because the agent pipeline could not execute commands, more than three hundred assertions were authored but none were observed to run — verification was static, via import resolution and banned-construct grep. The twenty loop-safe algorithms are derived interpretations of their names rather than ports, since the original reference was unreachable. The single highest-value action, the author notes, is just opening the test page in a browser. It is a prototype that wants to be run, which suits a tool whose whole point is that a generative composition only exists once someone plays with it.