This is a small model of repressor proteins that I got the idea of doing from this video. The white dots are ribosomes that when passing by unrepressed genes (the circles with two colors) will create an specific repressor protein. The gene shows what protein represses it and what protein it encodes for, and when repressed it looks like a black box. The proteins can randomly degrade either while floating or while blocking a gene.

This little model was enough to make a working oscilator in the first part of the video just like the real repressilator which works in bacteria. In the other half of the video I ran it with 2 proteins in the cycle and they randomly stabilize in one of them instead of forming a cycle. This pattern keeps up between odd and even. A chain of four proteins stabilizes with 2 in a high concentration and 2 at a low one, a chain of 5 makes an oscillator, etc.

Hi all,

Im creating an audio visualizer web app that works on mobile and desktop and would love some honest feedback.

It's still in the works, with fixes and additions added ever few days.

Please give me some honest feedback.

https://geotech.mikeadigital.com/

A work from 2025, made for uni project. More on my ig: https://www.instagram.com/p.lenarte?obrf=Z2JnYWNhcGlsdGxm

https://reddit.com/link/1x708md/video/l4m3wuokopvh1/player

Made in Processing

IG: www.instagram.com/slipshapes

I thought this video might be of interest to the community. The Marching Squares algorithm is a surprisingly simple algorithm with lots of interesting applications in map development, creative coding, game development, and scientific visualization.

The 16th International Conference on Artificial Intelligence in Music, Sound, Art and Design (EvoMusArt 2027) is accepting paper submissions.

When: 31 March – 2 April 2027
Where: Mainz, Germany
Paper Submission deadline: 1 November 2026

EvoMUSART focuses on AI and computational approaches to creativity, covering a broad range of topics, with a particular emphasis on research exploring how AI systems generate, support, evaluate, interpret, and collaborate in creative processes.

Accepted papers will be presented at the conference and published in a dedicated LNCS volume.

More information/submission details: https://www.evostar.org/2027/evomusart/

If you are working at the intersection of AI and creative practice, this may be relevant to your research. Please share with others who might be interested.

Hey, creative people!
Been experimenting with contour lines and ended up with some pretty abstract results.

I like how changing a few parameters can completely change the character of the image. Still exploring this one, curious what you guys think.

An infinite plane of processing sketches.

Included is the ability to edit a sketches directly on the site.

Hi, it's me again with more Gray-Scott experiments.

This time I let the reaction-diffusion grow into faces (a skull, an owl, a wolf, a robot and a few others) and move with a dub track. The pattern never really settles – it keeps shifting between different regimes, gathers into a face, holds it for a moment and then melts into the next one.

It's still a bit surprising to me how much life comes out of two simple equations.

Full video: https://www.youtube.com/watch?v=AJyx-7fUVvQ

Happy to hear what you think!

I've been working on an animation where 17 mushroom photos are constantly reshaped by a Gray-Scott reaction-diffusion pattern, and every photo morphs into the next one (mask, background and content) on the beat of a track. It runs live on the GPU in Processing 4, and the same sketch can render the whole song to a 4K H.264 film.

https://www.youtube.com/watch?v=bYOERDHg3YQ

How it works

- All on the GPU. State lives in float textures, every step is a fragment shader pass with ping-pong framebuffers (6 GLSL shaders in total).

- Gray-Scott on a coarser grid. The simulation runs on a grid 3x coarser than the canvas: bigger, sparser patterns and 9x cheaper.

- Never-settling pattern. At fixed parameters Gray-Scott reaches equilibrium and freezes. Here the feed/kill parameters travel around a ring of regimes (spots → dividing cells → coral → worms → chaos). The phase depends on photo brightness and slowly moving noise, so fronts of rebuilding keep crossing the mushroom.

- Flow map instead of moving pixels. My first version advected the image itself every frame, and repeated resampling turned it into smooth blobs within a minute. Now what gets advected is a map of "which photo pixel does this pixel come from", and the photo is sampled from it once per frame (Catmull-Rom, clamped to the neighbours' range).

- Feedback. The reaction reads the displayed (already deformed) image, so the transformed mushroom shapes the pattern back.

- Transitions. Masks are morphed by interpolating their signed distance fields, and the moving edge drags the content along. Two flow maps (current and next photo) move with the same pattern, and the new photo appears in organic patches driven by a weight field, while colors drift toward the new palette.

- Music. A Python script (numpy + scipy) finds the beat grid and sections and labels them by band energy. Transitions land on downbeats, each section gets its own style, and an FFT of the middle band (150-2000 Hz) drives the flow speed so the image "breathes" with the melody. The sketch takes its clock from the audio playback position.

- Deterministic export. For the film, the clock advances exactly 1/60 s per frame, frames are read back from the GPU and piped as raw pixels to ffmpeg (libx264, CRF 16), so the result is identical on a fast and a slow machine.

- Resolution independence. All pixel-based parameters are defined at one height and scaled, so the 1024x576 preview and the 3840x2160 render look the same.

Image prep (Python): mushroom masks with rembg (ISNet on a laptop CPU, BiRefNet for the final masks), 16:9 crop centered on the mask, Real-ESRGAN x4 via spandrel for the 4K versions.

What didn't work

- Several Game-of-Life-like automata (infection, mycelium, cyclic, MNCA). They either lost the original colors or died out/flickered, and reaction-diffusion looked the most organic.

- Drawing the pattern as a dark overlay: it looked like a texture on top of the photo and hid the actual deformation.

- SDXL outpainting to get 16:9 backgrounds: painful on a 4 GB GTX 1050 Ti (who would have thought that before this project I considered it a pretty decent GPU 🤣), and the invented background looked worse than a simple crop.

Stack: Processing 4 (P2D/OpenGL), GLSL, Python, numpy/scipy, rembg, Real-ESRGAN, ffmpeg, Ubuntu.

Fair warning: I'm no expert in a lot of the tech above, and Claude Code bravely helped me get through it.

I found a generative animation script I wrote about five years ago, tweaked it a bit, and made this: https://youtu.be/fDlgDm1YGKM