I’ve been experimenting with connecting dance to generative art, and this is a little project I’m pretty happy with.

The video is an ink-style simulation that reacts to the dancers’ movement in realtime. It’s written in C++ using the libcinder framework and runs live while the performance is happening. No post-processing, just raw output from the sim.

I’d love to know what you think of:
- the overall look of the ink
- how readable the movement is
- any ideas for pushing the effect further

If you enjoy this kind of generative / motion-driven art, I post more experiments and behind-the-scenes clips on Instagram: https://www.instagram.com/gaborpapp_/

A simulation of entropic collapse, aka the process of generative dynamic complexity synonymous with life, and characteristic in living systems. What's going on here is:

Each particle is equally attracted to and repelled from other particles.

Each particle has a phase and a position.

The phase modulates the particle's attraction/repulsion profile - how it is attracted vs repulsed to other particles.

This phase is influenced by the phases of other particles according to their distance.

This acts as a globally synchronizing force, lowering the entropy of the entire system, increasing its complexity as its entropy decreases.

This is how life works - it's not 'evolved', its inherent to the geometry of the entire system.

Life didn't 'evolve', it has always existed. Nothing 'created' it, because nothing needs to.

Life is an autocatalytic process - everything is always already alive, always has been alive, always will be alive.

EDIT:

Source code: https://codepen.io/sschepis/pen/PwPJdxy/e80081bf85c68aec905605ac71c51626

Same principles, modeling multiple instances of the above interacting together: https://psizero.com/entropic-life

Cables.gl got an animation timeline update, and I recreated this scene from NGE as an exercise. Everything is procedural, you can check out the workflow/nodesystem here.

Last week-end I built a watercolor simulator based on real physics and shared it here.

A lot of you asked to play with it so i improved it and it's now live: https://sudoaquarelle.com/

New since the prototype:

- More pigments (52), based on the best research out there to predict color mixes (Kubelka-Munk).
- More luminous / glassy feel
- Some fun experimental stuff like the salt and alcohol techniques to alter the texture, a backlight effect and a few more.
- I also added a Code mode where the simulator prints its real function calls next to the sheet while you paint

It's still largely based on the same physics model as my prototype: Curtis et al.'s "Computer-Generated Watercolor".

All in the browser.

Current status: building and implementing a kid-friendly version. Plenty of awesome things to learn with watercolor painting!

This weekend I've been working on a watercolor simulator based (as much as possible) on real physics.

It's built on Curtis et al.'s watercolor model (SIGGRAPH 1997) with a fluid layer, drifting pigment and wet paper fibers.

I decided to explore this because I love watercolor painting, and when I do some, my favourite moment is when the pigments get mixed inside the water and spread chaotically. The transparency, the lack of control, the depth of the colors in that moment is what I enjoy the most.

So I started to wonder how code could help fix that moment in time.

Early WIP so don't mind the look. I'll be sharing the repo to the V2 as soon as i get a chance to polish it.

A collection of 337 real-time interactive simulations, each written as one self-contained C file. No OpenGL, no SDL — everything is forced through a terminal character grid with ncurses.

Deliberately no build system. One file is one program:

gcc -std=c11 -O2 -Wall -Wextra path/to/file.c -o demo -lncurses -lm && ./demo

Range goes from Conway's Game of Life and cellular automata up to a Jos Stamstable-fluid solver, a Crank-Nicolson Schrödinger solver, an SDF raymarcher with soft shadows, and a Cornell-box Monte Carlo path tracer — all rendered as ASCII.

Every file carries its CONCEPTS / MENTAL MODEL notes and cites its sources; there's a consolidated bibliography in documentation/Reference.md.

Repo: https://github.com/prtamil/AsciiCreativeCoding

It's a personal learning project — the "rebuild every primitive yourself, no shared utilities" approach is intentional.

Yes, it's AI-assisted — call it AI slop if you want, but every file was compiled, run, visually verified, and rewritten by hand and refactored until it actually worked

https://www.instagram.com/tameemsankari/p/DJEWldht9Bi/?img_index=1

I've been using this winter downtime to work on some unfinished ideas. I had an idea years ago to work with pdf files in unconventional and glitchy ways. These results are from the first initial experiments and I'm not yet sure what I'm gonna do with them.

I'll probably/hopefully make something with them in 2026. Until then I've got some more bash scripting to do!

Built in three.js using 4,000+ particles that smoothly morph between 3D forms like a cube, sphere, torus, cone, cylinder, Klein bottle, and Möbius strip.

You can:

• Switch between shapes with a click

• Adjust particle count and size

• Pick any color

• Watch smooth morphing transitions

• Rotate freely with orbit controls

The UI is fully collapsible and the entire scene has ambient and directional lighting with real-time rendering. Everything stays fluid even at higher particle counts.

I would love to see what others could add to this script.
Remixable live demo in comments.

Try it out and view the source code here

When it’s disabled, the toggle will stubbornly flip itself back just to mess with you. ( ´థ౪థ)

Inspired by the Useless machine — this little piece of trash is peak maker romance. (´,,•ω•,,)

Why a cat paw? Because a cat paw is the cheekiest, most smackable little hand I could think of. ヾ(◍'౪`◍)ﾉﾞ

See web demo in comments for full resolution!
This sketch is a real-time particle simulation where hundreds of thousands of white points reveal the presence of an invisible black hole. Nothing is drawn except particles and stars. The black hole itself is implied only by how it pulls particles inward with curved, accelerating motion.

Particles begin orbiting from a distance, following curved paths shaped by a gravity equation that uses an inverse cube law. As they spiral inward, they accelerate and either disappear into the event horizon or join an accretion disk around it. A starfield sits in the background, and clicking and dragging lets you rotate around the simulation in 3D space.

There are no physics libraries. Everything is written in raw Three.js using buffers, shaders, and simple velocity updates. The black hole lensing distortion is a fake but convincing shader trick based on screen-space position.

This was built to simulate orbital collapse at scale with no color, no textures, and no glow. Just behavior.

Web demo in the comments.

This is a chess variant, where the rules are the same as standard chess, but the board is an irregular grid. This makes rook lines bend and bishop lines fork.

So just like a standard board, every tile is still a quad. And every tile still has only 1 neighbour for every side. But it can have more than 1 neighbour sharing a corner, which is what makes bishop lines fork. Or it can have none, which is what make lines bend.

The steps to build this:

• start with a plane made of triangles

• pair some random triangles with their neighbour and fuse them into a quad. You end up with gaps between those quads where triangles cannot be paired

• subdivide everything. Quads become 4 smaller quads. Triangles become 3 quads. This is the playable grid.

• Then it's just a matter of smoothing it (in this case the points on the edges remain static, only the inside points are smoothed) and ensuring neighbours don't share the same color.

Then the tricky part is to give intuitive controls for players to configure boards how they want.

• Web version: https://polyreplay.com/chesstwist/demo

• if you prefer Steam (windows/mac/linux): https://store.steampowered.com/app/2775560/Chess_Twist/

• the engine behind it: https://polygonjs.com/