If you want to keep zooming in the browser and have snappy gpu accelerated performance while basically never hitting “reached limit of numerical precision,” check out https://mandeljs.hgreer.com . The math to make this possible gets pretty funky: I go over the tricks I used at https://www.hgreer.com/JavascriptMandelbrot/

No scrolling with the scroll wheel though :(

The whole thing is a tower of spaghetti bit hacks in the name of depth and speed. Embarassingly, it actually can't actually render zoom levels that aren't powers of two and I'm not sure how to change that.

Can you make it so that the position you clicked stays at the same position after each zoom, rather than centering it on your cursor? That way you can click multiple times to zoom in on the same point.

Thanks for creating this, I had some fun exploring the set. What does the scale parameter stand for?

The color of each pixel is

    fragColor = vec4(vec3(cos(c), cos(1.1214 * c) , cos(.8 * c)) / 2. + .5, 1.);

Where c is the number of iterations divided by the scale.

That really is very fast!

(I don't know if this is a known compromise of your technique (I couldn't find it mentioned), but I occassionally get a ring of varying thickness centred in the render with an inverted coluring to the rest of the pixels, or sometimes a solid colour. It varies is size and comes and goes without an obvious correlation to zoom level.)

Yeah, I've been chasing that for a while. I've traced it to subnormal float handling. Here's the scenario: if you multiply the 32 bit float float 1 x 2^-127 by 1/8, you can't get 1x2^-130 because 130 isn't representable in a 8 bit exponent. On the CPU or a modern GPU, this is special cased to result in a "subnormal" float: .125 x 2^-127. However, this adds a ton of extra complexitity to the FPU. Old GPUs just gave up and say "It's zero." WebGL standardized on the old GPU behavior, so a modern GPU running webgl sets a flag to behave like the old GPUs.

I'm representing complex numbers as (real_mantissa + i * imag_mantissa) * 2^exp where real_mantissa and imag_mantissa are themselves 32 bit floats, and I can reduce the frequency of the colored rings in my shader by keeping the mantissas around ~1000 instead of ~1 (and reducing the exponent to keep the value the same) so that they are less likely to go subnormal, but I can't seem to get rid of the colored rings entirely.

I don't actually know the pathway through the code from subnormal underflow -> colored rings, but if you run a CUDA renderer with the same algorithm, the rings appear when you set the flag for "round subnormal floats to zero."

Wow nice! Though I seem to get artifacts both in Brave and Firefox on Android: https://imgur.com/a/vo2ZVOQ

https://mandeljs.hgreer.com/?;re=-0.751165720536567020384363...

Here's my attempt done a long time ago, not very polished:

https://brazzy.de/en/Mandelbrot.php

Even for that, the actual Mandelbrot calculations were the smaller part. It's really amazing how such a trivially simple formula spawns such endless complexity.

I'll add my julia attempt that animates and works with webgl:

http://julia.perses.games/

Complexity is trivial. That's the lesson here. It's human perception that's special. It's special in that it has an uncommonly low bar on what's considered impressively complex.

Which implies something important, no doubt.

I made quite a sophisticated viewer as a teen, but boy was it slow to run back then, back on a 486.

Now people write viewers that run lighting fast in a browser thanks to WebGPU! Like:

https://www.reddit.com/r/fractals/comments/o7l4bm/please_try...

I remember as a teen I did mine in 68000 assembly on a Commodore Amiga to get it reasonable fast considering it was running on a 16 MHz CPU — i would say a few seconds to draw the canonical image — but IIRC it reached pretty fast the limit of math precision.

At that time I didn't know what was a complex number, but was fascinated by the whole concept of fractals and how complex structures could be created with a relative simple program.

A few seconds? Wow! I did a science fair project on the Mandelbrot set using my Amiga 2000, and it took me a good 45+ minutes to generate a single 320x200 color image. IIRC, I wrote the generator in some variant of Pascal, and was so happy with the performance increase over Basic on my C=128...

I ran in to the precision limit pretty quickly, same as you. I didn't understand computers well enough to know that's what the problem was, and I remember spending hours pouring over my code, trying to figure out where the bug was. Good times. :D

The difference is probably you used floats and he/she used fixed point (integers). Of course that way you do run out of precision very quickly.

Software emulated floats on Amiga 2000 were really, really slow.

If I'm not confusing it with something else, I seem to recall that when zooming on the set the calculation was nearly instantaneous. As you said, good times! ^__^

I still have that A500 but who knows where I put those floppies, I'm tempted to turn it on but I'm scared the PSU will blow itself...

A500 PSUs (particularly the 2nd one) are the most reliable and powerful.

The A500 themselves are built like tanks. Chances are it just works.

But watch out for trapdoor expansion. Most likely has a varta barrel battery in it, which will eventually leak and damage the expansion, and possibly also the computer itself.

I would recommend opening that trapdoor and removing/inspecting anything installed there as soon as possible.

These barrel batteries are only used to keep RTC, and the board will be fine w/o.

I did it in QuickBasic (also on a 486).

Now that's slow.

I typed in a BASIC program for a C-64 from a computer magazine. That was a popular mechanism for software distribution back then.

I thought "this will never work", but I was amazed that it did in fact work. I remember letting it run overnight to find a complete 160x200 4-color image the next morning. Just clearing the screen using a loop to fill 8192 bytes with 0s took over a minute.

Everything about the computers at the time was so terrible, I don't feel any nostalgia for those days or that technology.

The one I wrote in BASIC on my Apple IIe never finished, it hadn't even got the interesting bits of the set after a day or so and I needed to play games.

FRACTINT was great because I could use my 286 and it was fairly fast because used integer whenever possible.

I did it in High School on my crappy TI programmable calculator. Took for ever to calculate but it worked.