Tools → Process → Output

A friend once told me that, to some extent, tools put guardrails on the outcome. I don’t think they meant that in a rigid way, as if the tool decides everything for you, but it made me think differently about how I was making my work.

A tool sets boundaries. It creates a space where some things feel natural, some things feel awkward, and some things never really occur to you at all. Different software pushes you toward different kinds of images, even when it pretends to be neutral.

That idea stayed with me because I had spent more than 20 years working with software, images, interfaces, and code. For a long time I treated that experience as something next to the artwork: useful, practical, part of how I made things, but not part of the work itself. Eventually it made more sense to lean into it. If tools shape the outcome, then building the system is already part of making the work.

My brain keeps telling me that making good art should be as simple as finding a series of processes I can string together until something magnificent comes out. In a way, that is true. The hard part is coming to an agreement with the thousand small decisions that add up to something worth keeping.

That only happens by running the same gauntlet over and over. It feels like going to the gym for the art brain: failure, adjustment, repetition.

Vessel came from wanting a drawing system that matched the way I wanted images to behave. Pixel art, painting, animation, dithering, and playback all live on the same surface, so a drawing can carry structure, movement, colour, and timing from the beginning instead of collecting them later in separate apps.

I designed Vessel to remove the friction between intention and result. I wanted to change resolution while drawing, play and edit at the same time, and shift pattern, tone, texture, and behaviour through pressure rather than having to stop and dig into the settings.

That mattered because every interruption changes the work a little. Menus, exports, mode switches, separate apps, and fixed pipelines all create distance between the thing I am trying to make and the thing that appears on screen. That distance is never useful, so I wanted the system to stay close to the hand.

It was also never meant to be a general-purpose art app; the point was to build a particular set of limits and then work inside them. The pixel grid gives the image a kind of skeleton, pressure changes how a mark behaves, dithering handles texture and colour, colour cycling lets the image shift without being redrawn, and playback keeps it moving after the drawing has stopped.

Somewhere in there the work stops being a fixed picture and becomes more like a system. The image is still drawn, but it is also held by rules, timing, and state, so it can keep changing without being remade from scratch.

That changes the way I think about export as well. In most software, export is where the work gets flattened into a final file. The layers disappear, the timing is baked in, and the process is hidden. That never felt quite right for this work.

In Vessel, the image is built in the editor and then handed to Goblet, the player, where it keeps running. What moves across is the whole image-state rather than a flattened copy. Its timing, colour behaviour, dithering, playback, and structure all stay intact.

This is why the software feels like part of the material of the work, along with the marks, the rules, the mistakes, the failed versions, and the behaviours that continue after drawing stops.

Somewhere along the way, export stopped meaning the end of the image. Now it’s just a change of state.