Imposition, by Script

There is a moment in every small-press project when you hold a stack of freshly printed sheets and realise that page one is on the back of page eight. The reader will never see this. A folded book hides its own arrangement, like a coat hiding its lining, and the craft of getting the lining right has a name from the print shop: imposition.

I learned it the cheap way, by ruining a ream. This essay is the cheaper way for you.

The problem, stated plainly

Take a sheet of paper and fold it once. You now have four pages: a front cover, an inside left, an inside right and a back. Nest a second folded sheet inside the first and you have eight pages. Nest a third and you have twelve. This is a saddle-stitched booklet, the kind with staples or a single thread down the spine, and it is the humblest structure in bookbinding.11Strictly this is a nested binding. Larger books use many small nests, called signatures, sewn one to the next, which is the subject of the series linked at the end.

The trouble comes when you want to print it. Each sheet carries two pages on one side and two on the other, and a printer wants each side as a single flat page. Page 1 does not sit next to page 2. It sits next to the last page of the booklet.

Look at the figure for a minute and the pattern appears. On every side, the two page numbers add up to one more than the total. Eight and one. Two and seven. Six and three. Four and five. That is the whole secret, and the rest is bookkeeping.

A dozen lines

The bookkeeping, in Python:

def booklet(pages: int) -> list[tuple[int, int]]:
    """Left and right page numbers for each printed side."""
    if pages % 4:
        raise ValueError("a folded booklet needs a multiple of four pages")
    sides = []
    for sheet in range(pages // 4):
        sides.append((pages - 2 * sheet, 2 * sheet + 1))      # front
        sides.append((2 * sheet + 2, pages - 2 * sheet - 1))  # back
    return sides

def pad_to_four(pages: int) -> int:
    return -(-pages // 4) * 4

for n, (left, right) in enumerate(booklet(pad_to_four(10)), start=1):
    print(f"side {n}: {left:>2} | {right:>2}")

Feed it ten pages and it pads to twelve, because a folded booklet cannot be ten. The output is the order in which to place your pages:

side 1: 12 |  1
side 2:  2 | 11
side 3: 10 |  3
side 4:  4 |  9
side 5:  8 |  5
side 6:  6 |  7

Pages 11 and 12 do not exist, so those slots are left blank. A blank back cover is a perfectly good thing to have.22Printers call these slots “blanks” and are mildly superstitious about them. A traditional hand compositor will not let the final blank be used for advertising, on the grounds that the book has earned a rest. I now keep the function in a file beside my layout notes and run it before I have typed a word of the booklet, because the page count decides everything else: the stitching, the paper weight, the width of the spine.

Why I bother

You can, of course, buy software that does this. Most word processors have a “booklet” print option buried somewhere, and it works. But I find that the thirty minutes spent writing the thing out by hand are what make the structure stick. After the second time I could look at any folded pamphlet in a shop and know, roughly, how many sheets were inside and how they were nested, the way a carpenter looks at a table and sees the joints.

There is a practical gain too. Once the order is a function, it becomes a parameter. Last month a friend asked for a thirty-two page poem collection. I changed one number, printed a proof on the cheap paper, folded it at the kitchen table and read the whole thing in the right order before a single good sheet was touched. The proof had two pages upside down. I would have found that out on the real sheets.33The usual culprit is the back of each sheet, which has to be flipped on the short edge or the long edge depending on your printer. Print one test sheet and check before committing paper.

What it taught me about books

The imposition scheme is one of those rules that disappears once you have it. It also made me read ordinary books differently. Open the next paperback you pick up and look at the spine from above: you can see the signatures, the little bundles of folded paper, stacked like slices. Each one was once a single sheet with sixteen pages arranged in an order that looks random until you know the rule, and each rule ends with the same sum.

If you want to know what happens after the sheets are printed, the three-part series that begins with Folding the Signatures follows one small book from loose paper to finished cover. The code above stays where it is. Use it freely; it has no licence and no opinions, which is more than I can say for most software.