I've learned and applied many programming languages for these projects. Many were interesting math and/or optimization experiments including parallelism. Fractal rendering lends itself to iterative, recursive, and approximate algorithms, and working with them was quite fun.

These projects were a mix of deriving and applying new algorithms, as well as researching and adapting existing ones.


For these projects, I learned about or used:

  • chaotic algorithms and strange attractors
  • complex mathematics
  • n-diminsional affine transforms
  • color space transforms
  • GPU programming
  • CPU parallelism

I worked in the following languages:

  • GLSL
  • Python
  • RealBasic
  • Processing
  • Java
  • Go
  • C

Outline of projects


Fractal Chaos

In 2006 I discovered the Chaos Game Algorithm. My first project with it was Fractal Chaos which I wrote with a friend of mine I was teaching to program. Originally we only knew about Sierpinski's triangle, but with some changes we discovered may other fractals it could produce as well, such as this one (right), which was the first of our discoveries.

I later found out that this, and many other similar fractals had already been discovered, and they were all a subset of Flame Fractals generated using Affine Transforms and a histogram image. At one point I programmed my calculator to generate some of these as well.


Experimental Higher Dimensional Flame Generator

After rediscovering some interesting 2D flame fractals, I decided to investigate higher dimensional ones. I couldn't find any existing work on the subject beyond some minimal 3D experiments with 2D histograms. I tried 3D histograms, as well as regular 2D histograms while mapping some of the additional dimensions to locations on an image. Here are some animations produced with this algorithm (click to view).
Shredding_a_Flower___Full_by_Craig_M.gif Fractal_Shredding_1_by_Craig_M.gif

Experimental Reverse Flame Generator

The Chaos Game algorithm has very poor cache performance. It requires almost randomly jumping around a large histogram incrementing cells. This includes use of random numbers as well. I derived a deterministic explicit algorithm for computing an approximation of the value in any rectangular region in the histogram. This allows computing small areas of the desired image, as well as easy parallelism. The approach is based on inverting the affine transforms used to make the fractal, then iterating transforming the target region of the histogram and looking at the included areas. This approach was also possible to implement as a fragment shader to run on the GPU, see also GPU version below.


I implemented a experimental fractal flame renderer in Go. It is designed to have high performance including parallelism. It is intended to allow trying and mixing many rendering algorithms, types of functions, and coloring schemes. It is an experimental project with a focus on exploring algorithms. It is still in the early stages, but has produced some interesting results and the source code is available on the GoFlame page on GitHub


I implemented a non traditional, but still forward renderer. It takes the histogram and maps it onto itself accumulating the image.

Parallelized Backward

This backwards renderer is a modification of my previous backwards renderer that iterativly improves the image by looking at the pixels that would be mapped onto each pixel every iteration.

Evolving Fractals

In Processing I implemented a user interface for displaying and choosing fractals described by parameters fetched from the central server. Once enough selections had been made, a new generation of fractals would be produced. A selective mating algorithm was implemented to allow multimodal optimization. When combined with people's bias toward novel fractals, this allows several different species of fractals to develop. The selective mating was done by evolving a preference for how similar potential mates should be in various aspects. In the user interface, likely mates tended to flock together as they self organized on screen. The evolution was done on a central server which supported multiple client web apps working together to evolve fractals. Some renders of the resulting fractals are included below:
Evolved_Fractal_Hexagon_by_Craig_M.png Wave_Square_by_Craig_M.png Evolved_Fractal_Square_3_by_Craig_M.png Evolved_Pentagon_by_Craig_M.png Ring_of_Red_Lightning_by_Craig_M.png


Fractal Paths

When I learned about fractal curves, such as the Koch Curve, I implemented an editor and rendering for making them. It implements a subset of L-Systems with realtime threaded rendering while editing and viewing. Mac and Windows builds can be downloaded on the Fractal Paths page of my Spin Craft Software site. There are additional images on the Fractal Paths Images page as well.

Escape Distance Fractals

I've done several experiments with escape distance fractals, mostly based on complex mathematics as with the Mandelbrot Set. The idea is to apply an iterative algorithm, and select the points that converge, either to a point, or to a cycle, as part of the set. Success in this area demonstrates an understanding of convergence and divergence as well as complex mathematics.

GPU Fractal Renderers

I've implemented several fractal renderers that do most or all of the processing on the GPU. This demonstrates my ability to adapt and efficiently use available hardware.


In GLSL I derived and implemented an interesting coloring algorithm for the Mandelbrot set and the areas around it. These images were generated entirely on the GPU using my shader.

AngleBrot4_by_Craig_M.png AngleBrot5_by_Craig_M.png AngleBrot6_Wallpaper_by_Craig_M.png BlueBrot1_by_Craig_M.png Error_Brot_by_Craig_M.png FlowBrot1_by_Craig_M.jpg MandelTree_by_Craig_M.jpg Shadow_Brot_by_Craig_M.png

Reverse Fractal Flame

I ported my Experimental Reverse Flame Generator (see above) to GLSL. It provided very fast visualization, but suffered from limited numbers of iterations.

Forwards Fractal Flame

Using Panda3D, I implemented the Fractal Flame algorithm with each transform represented by a quad which additively rendered to construct the fractals. The image after each step was used as the textures for the next. This provided a realtime interactive speed renderer what would converge to a good approximation of the fractal.

Copyright © 2011-2013 Craig Macomber