Like That 2020 (3D)

“Like That” is a generative art project that started in 1996 as a series of 2d image generators and 3d animations called “The Order of Things”. It drew on the aesthetics of then-contemporary British art (Julian Opie, Rachel Whiteread, Art & Language, Bridget Riley). The 2d works in the series were written in the PostScript programming language. The 3d pieces were written in Metrowerks CodeWarrior C++ on Macintosh System 7.x using QuickDraw 3D, their source code has unfortunately long since been lost.

In 2008 I re-implemented and extended the project using Processing. That version incorporated more historical references and I renamed it “Like That”, a reference to a phrase one of my children had used as a general purpose assertion as a toddler. In 2009 I generalized Like That using a script written in Common Lisp to glue together fragments of Processing code into many different combinations of shapes, colours and movements.

In 2019 most web browsers no longer easily support the Java programming language that Processing is based on and Processing’s JavaScript replacements are either already deprecated or too different from it to make porting simple. I have therefore ported the 3D Processing code to THREE.js (I’m still thinking about whether to port the animated 2d code). Going from platform-specific compiled applications to cross-platform bytecode and then to scripting languages has been the technical journey of much of software development over the same time period.

I still find Like That visually and conceptually engaging so I was glad to be able to update it to add some contemporary references and keep it running.

Project page:


Source code:

Galerie Default

I created a building in CryptoVoxels using one of their default build templates and filled it with a show of Tokens Equal Text:

I’ve named it Galerie Default after how it was made. You can take a look in your web browser via the link above (and if you have a fancy VR headset you’ll soon be able to wander around it immersively). There are much more advanced uses of the CryptoVoxels system to show NFT art within it, but this was a fun experiment.

Hacking Creative Composition at CADAF

I’ve a couple of pieces at CADAF in New York with Kate Vass Gallerie (above is one of the giclées, “Local Maxima: SFLT2, Square” (2019)):

Creative Crypto have a profile of me ahead of the event, from which I’ve stolen the title of this post:

Blockchain Aesthetics: Dogecoin and Ethereum

Two new sets of visualizations to complement the Bitcoin ones: Dogecoin and Ethereum.

You can get them via git, or view them on the Show section of this site.



This took a ridiculous amount of time to hack together, but here’s a Common Lisp function to decide the shortest angle between two other angles. It’s used in the example of seeking a point above. I can now add noise to this to make a more AARON-style pen.

(defun shortest-angle-difference (a1 a2)
  "Find the shortest positive or negative distance between two angles."
  ;; This was slowly assembled from various online sources, none of which worked
  ;; Normalize angles to 0..2pi
  (let ((from (mod a1 +radian+))
        (to (mod a2 +radian+)))
      ;; If from and to are equal (0 = 2pi radians) the angle is zero
      (if (or (= from to)
              (= (+ from to) +radian+))
          (let ((angle (- to from)))
            (if (> (abs angle) pi)
                ;; Please simplify me
                (* (- (signum angle)) (- +radian+ (abs angle)))
draw-something 2016

draw-something drawing February 2016

I’ve updated the Common Lisp version of draw-something to use modern technologies – Roswell, QuickLisp, ASDF 3, cl-cffi-gtk and the Plan testing library. The tests helped flush out bugs, changing my mis-uses of defmethod to defun silenced a lot of compiler warnings and that in turn helped find some more bugs. There’s now a bit of technical debt in the form of function and class names, I’ll address that later. Like the recent minara update, this is a bitrot update rather than a new feature release.

Running the code to test it reminded me of just how dissatisfied I was with the last version of draw-something. The image at the top of this post is one of the less bad results of running the code. This is an aesthetic / theoretic problem rather than a coding one. I need the same clarity that informed the earlier versions of the program (you can see a JavaScript version of one running on tumblr) in order to structure the code to output something you’d actually want to look at.

Minara 0.4.0


I’ve been making the regular (accidentally) six-yearly update to Minara, my vector graphics program.

The new version switches from GLUT to Gtk for the windowing system, from GLU to Cairo for the renderer, and from C to pure Scheme for the core application. It’s all written in The GNU project’s Guile Scheme system.

Minara is Lisp all the way down: the application, tools, and graphics files are all written in Scheme. It’s designed as an environment for 2D generative vector art hacking.

Art For Algorithms


My first article for Furtherfield as guest editor is now online:

Rob Myers takes a look at how we can subvert the operation of the algorithms that the Digital Humanities, corporations and governments use to read, see, and draw conclusions about human expression by treating them as the true audience for contemporary art and literature.

Easier Dogecode

I’ve added a Dogecode runner that uses‘s API rather than requiring a local dogepartyd instance to be running. You can get the runner as part of the Dogecode source code here: And you use it like this:

dcrunw DFibwNZvuJaHM9bD6x1WA63urkHiE4tWzF

which will fetch the program encoded as Dogeparty tokens at the specified address (DFib…) and run it locally. Here’s some addresses to try:





Blockchain Aesthetics 2

Visualizing Bitcoin blockchain transactions – click on each image to run in your browser.

Each hash as instructions for a turtle graphics pen:


Life games with each hash as the starting board state:


A Chernoff Face of each hash:


Cellular automata with each hash as the initial row:


Quadratic curves with the bytes of each hash as the control point co-ordinates: