I “wrote” and “published” a “graphic novel.”

Like most people, I generally dislike scare quotes, but I want to underscore those in that declaration, because I want to be clear from the outset of this post and the two that will follow that my use of those three words in these ways is highly contingent. A reasonable person may well look upon what I’ve done and conclude that one or all of those words is inappropriate given what I’ve actually done. I believe they’re all valid for reasons that I will explain below, but I don’t think it would be worthwhile to insist on their validity over someone else’s objections. Basically, my feelings about this aren’t strong enough to get into an argument about it.

I find what I did intellectually satisfying, and that’s good enough for me. Also, since what I did here is basically “art” in some sense, which would make me the artist, and since I usually find artist’s long-winded discussions of their own art insufferable, I don’t recommend reading the rest of this blog post either in which I reflect on and explain my art.

With those disclaimers issued, then, this post will be the first in a series (a series of at least two) in which I try and explain what I did and why. This first post is about about how. If you’d like to get straight to the book itself, you can own it for the entirely unreasonable price of $16.00 (plus shipping) from Lulu.com. I’m also planning an ebook version if you want to wait for more reasonably priced option.

Part 1: Writing

The item in question takes the material form of a book: a codex of just over 350 pages, organized into nine chapters and an appendix. The content of this book is, as you see in the video above, simply page layouts of empty panels. They’re not really empty — on page 78, for example, the lines from page 77 and 76 fill the bottom left panel with the image of a doubled cross,  copy of page 32 has a smudged fingerprint, and my page 174 includes a speckled blob and some thin, horizontal gray streaks — but you get the point.

As an idea, it’s not necessarily about the “contents” of those pages. I started with three rules, then I wrote a Perl program that would generate all of the pages following those rules.

  1. All panels are rectangles
  2. No more than 3 panels in either axis
  3. All possible space must be covered by panels

Given those constraints, how many possible layouts exist? Most of Watchmen follows this rule, for example, but it only demonstrates about 10 different variations on this. Those variations are driven by various narrative-driven pressures, so what else is possible without the same fealty to telling a story?

I asked a colleague, a mathematician, about this problem, and he confirmed that this question falls under the category of advanced combinatorics, it didn’t seem like there would be a way to express this as a straightforward formula.

Failing that, I still had to think of some way of generating these layouts, but first I needed a way to describe a layout in such a way that I could store, test, and ultimately generate that into a page. Like most things, this idea hit me while on a run. I’ve hosted the code at github if you’re interested, and I’ll try and describe it briefly here. I’m generaly not a very good programmer, I should say, but I’m pleased enough with how this script turned out that I don’t mind sharing it.

Think of it like this: Every potential grid position is a letter in a string.




There are 9 positions in a 3×3 grid, so that might look like ABCDEFGHI. A layout description uses a letter to indicate the top-left corner of a panel, then follows that with a width and height value pair.

Here are some examples following that schema:



String `A1:1B2:1D2:2F1:2`




With this method of notation in hand, I just needed to find all of the valid layouts (i.e. all those without overlapping panels), so I wrote a script that’s basically a brute force guesser plus a validator, which turned out to be fairly quick thanks to my string-based notation for coordinates. Again, it’s all spelled out and pretty thoroughly commented at github, but the basic process goes like this:

1. Pick two letters from the layout string, ABCDEFGHI.

Let’s say A and E.

2. Find the intervening points that that rectangle covers.

Bearing in mind that the grid looks like


The rectangle I’m trying to create includes letters from the top-left corner of the total grid.


3. If all those middle points are still in the string, we keep this rectangle. If not, this rectangle overlaps with one we already have, so reject it and try again.

In this case, ABD and E are all still in the layout string, so we’re good.

4. Remove the matched rectangle from the layout string so that the next guess starts on a valid corner.

That leaves us with CFGHI for the next guess.

5. Keep guessing until the layout string is empty, and then add the completed layout into a txt file of valid layouts.

This loop repeats forever, so the idea is you have to watch it until it stops finding new valid layouts. And since I don’t have the mathematical formula for describing the possible number of layouts, I’m simply waiting it until it seems to stall for a few seconds or minutes.

Having run this with a few other parameters, I do have some data which seems to hint at a pattern. If you have any insights, please let me know:

Width x Height (area) == Total Layouts
1 2 2 2
1 3 3 4
1 4 4 8
1 6 6 32
2 1 2 2
2 2 4 8
2 3 6 34
2 4 8 148
2 5 10 650
2 6 12 2861
3 2 6 34
3 3 9 322
3 4 12 3160
4 4 16 82000

* This is an approximate number. I let it run every night for a couple of weeks, and it was still finding one new layout in every 100,000 guesses or so.

Anyway, with all these layouts in hand, my next task was simply to generate the panels. I say “simply” because this was something I figured out for last year’s NaNoGenMo, a graphic novel comprised of untitled youtube videos with the randomly-derived title, The Something, The Thanksgiving, and The Nothing.

For An Arthrogram, I drew a new line (a nice dark line with a Sharpie), and I programmed it to be somewhat more variable. Putting it into panels, though, was just a matter of giving ImageMagick some coordinates and then lots of trial and error with math to get the overlap just right. That script and the PNG of my line are also on Github.

So that’s an introduction to my “book” project, An Arthrogram. I’ll write in a future post or posts about why I decided to self-publish this with Lulu and why I think this actually is a graphic novel, but for now, I wanted to get this brief introduction published before this year’s NaNoGenMo gets going.