By	Casey Muratori

Recently, I helped with the prepress work for Meow the Infinite. I wrote up the experience in a Molly Rocket news feed post. Doing the prepress properly involved learning a bunch of interesting stuff about printing presses. OK, that’s a lie. It didn’t really involve learning a bunch of interesting stuff about printing presses. I learned a bunch of interesting stuff about printing presses unnecessarily. The more you learn about these things, the more you realize how awesome they are, and you want to keep going. If you go read the post on prepress work, you might learn something useful if you yourself want to do prepress work. By constrast, this post here has zero practical information in it. It is literally just a list of ways that printing presses are like GPUs. There’s no point to it whatsoever, except to try to impress upon the uninitiated just how cool modern printing presses are.

Now, it may seem like I want to analogize presses to GPUs because I just happen to program GPUs. As the saying goes, “If the only tool you have is an analogy to a hammer, every problem looks like a story about nails.” I don’t disagree. That is probably exactly what’s going on here. But if Buzzfeed can make lists of things that nobody cares about, so can I. In fact, now that I said that, the hell with it, I’m going all in on the Buzzfeed formatting:

No really, they do. And the frame rate can be fixed or variable, just like on a GPU! It just depends on whether it is a web press or a sheet-fed press. A web press is a press where giant rolls of paper are fed directly into the press, and at no time does the press ever actually operate on an individual sheet of paper until the very end. For these presses, the frame rate is measure in feet per second, and is fixed. You can’t slow down the work on one specific render target (a sheet-sized section), because everything is a single continuous feed, and it runs at a constant rate. A sheet-fed press, on the other hand, operates on individual cut sheets. They do not have to move through the press at a resolved rate (although they might), and in fact, any individual part of the process can be as fast or as slow as necessary.

Many presses render four channels per pass, just like a GPU. The press has individual inking assemblies that operate in series to transfer four different inks (or alternatively, coatings) to the paper as it moves through the press. However, much like higher-end GPUs, large presses might also be able to write more than four channels per pass, as the only constraint is how many inking assemblies are laid out in series. Special effects “channels”, like glossy coatings, can be applied using extra assemblies that come after the standard inks. Sheet-fed presses can even use multi-pass rendering. Because they do not operate on a continuous feed of paper, sheets from one pass through the press can be rerouted and fed back into the press to apply another round of inking. To a certain extent, you could even say web offset presses are multi-render-target in a single pass. They apply ink to both sides of the paper feed at the same time, writing two separate images simultaneously.

Remember back when texture changes were really expensive, and the GPU could only read a few textures at once? Well, modern printing presses are exactly like that. Modern presses get source images via physical, deformable “plates” that wrap around cylinders. As paper moves through the press, these plates transfer their images onto the paper, usually through an indirect process involving chemicals and intervening rollers. In order to start printing, the plates must be loaded onto the cylinders. Once they are, the press can operate at full speed, but it can only print the set of pages that are laid out on that particular set of plates. In order to print a different set of pages, the press must be halted and the old plates swapped for the new ones. I’m still curious as to whether anyone makes a press that can hot-swap the plates. For sheet-fed offset presses, it wouldn’t make much sense, because if maximum throughput was your goal, you’d probably be using a web offset press. But for web offset presses, which are designed to run continuously, it seems like it would be desirable. I’ve yet to find anything that mentions such a feature. It would be difficult to build, since the plates must be registered precisely, and to avoid wasting paper, it would have to mechnically swap in as quickly as possible. But given how many ridiculous mechnical assemblies already exist in modern offset presses, this would hardly be the most surprising thing to see!

Much like GPUs have stages of processing that cannot proceed until earlier stages have completed, presses do too. For example, heat-set inks like the kind used in web offset presses must be heated for a specific amount of time in order to set, and the paper cannot be manipulated until it does. To accomodate this, heat-set presses are designed to feed paper through a long, thin oven such that the total amount of time it takes the paper to get from one end to the other is sufficient to ensure the ink is set.

It’s kind of ridiculous how accurate offset presses can be, especially when you consider that web presses are operating on paper at speeds of several feet per second. At least four inks have to be laid down with precise calibration in order for the result to avoid color fringing. So much like we might run captures on a GPU to see what’s going on in the process, high-end presses have high-speed cameras that photograph specific spots in the pipeline and feed the results to operator terminals for analysis.

If that’s not enough to convince you that presses are like giant GPUs, I don’t know what is. But one thing you could try is watching this video of high-end web press operating at full speed:

It shows all of the elements I mentioned, as well as the crazy machinations that happen to separate page streams and interleave them into signatures. And yeah, I tried to analogize that to the part of the GPU that sequences frames onto the HDMI cable. But even I thought that was reaching a little bit. Maybe someone more intrepid can try to analogize it to memory routing and crossbars!