Exploring The Mandelbrot Set In Real Time

The Mandelbrot set – the fractal ‘snowman turned on its side’ seen above – has graced the covers of magazines, journals, and has even been exhibited in art galleries. An impressive feat for what is nothing more than a mathematical function, and has become something of an obsession for [Chiaki Nakajima].

Even on modern computers, generating an image of a portion of the Mandelbrot set takes a good bit of time. When [Chiaki] discovered this fractal in the mid-1980s, the computers of the day took hours to generate a single, low-resolution image. Real-time zooming and scrolling was impossible but [Chiaki] made the best of what he had on hand and built Pyxis, a Mandelbrot set generator made entirely out of TTL logic chips (Google Translate here).

The original Pyxis connected to a desktop computer via a breakout box. while a special program toggled the bits and registers inside the Pyxis to generate pictures of the Mandelbrot set a thousand times faster than the CPUs of the day could muster.

Time marches on, and the original logic chip Pyxis is can be easily surpassed by even the slowest netbooks. There is, however, another way to build a hardware Mandelbrot set generator: FPGAs.

A few years ago, [Chiaki] began work on the Pyxis2010 (translation), an FPGA-based Mandelbrot set generator able to dynamically zoom and pan around the world’s most popular fractal. Built around an Altera Cyclone III FPGA he picked up from Digikey for $600 (no, not a dev board, just a bare chip), [Chiaki] began deadbugging his circuit directly onto the pins of the hugely expensive FPGA. A man with a steady hand and no fear if there ever was one.

Instead of connecting his Mandelbrot generator to a computer and using it as a co-processor, [Chiaki] decided he wanted something more portable. He found an old Sony PSP, removed the LCD screen, and integrated it into his circuit. After a careful bit of dremeling and fabrication, [Chiaki] had a hand-held Mandelbrot generator that is able to display images of the world’s most famous fractal faster than any desktop computer.

It goes without saying this build is incredible. The technical skill to build an insanely fast Mandelbrot generator on an FPGA is astonishing, but basing it off a logic-chip based build reaches into the realm of godliness. You can check out a video of this amazing build after the break.

Props to [Ian Finder] for sending this one in.


33 thoughts on “Exploring The Mandelbrot Set In Real Time

  1. I would say the openCL fractal generators smoke this for pure speed… Especially in a multi-gpu pc.

    The skills shown here are nothing short of spectacular however.

    Its almost a shame to have such a low res screen for such am epic build.

    1. There’s no way you could zoom in as far with an OpenCL implementation: GPUs just don’t have the precision for it. At best you get a nominal 52 bits of mantissa. An Intel x86-64 chip gives you 64 bits of mantissa using 80-bit floating point mode, but that wouldn’t give you the speed you’d need to render this quickly.

      Currently an FPGA or a cluster of PCs is the only way to achieve that.

    2. You don’t even need OpenCL – pretty much all modern web browsers apart from IE will run WebGL – and you can do Mandelbrot in a fragment shader:


      It’s awesomely fast – however as with OpenCL (probably more so) it doesn’t really have enough precision. Having said that I’d be amazed if you couldn’t write you own multiply and add in OpenCL to handle arbitrarily large integers.

      Awesome build though – it’s great to see people using these impressive chips – even more so without a PCB! I guess when it comes down to it, $600 isn’t so much considering what you get for your money.

  2. that is a thing of beauty.

    In ma youf I tried to write a mandlebrot routine for my Ti calc. never did get it to work, until I realised the sheer workload a mandlebrot represents – it was working but oh so slowly.

    1. I implemented Mandelbrot in “basic” on my TI-82 calculator back in the 90’es. It required a fresh set of batteries and took just over 23 hours to render a single frame.

  3. It’s good to see reminders of how prices have fallen over time. That exact FPGA is <$400 at digikey, and if I read the report correctly, you should be able to do this on a <$100 FPGA (Spartan6 seems to have enough gates and memory).

    Something that hasn't changed is the challenge of handling BGA packages. Crazy cool deadbugging there!

  4. Sweet build!

    Editors: “When [Chiaki] discovered this fractal in the mid-1980s…” is potentially misleading to those who don’t know the history. I’d suggest something along the lines of “When [Chiaki] first heard about this fractal in the mid-1980s.”

  5. When [Chiaki] discovered this fractal in the mid-1980s, the computers of the day took hours to generate a single, low-resolution image. Real-time zooming and scrolling was impossible…

    Total balderdash! In 1988 a buddy had a fractal program that his brother wrote that used multicolors, zoomed and cycled in real time, it was amazing!

    1. I was gonna say the same thing. “Hours” is a bit of an overstatement. There was one for Atari ST that took a fraction of a second to redraw at 320×200, called the Trendy Handy Randy Hendy Bendy Mandy by Mark Henderson.

  6. This is just awesome. A masterpiece in every way. If my FPGA skills were at his level (they pale in comparison) I wouldn’t mind spending $600 in a single chip to get that kind of power in my projects.

Leave a Reply

Please be kind and respectful to help make the comments section excellent. (Comment Policy)

This site uses Akismet to reduce spam. Learn how your comment data is processed.