This weekend I decided to play around with OpenCL, something I had never used before. As first project I built a Mandelbrot set renderer. This seemed fitting, since in high school I wrote an extremely slow version in TI Basic on a TI84 graphic calculator. Rendering a single image took about 45 minutes.

The math behind the Mandelbrot set is relatively simple. A point on the complex plane is included in the set if the sequence with is bounded. For simplicity we interpret “bounded” as after 256 iterations. To add some nice coloring to the points outside of the set, we can count how many iterations it takes for the sequence to go “unbounded”.

I translated the pseudo code from Wikipedia into the following OpenCL kernel:

```
__kernel void mandelbrot(__write_only image2d_t out) {
int2 pos = (int2)(get_global_id(0), get_global_id(1));
int2 size = get_image_dim(out);
// Scale x to -2.5 to 1
float x0 = (float)pos.x / size.x;
x0 = x0*3.25 - 2;
// Scale y to -1 to 1
float y0 = (float)pos.y / size.y;
y0 = y0*2.0 - 1.0;
float x = 0.0;
float y = 0.0;
uint max_its = 256;
uint i = 0;
float d = 0.0;
while (i < max_its && d < 4.0){
float xtemp = x*x - y*y + x0;
y = 2*x*y + y0;
x = xtemp;
d = x*x + y*y;
i++;
}
uint4 color = (255, 255, 255, 255);
if (d < 4.0){
color.xyz = (uint3)(0, 0, 0);
} else {
color.xyz = get_color(i);
}
write_imageui(out, pos, color);
}
```

The complete code can be found on my GitHub repo.