Printing a Book at Home with Minimal Equipment

While writing a book, I wanted to get some feedback from other people on it. To make the feedback process easy, I therefore ordered a few copies at a local printing house. This wasn't too expensive so seemed like a good deal. However, after having to wait a few days on the result, it all didn't seem like such a good deal after all. Having to wait multiple days is a waste of time, as is having to order a batch for a better price. That got me thinking whether it is possible to print a book at home.

After having looked at BlueprintDIY on YouTube, it turned out not to be difficult at all. I think this is pretty cool. Especially in the current day and age where everything on the internet moves at a breakneck speed, there is some peace in just printing things out. Put differently, what is the chance that your social media posts, your backup disk, or your website are still available in 50 years? Not so high I'd guess. Even with the Internet Archive, I'm just not so sure that your data will still be there in 50 years unless you put in a lot of work. On the contrary, a book will probably still be around in 50 years. Apart from floods or fires (which could also damage a disk), there is no virus or hack that is going to destroy or modify the data.

So how to print a book at home? Here I'll present a very simple approach that requires almost no equipment. Only paper, a printer, glue, and a paper cutter.

To my surprise, this actually worked pretty well. I'm still tweaking the process a bit, but printing your own books seems pretty easy. Even with my basic equipment, it takes me no more than 30 minutes to create a book that works. It "works" just like any other book, namely you open it and you read it.

For this example, I took a file I had for the book Bushido: The Soul of Japan by Inazo Nitobé. This book was originally published in 1908 so it is in the public domain. I already had converted this book into Typst a while ago, but you could use also other sources. The PDF can be downloaded here and the Typst source code for the book here. I set the page to A5 with 2 cm margins on all sides.

For the big picture, the idea of printing a book here is to print two A5 pages next to each other on one A4 page (the default size for my printer). Later, I cut the pages in half to get the two A5 pages.

To convert normal PDFs into a PDF that contains A4 pages with two pages next to each other, I wrote the following Python script

# Created venv with `uv venv`
# `source .venv/bin/activate.fish`
# Then `uv pip install pypdf==5.7.0`

import os
import subprocess
import sys
from pypdf import PdfReader, PdfWriter, PageObject, PaperSize
from pypdf import Transformation


def num_pages(filename):
    reader = PdfReader(filename)
    return len(reader.pages)


def ceildiv(a, b):
    return -(a // -b)


def scale_page(page: PageObject):
    page.scale_to(height=PaperSize.A4.width, width=PaperSize.A4.height / 2)


def join_pages(left: PageObject, right: PageObject):
    new = PageObject.create_blank_page(width=PaperSize.A4.height, height=PaperSize.A4.width)
    # right.scale_to(height=PaperSize.A4.width, width=PaperSize.A4.height / 2)
    scale_page(right)
    new.merge_page(right)
    op = Transformation().translate(tx=PaperSize.A4.height / 2, ty=0)
    new.add_transformation(op)
    scale_page(left)
    new.merge_page(left)
    return new


def blank_page():
    return PageObject.create_blank_page(width=PaperSize.A4.height / 2, height=PaperSize.A4.width)


def convert_to_zero_based(index):
    """
    The math is 1-based while the indexes in the PDF are 0-based.
    """
    return index - 1


def main():
    if len(sys.argv) < 1:
        print("Expected basename (without .pdf) as first input argument")

    basename = sys.argv[1]

    command = ["typst", "compile", basename + ".typ"]
    result = subprocess.run(command, capture_output=True, text=True)

    if result.returncode == 0:
        print("Generated document succesfully\n")
    else:
        print("Command failed with return code:", result.returncode)
        print("Error:", result.stderr)
        exit(1)

    n = num_pages(f"{basename}.pdf")
    print("n:", n)
    half = ceildiv(n, 2)
    # If n is odd, we need to add one since we printing duplex.
    # Can lead to 3 empty pages in the worst case.
    half = half if n % 2 == 0 else half + 1
    print("half:", half)

    reader = PdfReader(f"{basename}.pdf")

    even = PdfWriter()
    print()
    print("----- back -----")
    for i in range(ceildiv(half, 2)):
        print("i:", i)
        # half + 2 : 2 : n
        left_index = (half + 2) + (2 * i)
        print("left_index:", left_index)
        # 2 : 2 : half
        right_index = convert_to_zero_based(2 + (2 * i))
        print("right_index:", right_index)
        left = reader.pages[left_index] if left_index < n else blank_page()
        right = reader.pages[right_index]
        # Flip since we're printing on the back of the odd pages.
        joined = join_pages(right, left)
        even.add_page(joined)
        print()

    print("----- writing back.pdf -----")
    even.write(f"back.pdf")
    print()

    odd = PdfWriter()
    print("----- front -----")
    for i in range(ceildiv(half, 2)):
        print("i:", i)
        # half + 1 : 2 : n
        left_index = (half + 1) + (2 * i)
        print("left_index:", left_index)
        # 1 : 2 : half
        right_index = convert_to_zero_based(1 + (2 * i))
        print("right_index:", right_index)
        left = reader.pages[left_index] if left_index < n else blank_page()
        right = reader.pages[right_index]
        joined = join_pages(left, right)
        odd.add_page(joined)
        print()

    print("----- writing front.pdf -----")
    odd.write(f"front.pdf")
    print()


if __name__ == "__main__":
    main()

Here, the script creates two files namely front.pdf and back.pdf. I do this because in my aim for being cheap, I ordered a printer that cannot do double-sided printing. The idea of these two PDFs is that you first print front.pdf, then manually rotate the stack around and then print back.pdf. If you have a double-sided printer, you can modify the script so that all pages end up in one PDF.

After running this script on bushido.pdf, the output before rotating looks as follows:

Then rotate and feed it in and print the other PDF.

Next, the pages should be cut in half. I am here using a very basic paper cutter that cost me €28. Unfortunately, this cutter can only cut about ten pages at the same time, so for big books it works, but is a bit laborious.

This gives two stacks:

Now you can put the left stack on top of the right and continue with the cover.

For the cover, I have used a cardboard paper of 300 g/m² (make sure that it's not too thick for your printer). In Google Docs, I quickly hacked a front cover together which then looks as follows:

To put the pages into the cover, you have to pre-fold the cover. This is the trickiest part. You could measure this all out very meticulously, but what I did here was to take one of the A5 pages, put it on top of the cover and then slide it to the outside by half the width of the stack. Now the left side of the A5 that you slid to the side is the location where a fold has to occur:

And make another fold so that the stack of pages has enough space:

Next, I took a bit of very basic glue and put it on the cover:

And pressed the stack of pages into the cover and let it dry for a few minutes. That gives the following end result:

Yes, I messed up the centering on the front cover here which I'm going to blame on my laziness and in particular Google Docs being weird.

Also, you notice that the inside stack is now sticking out of the outside. For a review version, this should be fine. You could with a lot of fiddling probably get this correct. If you want a more neat version, however, you'll probably want a stack cutter. That's essentially what printing houses do, you make sure you have a cutter that can cut all pages at once and then cut once at the top, bottom, and right. That way, the whole book looks neat. As long as you have enough margin on the pages, you can freely cut of some of the outside.

Anyway, let's take a look at the inside:

That's it. I've already printed a few books like this and so far it works fine. It read just like any other book.

For the future, I'm planning to experiment a bit with other page thicknesses. I currently find the bleed-through a bit annoying. It works but I personally don't like it so much. Also, the cover currently has a tendency to curl up, so I need to find another paper type for that. And I've already ordered a stack cutter which I expect is going to improve the appearance of the result a lot.

The total costs for printing a book of 125 pages, excluding my time, is now about €0,80. €0,60 for the paper and the rest for a bit of ink, glue and the cardboard paper.

Hopefully this was an interesting tutorial. Let me know if you have any feedback or suggestions.