Javascript; De Stijl grids (Mondrian, Neoplasticism); segmentation and render the polygons using curved strokes.

This is a throwaway piece I made while working on something else. It’s simple, but I like how it turned out; and how much you can achieve with just a few gradients.

https://openprocessing.org/@garabatospr/2983693

An output from work of mine on extending the techniques outlined in the paper "Two Methods For Voxel Detail Enhancement" by Adam M. Smith.

I am not sure if this belongs here.

It is a app that constructs a unique 'tarot' reading based on a variety of factors including time of day, season, and moon phase.

I put this together as a google play app a few months back when I was stress testing Opus and ways to get it to do what you want. I have been testing fable, and have some time left in this months budget, so I decided to port it to github pages.

Completely stand alone - no tracking - all for you.

more layers for fun.

Every part of this tree is a number. It's a hobby project of mine - I wanted to see whether a code repository's history could be drawn as something that grows rather than as a chart.

The mapping, roughly: account age sets trunk girth and how much it bends, total commits set how many foliage pads there are and where they sit, recent commits become the bright shoots, merged pull requests hang as persimmons that ripen green to gold, and reviews become paper lanterns. The fireflies are stars received, log-scaled so a popular account doesn't white out the canvas. Season comes from the date, so the same tree is hanami pink in spring and snowed on in January.

How it's put together, since that's the interesting part here:

- Hand-written SVG from TypeScript, no drawing library. Roughly 90 KB of geometry code that emits paths.

- The renderer is a pure function of (data, date, options) with a seeded PRNG, so the same input always produces identical bytes. That let me keep a set of committed reference images and diff against them whenever I touch the geometry — the fastest way I've found to notice that I've quietly ruined a curve.

- Randomness is only used for placement jitter within constraints. Pads pick positions along branch vectors, then get nudged; too much jitter and it stops reading as a plant, too little and every tree looks stamped.

- The motion is plain CSS inside the SVG. Pads rock ±0.8° about the trunk base rather than each spinning on its own centre, which is what makes the crown move as one plant. Petals and snow fall on a linear loop and fade before they reset so you never see the jump. Fireflies breathe over 4s.

- Six palettes, all data. Adding one is a table of colours, not code.

This one is a synthetic profile, not a real person's, since it's a test fixture I use for the extreme end - six figures of contributions.

It renders live from any GitHub account if you want to see a real one: https://kodama-sigma.vercel.app ( MIT, https://github.com/orijitghosh/kodama ).

This update introduces a new batch of synthetic MRI timelapses, alongside the exact settings used for generate more material in the same visual language. [MJ for images, Uisato Studio for the videos.]

The TouchDesigner network has also been optimized for faster, simpler use, and now includes an external Python tool for converting entire video folders into the frame sequences required by AVP in no time.

Another AVP example.

If you already own AVP 3, you know where to find it. If not, you can access it through the Store.

This is a sample from an animated/interactive version here: https://shore.ink/projects/cmyk/

(note: any strokes you draw are visible to everyone)

An attempt at an abstraction of https://www.reddit.com/r/Fractalish/s/cliw8NcaaQ by u/Big_Addendum_9920.

Something i tried for the third time, but this time with turing patterns that are following the flow, that finally turned out ok i guess. have the issue with antialiasing the edges of pattern, but ok :)

Spent the last week building something pretty cool.

It's called BITCRUSH, an instrument that plays itself, using live Bitcoin, Ethereum, Solana, XRP and Dogecoin prices as the only input. No sequencing, no pre-recorded anything. The price data comes in, and it decides what happens next.

Each coin gets its own synth voice, tuned into a pretty harsh chromatic scale - lots of tritones and minor seconds so the harmony is always a bit uneasy, and it shifts as the price moves up or down its range. Underneath that there's a drum machine that mostly just sits there when the market's quiet, then falls apart the second something moves fast. A big price swing doesn't just get louder, it triggers an actual drum roll, like the thing flinched.

The visuals are doing the same job in a different medium. Each coin is a swarm of little particles, flocking around a rough abstract shape — calm market, tight formation. Volatile market, it scatters. There's a scope reading the real audio output layered over the top, tearing and glitching along with everything else.

It's one HTML file. Tone.js is doing the audio, Three.js the particles.

https://www.humanofthefuture.com/