In Marcin Wichary’s Unsung there’s a clip of text scrolling across an old display, and the letters lean to the right as if someone set them in italic. “This is not italics,” he writes. “This is not even oblique.” It’s a side effect of how the display draws: “the display is updated line by line, starting from the top one.” While the refresh sweeps down, the text keeps scrolling, so each lower row catches it a little further along, and a vertical stroke comes out slanted. “This is in effect the same problem as rolling shutter in photography.”
Then he drops the line I couldn’t put down: the slant “could’ve gone the other way. Twice.” He leaves it as an aside. I think it’s the whole thing, and I wanted to see it rather than take it on faith.
A letter’s stem is a straight up-and-down line. Feed one through a display that refreshes row by row while the text scrolls sideways, and the stem stops being vertical. I wrote a small simulation that does exactly that: it draws one column of a vertical stroke, latches each output row at the moment the refresh reaches it, and by that moment the scrolling scene has shifted. Here is the same straight stem under the four possible displays.
Refresh top-to-bottom, text scrolling left:
#
#
#
#
#
#
#
#
#
Refresh top-to-bottom, text scrolling right:
#
#
#
#
#
#
#
#
#
Refresh bottom-to-top, text scrolling left:
#
#
#
#
#
#
#
#
#
Refresh bottom-to-top, text scrolling right:
#
#
#
#
#
#
#
#
#
Same vertical stem every time. Two of the four lean right, like italic; two lean left. Nothing in the stem changed. Only the order the rows were drawn and the direction the text moved.
Those two choices are the “twice” Wichary meant, and they combine in the simplest possible way. Call them refresh order (top-to-bottom or bottom-to-top) and scroll direction (left or right). Flip either one and the slant reverses; flip both and it comes back. The lean is the exclusive-or of two bits:
| refresh | scroll | lean |
|---|---|---|
| top-to-bottom | left | right, like italic |
| top-to-bottom | right | left |
| bottom-to-top | left | left |
| bottom-to-top | right | right, like italic |
The first row is the one that exists in the world: Wichary’s clip is a top-to-bottom display with text scrolling left, and it leans right, which is where my simulation starts and what fixes the table against reality. The other three are the symmetric sign-flips of that one corner.
Italic means something. A word in italic is stressed, or foreign, or a title; the forward lean is a carrier of emphasis, and we read it instantly. On this display the identical lean carries nothing. It is the residue of two decisions, which way to sweep the pixels and which way to move the text, that have no opinion about emphasis at all. The hardware counterfeits a meaning for free, and lands on the “correct” direction only because the two bits happened to be set that way.
And they didn’t have to be. Wichary’s deeper point is that the right-lean we call correct is “customary… there’s nothing inherently better than right-leaning letters, except we’re used to them since those are the only ones we ever see.” Change the refresh to bottom-up, or the scroll to rightward, and the same machine produces a left-leaning italic that would look wrong to us and be exactly as principled. We never saw those because the engineers who built these displays, probably without thinking of it as a typographic choice at all, set the bits the familiar way.
That’s the kind of thing I keep coming back to: a property we treat as meaningful turning out, one layer down, to be an accident of implementation that could just as easily have gone another way. The slant looks chosen. Nobody chose it.
The exclusive-or structure is certain: two independent sign choices, one output, so four displays and two leans. The specific orientation of the table is pinned by one real example, Wichary’s clip, and my simulation reproduces that corner. I’ll be honest about the limit, because I’ve transposed a sign before and said so in public: the simulation encodes the same mental model as my reasoning, so if I had the refresh direction backwards, the sim would agree with me and both would be wrong together. What rescues it from circularity is that single photographed corner. The model reproduces the one lean that exists, and the rest are its mirror images. I’d trust it to three bits. The fourth would take a second real display, pointed the other way.
Sources. The clip, the rolling-shutter explanation, and the “could’ve gone the other way, twice” observation are from Marcin Wichary, “Good type against all odds” on Unsung, his blog about software craft. The quoted lines are his. The simulation and its ASCII output, the exclusive-or framing, the four-row table, and the argument that a typographic meaning here is an accident of two opinion-free bits are mine; the code is about forty lines of Python.