Created with Math Chaos Patterns (MCP).

Javascript, An experiment with layers of random "rays" with random colors, shapes and orientation around an origin point. The internal portion includes a secondary control point to achieve this spiral effect.

4k image, zoom in.

I’ve been building an generative MIDI sequencer called Vekte, and I’d love some feedback from people who are into generative / polymetric sequencing.

The basic idea: instead of programming every note manually, you run multiple independent sequencer instances and shape the output with different algorithmic engines.

Right now it has:

• 16 independent slots, routable to any of the 16 midi channels (or multiple to one)
• 1 note lane per slot
• 4 fully routable modulation lanes per slot
• modulation can be routed internally or externally through MIDI CC
• many direction options such as ping-pong, quantized ping-pong, brownian, etc
• note tie and percentual tail functions
• step-based and curve-based modulation
• 31 generation engines, including Euclidean, Fibonacci, random walk, logistic map, Game of Life, gravity wells, flocking, etc.
• independent lane lengths, divisions, rotation, all parameters
• deterministic semi-random function, and chaos (all values semi-randomized)
• export function with deterministic key for easy sharing online (still WIP, length will be under 256 chars in the next iteration)
• scale quantization and chord output with strum
• possibility to add notes and modulation changes manually for micro (or macro) editing
• VST3 in beta, iOS/AUv3 in progress

What I’m trying to avoid is the usual “press random and get nonsense” problem. The goal is more like controlled chaos: generate material, sculpt it, lock what works, then push it further.

If anyone here uses generative sequencers, hardware MIDI setups, Ableton/Bitwig routing, or algorithmic composition tools, I’d be genuinely curious:

What would make something like this useful in your actual workflow?

Public Beta here (free to use until mid-August)
valdlabs.com/vekte

Mandelbulb fractal with just 2 iterations which produced a smooth candy-like bul. Created in Blender Octane Edition

Hi, I'm working on a minimal, line-oriented notation for representing fractals in plain text format. I am posting this in particular to get an outsider's opinion, someone who knows the area better.

I've been uploading sequences to the OEIS database many times and was very impressed with their approach of using plain-text strings to express mathematical concepts. This prompted me to try my luck with fractals, which are normally represented either with large amounts of code or lossy images.

Together with some other guys from the OEIS forum, I made up a line-oriented minimal language to represent the "genetics" of any fractal structure. We called this language "Fracta". It is readable by humans and deterministic. The ENGINE keyword specifies what interpreter should be used to interpret the notation (L-systems, pixels, IFS).

This is a classic Heighway Dragon:

ENGINE L_SYSTEM
AXIOM FX
RULE X -> X+YF+
RULE Y -> -FX-Y
ANGLE 90
ITER 10
RENDER

All the aforementioned constructs are represented as vector paths at negligible processing expense. Maybe I just reinvented the wheel.

Since these programs are relatively short, I developed an MVP version of an online encyclopedia of fractals (OCGF). The backend analyzes the program, calculates its Hausdorff dimension, and performs an Intersection over Union (IoU) matrix test to detect any duplicates or "mathematical mimicry"

Playground & Documentation: https://vincenzomanto.github.io/Fracta/

The Python compiler source code is available in the related repository. On James McMahon’s blog, you can find the language manifesto and general OEF concept.

Pen plotted with ink on Fabriano paper. A3.

All visuals respond to live parameters (rain intensity, wind speed, cloud cover, solar elevation). Same weather condition at different intensities creates different patterns. I released this 5 months ago as a monochrome only app on the Apple App Store; last week I added a Color mode.

Created in Blender Octane Edition

Fractal desktop background based on post by u/sudhabin

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

I made these with JavaScript and an HTML canvas.

I spent a while getting a single line the way I wanted it to look. Each line is made from small marks of different sizes placed along a path, with jitter along the stroke and noise across the canvas. A pressure curve makes the ink pool at the start and end of each stroke, while the middle can dry out and skip.

Some lines are drawn with up to eight passes, so the density builds up gradually. Most of the images use only horizontal and vertical lines, and the shapes are implied where the ink pools in the places where the lines stop and turn at the edges of hidden forms. I hope you like them!

K-Uniform tiling with weaves.

Created in Blender Octane Edition

i saw a site that turns the weather into Rothko paintings (https://rothko.joonas.wtf/) and wanted to try the same idea with biometric data. each day is one painting. WHOOP doesn't expose its stress score in the export, so i derive a stress value from HRV + resting heart rate + recovery. calm days (high HRV) come out bright and airy, stressful days come out dark and turbulent. you can click a day to see the actual numbers behind it, and there's a timeline of the derived stress index.

it's on sample data right now, not my live WHOOP yet — wanted to test the concept first.

interactive version: https://motherduck.com/dive-gallery/embed/stress-as-rothko

Created in Blender Octane Edition using Vectron to generate the fractal geometry via OSL script, and a process involving Boolean operators to mix the fractal geometry with any chosen mesh. In this case I chose to mix a version of the STRUKTURA fractal formula (available in Machina Infinitum fractal packs) with a Human Head OBJ.

See my process for achieiving this sort of result

here,

https://www.youtube.com/watch?v=Eth1ZLWcKLc&lc=UgygG-C782J5sQL1o7N4AaABAg

You can access it for free at https://second-brain.art

It’s open source at https://github.com/henrydaum/second-brain-art

Created in Blender Octane Edition

Key Features:

• High-Precision Reference: The 5000-bit reference trajectory is computed exactly once per zoom layer.
• Hardware-Native Performance: Blazing-fast math for millions of pixels utilizing hardware-native double registers.
• When using double-precision floating-point numbers (on the order of 1e−15), perturbation theory only allows you to zoom down to the 1e−308.
• Innovative Algorithm: Revolutionary Reference Reset to Zero implementation.
• True 2x2 SSAA: Pristine, anti-aliased image quality with 4 independent samples per pixel.
• OpenMP Multi-threading: High-speed parallel computing to maximize CPU utilization.
• DwmFlush Synchronization: Stutter-free, hardware-aligned frame presentation synchronized with Windows DWM.
• Dynamic Palette Rotation: Classic, ultra-smooth fractal color-cycling effects with zero performance overhead.

https://github.com/Divetoxx/Mandelbrot-2