The Mandelbrot Set is a mathematical oddity where a simple function creates an infinitely complex landscape that you can literally zoom into forever. Like most people, I’ve downloaded Mandelbrot set viewers and marveled at the infinite whorls and spirals, and then waited while each frame took minutes or hours to render as I zoomed in. [Michael Henning], [Max Rademacher] and [Jonathan Plattner] decided to throw some modern computational muscle at this problem by building an interactive Mandelbrot set viewer using a laptop and two FPGA boards.

The three are students at Cornell, and this was their final project for the Advanced Microcontrollers class. The design is clever: the laptop handles the user interface and renders the final display of the Mandelbrot set. It also sends requests to the FPGA boards that do the number crunching, dividing the required calculations into tiles that are divided between boards. The FPGA boards are TerASIC DE-1 SOC boards that are built around a Cyclone V SOC FPGA chip twinned with 1GB of DDR3 memory. They used two boards, but their modular design means that it would be easy to speed the system up even further by adding additional FPGA boards.

The results are very impressive: the user can zoom in or out and move around in real time, at an impressive resolution of 1600 by 1200 pixels at 60fps. It does slow down when you zoom in, but it’s a remarkable example of how much faster FPGAs can be at this sort of thing than standard CPUs. They have tested it to a maximum depth of 2^260, but their system should be capable of going even further to a remarkable depth of 2^1700. At that depth, the full Mandelbrot set would be nearly as big as the observable universe.

[UPDATE: Corrected to DDR3 memory from DDR5]

I believe you mean DDRR3 memory. DDR5 isn’t projected to be available until late this year.

Oops, I meant DDR3, not DDRR3.

The extra R is because the rate is doubled!

You are right, the sources also mention DDR3

Yup, my bad. Slip of the keyboard and some wishful thinking.

How does the FPGA implementation compare to GPU implementations?

A quick look around turns up a 41ms to calculate a 2k*2k Mandelbrot on a GTX285 (from a test in 2010).

That would be around 19ms for a similarly-sized image, so a GTX285 wouldn’t be able to keep up with 60 FPS.

By 3D performance alone, a GTX1080 should be around 10X faster than a GTX285, so I’d say any recent GPU could easily outperform this FPGA.

https://www.shadertoy.com/view/ldSfWG

You can test it online there (a lot of mandelbrots written in shader language can be found there)

True, but for any level of detail in a Mandelbrot you need double precision math.

An ordinary GPU shader won’t be good enough, it will rapidly lose detail as you zoom in.

Any GPU manufactured in the last few years can handle double-precision in shaders normally, at not too bad a performance hit. And you can always use multiple of them and be clever to get whatever precision you need, at a higher performance hit.

That seems a little extreme. The two are both tools. Use them however you wish.

This looks so much better than bitcoins :)

Makes me wonder if there are any ASICS for speeding up complex multiplications. Would be helpful for signal processing too.

ASICs for speeding up operations commonly used in signal processing already exist. In fact, you probably have several in your PC – they’re called SIMD instructions.

It’s actually using ddr3, not ddr5

What about XaoS? Always been fast enough for me, even back then :)

https://sourceforge.net/projects/xaos/

Indeed. I was happy with xaos 10 years ago, perhaps not 60fps but still fast enough for realtime zooming.

BTW I also remember waiting 12 hours for single 160×200 multicolor frame on my C64 (coded in SImons’ Basic)

Oh, just checked and they even ported it to javascript, pretty fast too http://jblang.github.io/XaoSjs/

Yeh, right. So many microcontrollers are being pulled from the market and replaced by more expensive FPGAs that can’t be programmed by DIYers aren’t they?

I think you need to get a grip on reality and take a look at what’s on the market. FPGAs let you do things that are difficult or impossible with a microcontroller, but they don’t replace them for general use.

I hammer in all my screws with a brick

Nobody wants to learn things they only berate things, This could have been achieved in 2 months using 4 555 timers and a single resistor of unknown value.

with the difference that the 1080 is a magnitude (or more) bigger energy dryer than that fpga.

Previously:

https://hackaday.com/2012/10/23/exploring-the-mandelbrot-set-in-real-time/

Realtime rendering of the Mandelbrot set, using a deadbugged FPGA!