Inflector Gadget v0.10 released, with bugfixes to the perturbation implementation (thanks FractalLion) and support for variable wavyness everywhere:
source tarball and windows binaries available here:
https://mathr.co.uk/web/inflector-gadget.html#v010
web version available here:
example:
#InflectorGadget #MandelbrotSet #JuliaSet #Fractals #MathArt
DecemberAdventure 11th
some small experiment with buddhabrot style rendering of hopfbrot, nothing impressive due to curse of dimensionality
DecemberAdventure 12th
no code today
DecemberAdventure 13th
I fixed the perturbation code in inflector-gadget - now uses 1 reference per inflection point and 1 extra for image center. hopefully correct rendering in more circumstances now. thanks to FractalLion on fractalforums.org for the push and a test case (which previously failed, now works).
also added variable wave support to the inflected renderer, which changes appearance of old parameters (so another url update coming for the web version so as not to break existing links; will need to minor update the old versions to have options to fwd to the new).
new release coming very soon, testing appreciated especially within the next 24 hours:
git clone https : / / code.mathr.co.uk / inflector-gadget.git
and check the README.md for build instructions
Inflector Gadget 0.9 is released!
https://mathr.co.uk/web/inflector-gadget.html
The most visible change since 0.8 (among many) is a version for Web built with Emscripten. Also: wavy hybrid Julia sets.
Try it online:
Get source code and binaries for Windows and Web here:
https://mathr.co.uk/web/inflector-gadget.html#Download
#InflectorGadget #MandelbrotSet #JuliaSet #fractals #MathArt
recent #InflectorGadget updates (at home WIP, not hosted anywhere yet):
✅ fixed 8MB/render terrible memory leak in perturbation code
✅ fixed crash when parsing TOML fails (unhandled syntax error exception)
✅ minimal full-window canvas instead of the default Emscripten code
✅ copy/paste to/from system clipboard works in web version via ugly hacks (intercept Ctrl-V before it gets to SDL2; probably fails on systems that use a different shortcut)
✅ refactored shaders to avoid so much copy/paste duplication
✅ use Emscripten's libpng port
✅ use GLAD instead of GLEW to load OpenGL functions
hmm, i think the wavy escape equipotentials are from the escape circle not being centered on the middle of the shape at each stage... forgot to make notes on my derivation, so need to reverse engineer my equations in the source code to figure out how i did it. the inflected julia sets use (z-cn)^2+cn with cn typically getting larger and larger in magnitude but polynomial uses just z^2+c'n with a few small c'n in a loop, so converting might not be trivial... #InflectorGadget #maths #ComplexDynamics
#InflectorGadget desktop v0.7 released
inflection mapping gadget for complex quadratic polynomials, for making #MathArt #fractals #patterns
download source tarball and Windows binaries:
https://mathr.co.uk/web/inflector-gadget.html#Download
latest updates in repository as ever:
```
git clone https : / / code.mathr.co.uk / inflector-gadget.git
```
(remove the spaces, added to prevent fediverse clients obscuring full link text)
highlights of new features:
ssbo: use buffers for large data to try to avoid "too many registers" shader compiler crash
quantize: snap inflection points to node centers, toggle with Q key
one-shot: add --output=myfile.png to the command line to render, save and exit
exray out: hover over Julia set and press X to trace ray, digits printed to terminal (probably doesn't work on Windows)
crosshair: show next inflection in undo/redo
a second working example means it seems it's true: but having to tune the escape to zero radius is annoying: this one used 0.03
#InflectorGadget #maths actually seems to work with a different colouring algorithm. not sure if real or coincidence...
```glsl
#version 300 es
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
out vec4 fragColor;
uniform vec2 resolution;
vec2 cSqr(vec2 z)
{
return vec2(z.x * z.x - z.y * z.y, 2.0 * z.x * z.y);
}
void main(void) {
vec2 z = (gl_FragCoord.xy - resolution.xy * 0.5) / resolution.x * 4.0;
vec2 c[2];
c[0] = vec2(-0.9237192701539101, 0);
c[1] = vec2(-0.8931031149745472, 0);
float m = length(z);
for (int i = 0; i < 1024; ++i)
{
float mz = length(z);
if (mz < m) m = mz;
if (mz > 25.0 || mz < 0.001)
{
break;
}
z = cSqr(z) + c[i & 1];
}
fragColor = vec4(vec3(m < 0.11), 1);
}
```
thinking about #InflectorGadget #maths - in the limit of a regular pattern of N quadratic inflections repeated forever, i think the inflection points converge to a limit cycle. what would happen if you skip all the buildup and jumped straight into the limit cycle repeated forever (or until pixel escapes)?
I'm guessing it might look like the Julia set for a particular degree 2^N polynomial whose coefficients depend on the limit cycle of inflection points.
if it looks the same as the original pattern of inflections, or close enough, that would be amazing: I do wonder how much precision would be required though?
new feature in #InflectorGadget widget for #fractals #MathArt : undo/redo shows the next inflection point with a cross-hair, so it's possible to follow how something was constructed.
e.g.
click the + button in the inflections 0/15 scrubber to scroll through construction of this parallel evolution of (evolution of trees) and (disks)
did some experiments tracing #ExternalRay in #InflectorGadget Julia morphing.
the #ExternalAngle (expressed as binary expansion) of the rays of the inflection nodes in the #JuliaSet have unchanging periodic part corresponding to the starting minibrot, while the length of the preperiodic part increases linearly with each morph (e.g. adding a constant number of bits each time), zoom depth is constant, but the stretching dynamics sometimes need precision to be increased.
compare with #MandelbrotSet morphs by deep zooming, where the length of the periodic part (and thus iteration count) increases exponentially with each morph (e.g. doubling each time), and zoom depth goes up typically by 150% (requiring 150% higher precision).
speed-fractaling #InflectorGadget realtime #fractals #MathArt process screencast
https://media.mathr.co.uk/mathr/2025-toot-media/mathr%20-%202025-04-08%20-%20inflector%20gadget%20-%201280x720p5.mp4 10MB video 3m33s
https://media.mathr.co.uk/mathr/2025-toot-media/mathr%20-%202025-04-08%20-%20inflector%20gadget.png 5MB image
https://media.mathr.co.uk/mathr/2025-toot-media/mathr%20-%202025-04-08%20-%20inflector%20gadget.txt 4kB parameter link
some precision loss is visible near tree center when zoomed in. video is downscaled at low framerate to reduce file size.
Just published: web version of #InflectorGadget inflection mapping gadget for #MandelbrotSet #JuliaSet #fractal #fractals #MathArt
Pro-tip: keep the Add tool selected and use mouse wheel to zoom if available, otherwise (e.g. touch screen) you need to keep switching between tools
Click the hash button in the top left to update the address bar URL before sharing (otherwise it might not be up to date), here's one I did today (3 things in a rabbit: right-handed tree, left-handed tree, line):
added `{ preserveDrawingBuffer: true }` to the webgl2 context creation, now Firefox right click Save Image works properly (previously it saved a 100% transparent image).
apparently this can cause performance issues especially on mobile, so I will see about adding a different way to save later.
also made it update the URL hash automatically when adding inflection points (previously only on manual button click). this avoids losing work when accidentally refreshing the page etc. can't make it update on every action (zoom, pan, colours, ...) otherwise browser complains about too much history spam.
here are five things in a 2/5 Julia set: disk, line, three tree variants (distinguished by how they attach to the whole). not very refined (only 3 steps of each, 16 inflection points total including the initial Julia set location).
#InflectorGadget #JuliaSet #fractal #fractals #MathArt #WebDev
fiddling with #InflectorGadget #WebDesign and not sure how to approach it. header/footer with all widgets visible all the time works well on desktop...
https://mathr.co.uk/web/inflector-gadget/web-version/2025-03-25.jpg
...but is terrible on mobile as the header/footer take up most of the page making it hard to do anything with the tiny part image in between.
now trying a collapsible menu thing, works ok on desktop, next step is trying on mobile...
https://mathr.co.uk/web/inflector-gadget/web-version/2025-03-26a.jpg
https://mathr.co.uk/web/inflector-gadget/web-version/2025-03-26b.jpg
today I started porting #InflectorGadget from desktop OpenGL 4 to browser WebGL 2. It won't be a replacement, because some things need double precision which webgl doesn't have, but more of a way to try quickly and share with others. nothing online yet...
today I added a quantization option to #InflectorGadget, to snap inflection points to #MandelbrotSet nucleus (first one) and preimages of #JuliaSet attractor (later ones) - this makes all the nodes as circular as possible
this also makes the structure exactly reproducible (by a human, no automation yet) from instructions as there's no fuzzy variation coming from imprecise mouse click locations
the human touch adds a certain pleasant softness, so quantum mode is optional
ABaABb (Inflector Gadget)
https://diode.zone/videos/watch/dddbd716-c34a-4cf3-bf67-3df324f372ca
exploring some fractal patterning with inflector-gadget
in tidalcycles-like notation the actions needed to be taken at each next step could be described as
[circle <tree tree>]
[circle <tree line>]
[circle tree line]
[empty filled <tree line>]
there's no notion of time in this pattern system, only a sequence of steps of different kinds (but no particular length). the earlier steps are harder, once you get going the visual shapes reminds you what you need to do next to continue the pattern.
the notation is interpreted by a human, not sure if automation is possible (or desirable - the variations in inexact mouse clicks add a soft irregular character to the structures)
