Imagine a pen held in a fixed position with a paper moved under it. The pen can be raised and lowered independently of paper movement. This simple idea was the basis for this digital exploration.

Moving a piece of paper under a pen is analogous to translating all the pixels in a digital image. Therefore, I set out to build a system where each frame is calculated based on the previous frame and a series of user inputs.

At the heart of this system is a GLSL shader. The shader generates a new frame by translating all the pixels from the previous frame based on the boolean input and drawing the kernel at the center. For example, if up is true, then the value for pixel x,y in the current frame would be the value for pixel x,y-1 in the previous frame.

For initial experimentation, I wired up the boolean shader inputs to the WASD keys on my keyboard, allowing me to move around the canvas like a game of snake.

With the basic mechanism in place, I added additional features to enable creative art-making with Pixel Painter.

Kernel color and design can be changed.

The speed of the animation can be changed by increasing the number of pixels we translate each frame.

The pen can be raised and lowered so that we can navigate the canvas without drawing on it.

All colors on the canvas can be inverted while leaving the kernel unchanged.

I found that it could be difficult to create sophisticated artworks in manual mode, so I developed a simple scripting language to define pixel painter artwork. In PPCL, one line defines one frame of the animation.

Commands:

Control Structures:

Only two simple control structures exist in PPCL: line repetition and block repetition.

Prepend a command line with an integer N to repeat that command N times.

Wrap a block in parens prepended with an integer N to repeat the block N times. Note that the parens MUST have their own lines.

Example:

5 (
frameMultiplier=2
penDown
50 right up
50 left up
50 left down
50 right down
invert penUp
frameMultiplier=5
20 down
)
20 left

This PPCL code draws a simple repeating diamond pattern.

Writing PPCL:

While PPCL can be written manually in a text editor, I've also implemented a mechanism to record commands from manual mode and export the PPCL. In this way, manual mode can be used as a testing/experimentation ground to generate PPCL for use in future artworks.

When Pixel Painter finishes executing a PPCL script, it restarts execution from the beginning of the script without clearing the canvas. As a result, we can use PPCL to create infinite artworks that continue to animate forever, so long as the PPCL script leaves the kernel in a different position than it started and the script will not completely cover the canvas in one color.

Unlike the other artworks on this page (which are video files), the artwork to the right is embedded javascript and will continue generating indefinitely.

We can also use Javascript to generate complex PPCL. This also enables us to use tools like fxhash to generate pixel painter artworks parametrically.

In the artwork to the right, I have used Javascript to generate a new color value for the kernel at each frame, enabling me to create gradients.