f(x,y) = ((~((x % 1) ^ (-x))) ^ ((-(~y)) * (-(21 * x)))) % 9
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text.
Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.)
The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((~((x % 1) ^ (-x))) ^ ((-(~y)) * (-(21 * x)))) % 9
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (((-(~x)) * ((y * 12) / (20 ^ x))) * (~(~(-y)))) % 11
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (~(((-y) ^ (-x)) / ((x & y) ^ (-x)))) % 11
Extent: 64x64 (scaled x8)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((-((x / y) - (y & x))) ^ (-(-(x / 6)))) % 7
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((y + x) & (x + y)) * ((x / 7) & (y & x))) / (((18 | y) * (x ^ y)) | ((x | y) | (8 / y)))) % 11
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((x & 3) / (y - 7)) % ((10 | x) + (x / x))) | ((~(y & y)) | (~(x * y)))) % 10
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((-((19 / y) ^ (x % x))) + (((24 | x) * (y + 12)) ^ ((2 ^ x) % (~y)))) % 10
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((~((y ^ x) & (y / x))) ^ (((-y) * (~x)) * ((21 / y) / (x - x)))) % 4
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (((-(~x)) % ((-y) & (13 % y))) * (((~x) ^ (22 % y)) ^ ((y ^ 9) + (x - x)))) % 9
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (((-(3 ^ y)) & (-(5 & y))) * ((~(-y)) | ((x * 4) % (~y)))) % 6
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (~(~((y + 23) / (x * 4)))) % 2
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((y % x) * (x - y)) | ((y / 3) % (x + 15))) * (((y % y) + (x * y)) + ((y % x) / (y ^ y)))) % 7
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (~(((x + y) & (~y)) + ((-y) | (x % y)))) % 13
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (-(~((7 & x) ^ (y | x)))) % 13
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (((-(22 ^ y)) + ((13 & x) * (~y))) * (((15 & x) ^ (17 | x)) - ((-x) ^ (y - 8)))) % 4
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((-((~x) ^ (y + y))) / (((y & 19) / (~x)) - ((~x) ^ (x & y)))) % 10
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((x - y) / (x + 3)) - ((x * x) ^ (x / y))) | (~(~(-x)))) % 6
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ~(~((y + y) % (y ^ x)))
Extent: 256x256 (scaled x2)
"Gradient" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((~y) + (y / 21)) / ((y ^ 13) ^ (y & 9))) ^ ((-(x | x)) + ((x * y) / (14 ^ x)))) % 3
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (-(((x + x) % (20 | x)) + ((22 ^ y) + (-y)))) % 3
Extent: 64x64 (scaled x8)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (-(((5 * x) - (23 / x)) - ((y | x) + (y ^ x)))) % 7
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (-((~(~y)) * ((x & y) % (y | 17)))) % 13
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (~(~(~(x % y)))) % 6
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((x * 24) + (y ^ 22)) * ((y % 22) * (~x))) / (-((~y) & (-x)))) % 11
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((y + x) * (y ^ y)) / ((y & x) * (18 + x))) | (((7 + y) % (23 ^ x)) | (-(~y)))) % 3
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((y + y) ^ (-x)) + ((x & y) * (x % x))) + (((-x) % (y & x)) - ((~x) + (11 | y)))) % 4
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (((-(y * x)) | ((x - 11) | (6 + y))) / (((y * y) / (x ^ x)) / ((y & y) ^ (y / y)))) % 9
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (-(((~y) % (x * y)) / (~(y % y)))) % 12
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((~y) & (x ^ 13)) - ((x + y) * (y - y))) / (((-x) / (y / y)) / (-(~y)))) % 3
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (((y + y) + (23 & y)) + (~(y / y))) | (((y % 15) % (y ^ x)) ^ ((-x) & (~x)))
Extent: 256x256 (scaled x2)
"Gradient" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((x + y) % (y - 21)) % ((x - 23) ^ (~y))) * (-((y ^ y) + (x % 11)))) % 6
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((y / 5) ^ (y * 1)) % (-(y ^ x))) ^ (((24 * x) - (~y)) | ((y | 17) & (18 * x)))) % 8
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((-((x % y) + (21 / x))) + (-((21 & y) ^ (-x)))) % 12
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((~y) / (x & x)) ^ (-(x ^ y))) + (~(-(13 ^ y)))) % 11
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = (((-(~y)) / ((x / y) % (7 - y))) - (-((3 - y) ^ (y & 2)))) % 2
Extent: 128x128 (scaled x4)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((-x) & (y % x)) | (~(x | y))) % (~((-x) | (x | x)))) % 5
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((~((x + y) * (x & x))) ^ (((1 ^ y) % (x | y)) * ((y % 15) - (x & x)))) % 12
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((y ^ y) | (-x)) | ((x % y) | (-x))) ^ (((y * y) - (18 / y)) * ((y * 24) / (~x)))) % 12
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
This is a bot which produces procedural art by plotting an integer function taking the current coordinates and producing an integer result. The function is procedurally created using random numbers and appears in the status text. Coordinates are coloured either by where the value appears within the range of results (the "gradient" scheme) or simply by whether it is the most common result (white) or not (black) (the "onebit" scheme.) The code does not resort to evaluating a string.
f(x,y) = ((((-y) ^ (-y)) * ((x + x) + (-y))) + ((-(x - x)) + ((~x) % (x * y)))) % 5
Extent: 256x256 (scaled x2)
"Onebit" colouring scheme.