A message

The story of how that article came to be starts, weirdly enough, with a message from my sister. She sent me a message just after Christmas letting me know how she was telling her kids about some butterfly-shaped fractals I discovered when I was a kid, but all she can find online are formulae, and whether I could send her some pictures?

Truth is, I did have a webpage about them, except, it was the old page on the old domain I lost. I thought, no biggie, I’ll just checkout my local source of my former website, and realized with horror that I… don’t have them anymore somehow? After some digging, I managed to find them in the Wayback Machine (I was so relieved and thankful that I immediately sent them a donation, too!)

A floppy disk rescue mission

That being my winter break time of the year, it also gave me an impulse to do something I do every third winter break on average related to old software and data – bring out an old Atari ST to the living room floor, power it up, check if some floppies are still readable after many years, maybe create a fresh copy of the more important ones. Like this:

I’d also fire up and play around with some of these programs, marveling at just what I was able to achieve as a seventeen year old kid. I wrote a bunch of software for Atari ST in my youth. Some games, but by far my most favorite piece of software was a fractal generator I named Butterfly Fractal Generator after the visual resemblance of some fractals I discovered. Now you see how did a message from my sister lead me to bring out the old Atari again.

During these times I would also quietly despair at the thought that over the years I never managed to transfer any data off the floppy disks into a more modern ecosystem (e.g. an SSD in a laptop) for preservation. The only media that contains these precious bits of nostalgia are few 3.5" floppy disks. Miraculously, most of them are still readable after three decades, but it’s just a question of time before data gets corrupted and they get lost forever.

So every time I’d try different schemes to rescue them. I have an older PC that still has an internal floppy drive, and I tried various programs in the past that claimed to read and write Atari floppies on PC, but none of them worked. There are solutions to connecting Atari’s serial port to PC’s serial port and transferring data that way, but I was always stumped by the need to find or make a cable for that, or by the fact that I had no way to transfer the necessary software to an Atari floppy so it can run it.

I even considered some crazy schemes myself, like typing in a program on Atari from scratch that’ll convert floppies into modem sounds, recording them, and writing a program on PC that’ll decode them. Fortunately, I didn’t quite follow through on that one.

This year, I found some new rescue tool candidates: a low-level floppy driver named fdrawcmd.sys and an Open-Source program named ST-Recover and an older one named FloImg. Unfortunately, none of them worked either. The floppies kep Being Not Read (or rather, Being Read With Lots of Weird Drive Noise and Accompanying Errors.)

In desperation, I asked for advice on the interwebs, and a kind soul suggested I should try Greaseweazle, which is both software and a little circuit board that directly drives floppy drives. It “directly reads the magnetic flux on the surface of the floppies” – come on, how could I not desperately want to own one of these?

So I ordered a prebuilt Greaseweazle from a shop in Portugal, and it arrived, and I connected everything together, which ended up looking kind of ridiculous. So on one end there’s my MacBook Pro, which connects with a USB-C cable to Greaseweazle, which then connects with a floppy ribbon cable to a floppy disk drive that I took out of the PC chassis. Except… the drive also needs power through a 4-pin Berg connector, and the only power cable I have for it is the one coming out of the PC’s power supply, so I’m operating a noisy old PC beside all of this with an open chassis solely so it can provide power to the floppy disk drive I took out of it in the first place. Oh well, as jury-rigged assemblies go, I’ve had worse. I’m sad I didn’t remember to take a photo.

Anyhow, all of these gadgets are now properly connected to one another, I put in a floppy disk, and… I still got read errors! However, Greaseweazle diagnostics pointed out a curious thing: all read errors were on one side of the disk. I tried a different disk, with same results. Oh dang… it was never any of the software solutions’ fault; rather my old internal floppy disk drive is bust!

Wouldn’t you know it, I found a local business that advertises itself as a “PC scrapyard” and phoned them to confirm whether they have 3.5" floppy disk drives. They did (“we pre-test each one whether it works!”) I went to the place – it was, in fact, very scrapyard like. A store in a basement, with all kinds of PC parts from various eras in heaps on shelves, the proprietor himself not exactly a youngster anymore either. I had a chat with him how his inventory system still runs off of a floppy disk, so having a stash of replacement drives is absolutely essential for his business. Truly a shop frozen in time, that.

I returned home, connected the new drive to the Greaseweazle, and IT WORKED!. Finally, after 33 years, I had a copy of my software that is safe from entropy on floppy disks and I could run on an emulator!

On a sidenote, Greaseweazle needs the exact geometry of the disk on input if you use it in high level read mode (so not imaging the magnetic flux), and back in my youth I carelessly formatted my floppies as anything from 80 to 86 tracks, and from 9 to 11 sectors per track, so it was a bit tedious to figure out the format. I eventually switched back to running ST-Recover and FloImg on the PC, as they read the declared geometry of the disk from its boot sector data. And because of the power supply for the floppy disk, I couldn’t eliminate the PC from the setup anyway.

Next steps

Now that I could extract the data from floppies, I could also use an excellent feature from the Hatari emulator where I can mount a directory on my Mac as a HDD for the emulated Atari, so I can super easily transfer data into the file system on my laptop.

I already created an archival source code repository for my Butterfly Fractal Generator source code on Github. I also spent about a day trying to embed a browser version of the Hatari emulator into the page with the generator preloaded so people can play around with it, but it kept Not Wanting To Work so I gave up on that. In lieu, there’s an Atari ST disk image that you can load into an emulator yourself, should you want to.

I have some other projects from the past that I plan to upload for posterity later, as time allows, but all-in-all it’s a great feeling that they have finally escaped the confines of the old floppy disks.

I got introduced to fractals when I was maybe 14 years old. I grew up in Croatia in the '80s, then still part of Yugoslavia, and there were 3 monthly magazines you could subscribe to in Yugoslavia if you were a computer afficionado: “Moj Mikro”, published in Slovenia, and “Računari” and “Svet Kompjutera”, both published in Serbia. Naturally, I was subscribed to all three.

I don’t remember anymore which one of these three had an article around 1987-88 about the Mandelbrot Set, illustrated with black-and-white pictures of some interesting zoomed-in areas. I was immediately mesmerized by the beauty of it all. Despite not having any prior knowledge of complex numbers, I managed to write a small program in Commodore 64 BASIC (yep) to compute an image of the Mandelbrot Set in C64’s 160x200 resolution with 4 colors.

As you can imagine, it was slow^[1]. Like, go for lunch and come back to see it rendered few more columns of pixels slow. It wasn’t until several hours into runtime that I could tell if it even computes the right thing! Luckily, it did.

Writing my first proper fractal generator

Maybe a year later, I managed to convince my parents to sell the Commodore and instead buy an Atari ST. Going from a 1MHz 8-bit CPU to a 8MHz 16-bit CPU was a huge leap. Naturally, I wrote a fractal generator for it. By then, Fractint was around on PCs, and I learned a lot from it, e.g. some tricks to speed up computation. Most importantly, I learned that you can generate fractals from pretty much any formula. The generator I wrote ended up supporting a whopping 39 formulas! It supported not just the Mandelbrot/Julia set pairs, but it could even plot attractors.

Finding a new fractal

Many of these were well-known formulas, but of course, I wanted to know if I can find some hitherto undiscovered formulas, so I started experimenting with them. I didn’t have any methodology to my exploration; I was just assembling formulas by randomly constructing algebraic expressions and then watching what fractal image they produce. Most of the time, the generated fractal would be quite boring, often just a black circle surrounded by a sea of blue. It was summer, I was 16, so I had other things to do too (swimming, playing table tennis, reading books, being hopelessly clumsy around girls), but from time to time especially when it was too hot outside I’d stay in my room, sit in front of the Atari, and think of more ways to contort algebra.

Eventually, one formula caused this to appear on the screen:

Wow! I could not believe my eyes, but it was real.

(As a sidenote, this is an actual rendering from my original fractal generator software I wrote for Atari ST back then. I recently managed to finally transfer it from its original floppy disks where it spent a good 30 years without getting corrupted, so I can now run it in an emulator!)^[2]

In the video below, you can also see how it looked like while the software was running to render the fractal. It’s actually four times faster than it were on my original machine back in the day, as I could tell the emulator (the excellent Hatari) to run the emulated machine at 32MHz clock speed instead of its original 8MHz.

What’s the formula?

If you want a good introduction to Mandelbrot/Julia style fractals, I can recommend both an excellent 3Blue1Brown video and a similarly excellent Numberphile video. I’ll try to give you a quick summary here too, but if you’re intimidated by the math, just skip this section and keep looking at the pictures!

All Mandelbrot-Set style fractals are generated by iterating some function over the set of complex numbers. For every possible constant value $c \in \mathbb{C}$ we compute the sequence of $z_0 = 0; z_n = f(z_{n-1}) + c$ and if the sequence doesn’t escape towards infinity, then $c$ is part of the set (customarily colored black or white), and if it escapes towards infinity, then $c$ isn’t part of the set (and we color it according to some notion of how fast does it escape.)

For Mandelbrot Set proper, the iterated function is simply the square of a number, $f : \mathbb{C} \to \mathbb{C}, f(z) = z^2$. Or, written in the $z=(a+b\mathrm{i})$ notation that decomposes the complex number into a sum of its real and imaginary parts: $f(a+b\mathrm{i}) = a^2 - b^2 + 2ab\mathrm{i}$.

The iterated function for Szegedi Butterfly 1 fractal is also easiest to express in this decomposed notation. This is the function:

$$ f : \mathbb{C} \to \mathbb{C}, \quad f(a + b \mathrm{i}) = b^2 - \sqrt{|a|} + \left(a^2 - \sqrt{|b|}\right)\mathrm{i} $$

Finding more fractals

Now that I had this function, a trivial next function to try was to take the previous one and just swap the real and imaginary components in the function to obtain Szegedi Butterfly 2:

$$ f : \mathbb{C} \to \mathbb{C}, \quad f(a + b \mathrm{i}) = a^2 - \sqrt{|b|} + \left(b^2 - \sqrt{|a|}\right)\mathrm{i} $$

This resulted in this image:

Szegedi Butterfly fractals in modern software

If you want to explore these fractals today, I can recommend Ultra Fractal. It is commercial software but at $29 for its Express Edition it’s quite a steal (I’m not affiliated.) A nice thing about Ultra Fractal is that it has a large formula database, and many years ago I had my Butterfly Fractals added to it, so you can generate them as soon as you downloaded the formula database.

Here’s how they are rendered in Ultra Fractal, with more colors and a higher resolution (note how the horizontal axis is mirrored compared to my generator.)

In addition to the two fractals generated with the Mandelbrot-style iteration, there’s also an infinite set of their Julia/Fatou Set equivalents. Here’s a random representative of a Julia dual of Szegedi Butterfly 1:

And here’s one random representative Julia dual of Szegedi Butterfly 2:

Bioforms

In addition to the butterflies, I also discovered another function that produces – especially in its Julia sets – something that looks very much like living cells, or maybe a cross-cut of a living tissue. I call this one Bioform:

$$ f : \mathbb{C} \to \mathbb{C}, \quad f(a + b\mathrm{i}) = (2 - a^2 - b^2) * (b + a\mathrm{i}) $$

Its Mandelbrot Set equivalent looks like this:

It’s however the Julia sets that really show why I named this one Bioform. Just look at this animation going through a bit of the parameter space:

So… that’s it, that’s the fractals. Again, if you want to play with them, I recommend Ultra Fractal – happy exploring, and if you find some interesting regions in them, do let me know!

I used to have a personal website with .org domain but then due to some e-mail misconfiguration managed to miss its renewal reminders some years ago. When it expired, it was immediately snatched up by someone with address in Russian-occupied part of Ukraine and turned into a generic parked website with content revolving between fishy ads and porn. I guess squatted domains are being bought and sold, and these days according to Whois it belongs to an entity in Seyschelles. The new owner currently (fishily) advertises casinos on it.

The new personal website

So, this is the new personal website! Of all free similar domains, .live was the one that looks most legit. (I learned that you don’t really want to host an .xyz domain unless you are deliberately going for a shady look.) I’m also hosting it on Cloudflare Pages, and using a static site generator for it. We’ve come far from the original days of using a Secure Copy Protocol client and manually crafting HTML! Cloudflare is also my domain registrar now with an autorenew option, so fingers crossed I don’t lose at least this one!

What’s going to be here?

Mostly a blog. Maybe something more over time.