How Letters Became Software

Every piece of text you have ever read on a screen passed through a stack of decisions made between 1041 and 2016. The shape of the letters came from a file format designed to avoid royalty payments. The way accents sit on Vietnamese vowels comes from a 1991 decision to separate what a character is from how it looks. The smoothness of the curves comes from mathematics a Citroën engineer was forbidden to publish. And the whole thing still runs on an assumption cast in lead five and a half centuries ago: that text is rectangles sitting on a common line.

The history of type is usually told as a parade of machines. Told that way it is trivia. Told as a sequence of answers to one question, it becomes an engineering case study with direct lessons for anyone building software today. The question is: what is a letter? Every era answered differently, every answer froze assumptions into the infrastructure, and every following era spent its first decade breaking the assumptions of the last. The people who paid for the frozen assumptions were rarely the people who froze them. Mostly, the bill went to the two-thirds of humanity whose scripts behave nothing like Latin.

This essay walks through the six answers. It carries real numbers, one worked calculation, and citations to primary sources, because the standard tellings of this story repeat each other's errors. It was prompted by Simon Cozens' fine chapter on the same subject [1], which is worth reading and which this essay tries to out-cover in three specific places: the four hundred years between Gutenberg and the Linotype, the economics of why East Asia's two-century head start went a different way, and the ending, in which the hardest script in the world finally got its font.

Twenty dates that explain the whole story

Every claim in this essay is argued out in full below. This table is the reference version: one row per date, one citation per row, checkable in thirty seconds. Copy it, screenshot it, or link straight to this table; a suggested citation for the essay itself is at the very end.

The letter as an object

The first answer: a letter is a physical thing you can hold, and printing is arranging thousands of them into a mirror image of a page.

The answer was given in China, in the 1040s. An artisan named Bi Sheng, a commoner about whom almost nothing else is known, made letters from fired clay and set them in wax on an iron plate. We know this because the scholar-official Shen Kuo described the system in careful technical detail in his Dream Pool Essays, dating it to the Qingli era, 1041 to 1048 [2]. Wooden and then bronze type followed. In July 1377, at the Heungdeok temple in what is now Cheongju, Korea, a Buddhist anthology called Jikji was printed with cast metal type. The surviving second volume, held at the Bibliothèque nationale de France, is the oldest extant book printed with movable metal type, and UNESCO certified it as such in 2001. It precedes the Gutenberg Bible by 78 years [3].

So Gutenberg invented movable type roughly the way Columbus discovered America: for Europe [4]. His contribution is real, but it is a systems contribution, and naming it precisely matters because the system, not the idea, is what conquered the world. Around 1450 in Mainz he assembled four components. A steel punch with the letter carved on its tip, struck into a block of copper to make a matrix. A two-part adjustable hand mould, described by the International Gutenberg Society as the one element of the process for which no existing model existed, into which the matrix clamps [5]. A type-metal alloy, mostly lead with tin and antimony, whose useful property is that it solidifies the moment it fills the mould, so a caster could pour identical letters one after another all day [5]. And an oil-based ink that would stick to metal. The output of the system was the sort: a rectangular block of metal, one letter on its face, cast to a uniform height, designed to sit in a row against its neighbours on a flat bed. The Bible was completed around 1455 [6].

Hold that image of the sort. A rectangle, letter on top, lined up on a common baseline with its fellows. It is the single most durable design decision in this whole story, and it is still inside your phone.

The obvious question is why the technology exploded out of Mainz in fifty years after sitting in East Asia for four hundred. The romantic answers involve culture and imagination, and the scholarship does not support them. The economic answer is arithmetic. A full set of punches for a Latin book face is on the order of a couple of hundred: two alphabets, numerals, punctuation, some ligatures. Cast as many sorts of each as you need and you can print anything ever written in the language. A Chinese fount needs distinct types on the order of tens of thousands, most of which will be used once or never, and all of which must be filed, retrieved, and refiled by literate workers. A recent economic analysis by Luis Angeles at Glasgow models the choice and finds that Chinese commercial printers preferring carved woodblocks over movable type was the rational decision given the writing system, with movable type predicted to win only for enormous projects such as printing the Buddhist canon, which matches the historical record of when it was used [7]. The lesson generalises and this essay will need it twice more: a technology's fit to a script is an economic property, and the script with the smallest symbol inventory sets the design of the machine. Latin's 26 letters have been quietly subsidising the design of text technology ever since.

The bottleneck was never the press

Here is the part the popular histories skip, including, mostly, Cozens' chapter: for four hundred years after Gutenberg, the press got faster and the composing room barely moved. By the nineteenth century, steam presses could print tens of thousands of sheets a day, and in front of each one stood rows of human beings picking rectangles out of wooden cases one at a time. A skilled hand compositor sets at most about 2,000 characters per hour [8]. Every character on every page of every newspaper on Earth passed through someone's fingers twice, once into the page and once back into the case afterward.

Ottmar Mergenthaler's Linotype broke the bottleneck, and it is worth being precise about how, because the mechanism is a beautiful piece of systems thinking. The machine does not store type. It stores matrices, the moulds, on a 90-key keyboard-driven magazine. The operator types; brass matrices fall into a line; wedge-shaped spacebands drop between words; when the line is nearly full, the machine drives the wedges deeper until the line is exactly justified, then casts the whole line as a single fresh slug of hot metal, and afterward the matrices are automatically sorted back into the magazine while the operator types the next line [9]. Casting fresh each time means no worn type and no redistribution labour. The line-at-a-time output is where the name comes from: a line o' type.

The New York Tribune ran the first Linotype-set matter on page four of its issue of 3 July 1886, and printing historians can identify which stories, because a single wrong-font boldface apostrophe gives the machine away in three of them [10]. Semi-automatic hot-metal machines reached 9,000 characters per hour and automatic ones 12,000, against the hand compositor's 2,000, a factor of four and a half to six [8]. Tolbert Lanston's rival Monotype, developed in the same decade, cast individual characters instead of whole lines, which made corrections cheaper and won it the book trade while the Linotype took the newspapers.

Two things about hot metal matter for everything downstream. First, it made text keyboardable: from 1886 onward, a letter is something you type, and the mapping from keystroke to printed shape is the machine's business. Second, justification, the even right margin, became a mechanical afterthought, wedges pushed until the line fills. Gutenberg's compositors had justified pages by choosing among abbreviations, ligature forms, and letter variants with human judgment across the whole paragraph. The wedge is faster and worse, and the regression it introduced has still not been fully repaired. Section eleven returns to this.

The letter as a photograph

The second half of the twentieth century replaced metal with light, and the episode deserves more than the single paragraph it usually gets, because it contains the clearest cautionary tale in the whole history.

In 1946, two French engineers, René Higonnet and Louis Moyroud, prototyped a machine that set type by photographing character images from a spinning glass disc onto film [11]. Their Lumitype, later sold as the Photon, carried discs holding sixteen fonts, and with twelve point sizes selectable through optics, one disc replaced cases of lead type that weighed tons [11]. The first book composed on it appeared in 1953 [11]. Through the 1960s and 70s, phototypesetting swept the industry; the composing room shrank from a machine hall full of molten metal to a cabinet.

The cautionary tale is inside the optics. A metal typeface was cut size by size: the 8-point master and the 36-point master of the same face were different drawings, the small one wider, sturdier, more open, because centuries of punchcutters had learned what small sizes need. The phototypesetter took one master image and enlarged or reduced it with a lens. Cheaper by far, and visibly worse: text sizes set from a display master look thin and cramped, display sizes set from a text master look clumsy. The trade knew this at the time and shipped it anyway, because one master per face is an order of magnitude cheaper than a dozen. Digital fonts then inherited the one-master-scaled-by-arithmetic model wholesale, and the craft knowledge of size-specific design spent forty years in exile as a premium feature called optical sizes, returning as a standard capability only with variable fonts in 2016. An engineering economy chosen in the 1950s set the default quality of print for two generations. Frozen assumption, long bill.

The last machines of this era already had one foot in the next. The Linotron 202 of 1978 stored character shapes digitally as outlines and painted them onto a CRT for exposure [1]. Among the people doing serious work on such machines was Fiona Ross, whose team at Linotype used the new flexibility to build Bengali composition that hot metal had served badly [1]. Digital flexibility helping a non-Latin script first, before the formats hardened around Latin again, is a small preview of the fight in section nine.

The letter as a grid of pixels

Computers entered the story from a different door, and with a much cruder answer: a letter is a small rectangle of on-and-off dots. The IBM 2260 video terminal of 1964 generated its characters from hard-wired dot patterns; there was no font in the machine, there was circuitry per glyph [1]. Bitmap fonts, character shapes stored as pixel grids, made letters into data, but data with two crippling properties: they exist at exactly one size, and they scale in memory with resolution squared. Every size and weight is a separate hand-placed set of grids. A bitmap is a metal sort with the metal removed and the constraint retained.

Cozens makes an argument about this stage that deserves both repeating and crediting: the leap from rectangular metal sorts to rectangular character cells carried Gutenberg's deepest assumption straight into computing, that text is boxes of a fixed height aligned along a shared baseline [1]. For Latin, Cyrillic, Greek, and passably for Chinese, boxes on a line describe the writing. For the Nastaliq style of Perso-Arabic script, in which words cascade diagonally down and to the left with letterforms chosen by context, the assumption is false at the level of geometry itself. The rectangle was cast into lead in 1450, wired into terminals in 1964, and standardised into every font format since. Much of sections nine's drama is the slow, expensive purchase of exceptions to it.

The letter as an outline

The escape from the pixel grid came from Hamburg, from an engineer whose account of the moment survives in his own words. Peter Karow of URW began generating letterform variants programmatically in early 1973; he dates the birth of the digital typeface to 26 February 1973, when his software first produced contoured and shadowed versions of a hand-digitised outline automatically [12]. His system stored each glyph as points on its outline, with curve segments built from circular arcs, and, crucially, could interpolate: given a light master and a bold master, it computed the weights between. He named the software IKARUS in 1974, by his own telling because of how often it crashed, and introduced it publicly at the ATypI conference in 1975, in Warsaw [12][13]. File away the city; it returns at the end of this story with a symmetry too good to invent.

An outline is the correct abstraction, and it is worth stating why in one sentence: an outline stores the shape, from which any size at any resolution can be computed, whereas a bitmap stores one rendering and forgets the shape. IKARUS became the production standard inside foundries, quietly converting the world's metal-era typefaces into coordinates; its IK format could later be compiled into every commercial format that followed [13].

The same years produced a stranger and grander attempt. Donald Knuth's METAFONT, begun in 1977 alongside TeX and rebuilt in 1984, described letters not by their outlines but by programs: parameterised pen strokes swept along mathematical paths, so an entire typeface family flows from a few dozen numbers [14]. It is the most intellectually complete answer to "what is a letter" anyone has given, and it lost, for two reasons that matter to anyone designing tools for experts. Type designers think in outlines, the contour of the finished shape, and METAFONT demanded they think in skeletons and pens, a model at odds with how the craft's knowledge is stored. And its programs demanded mathematical fluency the profession had no reason to possess. A representation that is more powerful and less aligned with its users' mental model loses to a representation that is less powerful and aligned. IKARUS's dumb points on a contour won.

Four points that replaced a drawer of film

The outline needed better mathematics than circular arcs, and the mathematics came from car factories. In 1959, Paul de Casteljau at Citroën developed an algorithm for evaluating polynomial curves from control points; Citroën treated it as a trade secret and he could not publish [15]. Pierre Bézier at Renault, working slightly later on the UNISURF body-design system, could publish, which is why the curves carry his name and not de Casteljau's [15]. The mathematics is the one place this essay will slow down and work an example, because it is genuinely simple, and because it is the exact computation that runs, billions of times a day, under every glyph you read.

A cubic Bézier curve is defined by four points: two endpoints, P₀ and P₃, which the curve touches, and two control points, P₁ and P₂, which it approaches but does not reach. The curve is

B(t) = (1−t)³·P₀ + 3(1−t)²t·P₁ + 3(1−t)t²·P₂ + t³·P₃      for t from 0 to 1

P₀, P₃   endpoints, on the curve
P₁, P₂   control points, off the curve
t        how far along the curve you are, 0 = start, 1 = end

The four coefficients always sum to 1, so B(t) is a weighted average of the four points, with the weights sliding from all-P₀ at t = 0 to all-P₃ at t = 1. At the midpoint, t = 0.5, the weights are ⅛, ⅜, ⅜, ⅛.

Take a concrete quarter-bowl of a letter o, in font units: P₀ = (0, 0), P₁ = (0, 55), P₂ = (25, 100), P₃ = (80, 100). de Casteljau's algorithm finds the midpoint of the curve with nothing but averaging. Take the midpoint of each edge of the control polygon:

A = midpoint(P₀, P₁) = (0, 27.5)
B = midpoint(P₁, P₂) = (12.5, 77.5)
C = midpoint(P₂, P₃) = (52.5, 100)

Then the midpoints of those:

D = midpoint(A, B) = (6.25, 52.5)
E = midpoint(B, C) = (32.5, 88.75)

And once more:

F = midpoint(D, E) = (19.375, 70.625)

F lies exactly on the curve. Check it against the polynomial with the ⅛, ⅜, ⅜, ⅛ weights:

x = 0.125·0 + 0.375·0  + 0.375·25  + 0.125·80  = 19.375   ✓
y = 0.125·0 + 0.375·55 + 0.375·100 + 0.125·100 = 70.625   ✓

The construction has a property that makes it more than a party trick: the six points it produces, P₀ A D F and F E C P₃, are themselves the control points of the curve's two halves. Split, split again, and within a few levels each fragment is flat enough to draw as a straight line. That recursive halving, requiring only additions and divisions by two, is how an outline becomes pixels, and it is numerically stable in a way the raw polynomial is not. A letter, from 1984 onward, is a list of four-point curves plus an algorithm cheap enough to run inside a printer.

The delivery vehicle for that idea was PostScript. John Warnock and Chuck Geschke left Xerox PARC, where their page-description work had stalled, founded Adobe in 1982, and shipped PostScript in 1984 as a full programming language for pages, with fonts as cubic-Bézier outline programs [16]. Its second key idea was hinting: small declarative annotations in the font telling the rasterizer which stems must stay equal and where the critical alignments are, so that outlines survive the violence of being crushed onto a 300-dot-per-inch grid. Print quality typesetting from a desktop box, with Apple's LaserWriter as the carriage, created desktop publishing and ended the phototypesetting industry inside a decade.

The font wars and the merger that ended them

Adobe then made the move that shaped the next fifteen years: it published the PostScript language but kept the high-quality font format, Type 1, encrypted and proprietary, with the hinting secrets held close. Anyone could build a PostScript interpreter; only Adobe could sell fonts that rendered beautifully on it, and every serious font purchase paid Adobe [16]. Microsoft's own history of the period is blunt about the response: TrueType was designed by Apple as a means of avoiding per-font royalty payments and as a fix for Type 1's technical limits [17]. Apple and Microsoft, otherwise at war, allied; TrueType shipped in Mac System 7 and Windows 3.1, and the industry split into two incompatible outline formats, a period contemporaries called the Font Wars [16]. Adobe responded by publishing the Type 1 specification and shipping Adobe Type Manager, which rendered Type 1 on screen and defused the immediate threat.

The two formats differ in their mathematics in a way that still confuses working developers, so here is the two-sentence version. Type 1 uses cubic Béziers, four points per curve; TrueType uses quadratics, three points, which rasterize faster on 1990 hardware. Every quadratic has an exact cubic equivalent, obtained by placing the cubic's two control points two-thirds of the way from each endpoint toward the quadratic's single control point, so converting TrueType outlines to cubic is lossless, while the reverse requires approximation. (This essay's verification script checks the equivalence numerically; the two forms agree to floating-point precision.)

The wars ended in a merger of formats rather than a victory. In 1996, Microsoft and Adobe, later joined by the others, defined OpenType: one file wrapper that can carry either flavour of outline, TrueType's quadratics or Adobe's cubics in a compacted form, together with a new machinery of layout tables [18]. The wrapper diplomacy mattered less than the layout tables, which are the subject of the next section, because they are where the letter stopped being a shape at all.

The letter as a program

Everything so far, metal, film, pixels, outlines, shares an unexamined assumption: one character, one shape. Type an a, get the a shape. For Latin the assumption merely loses you ligatures and small caps. For most of the world's scripts it is false at the root. Arabic letters take different forms depending on their position in the word, joined to their neighbours. Devanagari and the other Indic scripts reorder: vowel signs typed after a consonant can render before it, and consonant clusters fuse into conjuncts. Vietnamese, the script this blog's home country reads every day, stacks a tone mark on top of a vowel that may already carry a quality mark, and ế, ữ, ồ need the stack placed per letterform, not slapped at a fixed offset where it collides with the vowel's existing diacritic. Every one of these behaviours had been handled effortlessly by scribes for a millennium and became a "hard problem" only when technology froze the one-character-one-shape assumption into formats.

Two decisions unfroze it. The first was Unicode, whose version 1.0 in 1991 drew a line that reads like philosophy and functions like load-bearing engineering: Unicode encodes characters, units of textual identity, and refuses to say anything about glyphs, the visible shapes [19]. The Arabic letter beh is one character regardless of which of its four contextual forms appears; which form appears is explicitly not the character encoding's problem. That refusal created a gap in the architecture, a place where something must translate a sequence of characters into a positioned sequence of glyphs.

The second decision was to fill that gap with a program stored inside the font. OpenType's GSUB and GPOS tables are rule systems, substitute this sequence of glyphs with that one in this context, move this mark relative to that base, and the font's designer writes the rules. A piece of system software called a shaping engine executes them. The font stopped being a box of shapes and became a box of shapes plus the code that chooses and places them. This is the precise sense of this essay's title: the letter is now the output of a program, and the program ships inside the font file.

The shaping engines themselves have a history worth compressing into a paragraph, because it is a rare clean win for open source in critical infrastructure. Each platform first built its own: Microsoft's Uniscribe, Apple's AAT (descended from the technically brilliant, commercially failed TrueType GX), SIL's Graphite for minority scripts the big vendors would not fund. Then a shaping library that had begun as code extracted from FreeType and Pango, named HarfBuzz, the Persian word for the calligraphic style also called naskh, was rewritten from scratch starting in 2006 by Behdad Esfahbod; by 2012, after a run of cross-company hackfests, Pango, Chrome, and ChromeOS had switched to it [20]. Today HarfBuzz shapes text for Android, Chrome, Firefox, Linux, LibreOffice, and much else. The reference implementation of the world's writing systems is a free library maintained in the open, which means a script community can fix its own rendering rather than petition a platform vendor, and that single fact has done more for digital script equality than any standard.

Which brings the story back to Nastaliq, the hanging Perso-Arabic style that section four called geometrically incompatible with the rectangle-on-a-baseline model. Cozens' chapter illustrates the problem with a Nastaliq specimen captioned, in full, "No OpenType for you!" [1]. The caption was fair when written and it has aged into the best kind of obsolescence. Google's Noto Nastaliq Urdu ships as an ordinary OpenType font, its cascading geometry achieved through thousands of contextual substitution and positioning rules that push the format to its edges, and the currently maintained build of the Noto Nastaliq sources lists, as its top contributor, Simon Cozens [21]. The man who wrote the joke went and closed it. The rectangle assumption of 1450 was never repealed; it was bought out, rule by rule, by people who cared enough to write the rules. That is usually how frozen assumptions die in real systems: not by rewrite, by patient purchase.

The letter as a parameter space

The sixth answer to the question was given twice, and the second time it stuck.

Typeface families had always been discrete: a regular, a bold, an italic, each a separate design, each a separate file. Adrian Frutiger's Univers of 1957 organised its 21 members into a numbered two-axis grid of weight and width, which is a family conceived as a coordinate system, but still shipped as 21 separate fonts. Karow's IKARUS had interpolated between masters inside the foundry since the 1970s [12]. Adobe took the idea to end users in 1991 as Multiple Master fonts, Type 1 fonts carrying several masters and the ability to blend them on demand. The format failed commercially within the decade; applications never supported it well, managing the generated instances was miserable, and Adobe quietly retired it [16]. Apple's TrueType GX variations, from the same years, were technically superior and failed at least as hard, for the platform-lock reasons that killed the rest of GX.

Then, on 14 September 2016, at the ATypI conference, Microsoft, Apple, Adobe, and Google jointly announced OpenType 1.8, whose font variations are, by the announcement's own words, a revival of Apple's GX design: one file, several masters, continuous interpolation across named axes of weight, width, optical size, or anything else the designer defines [22]. The conference was held that year in Warsaw. Interpolation-based type entered the industry at ATypI Warsaw 1975 inside a foundry tool, and became a universal standard at ATypI Warsaw 2016, 41 years later in the same city [13][22].

Why did the identical idea fail in 1991 and win in 2016? The announcement is candid about the motive: with fonts now streaming to browsers on data-metered phones, a single variable file weighs far less than the six or ten static instances a web page would otherwise load [22]. The Multiple Master pitch had been aimed at designers, a small market that could shrug it off. The variable-fonts pitch was aimed at bandwidth, which nobody can shrug off, and it arrived two years before WOFF2, the Brotli-compressed web font packaging that became a W3C Recommendation in March 2018, squeezed transfer sizes further [23]. A technology's second coming succeeds when its economics finally point the same direction as its elegance. And as a quiet bonus, variable fonts gave back what the phototypesetters' lens had taken away in the 1950s: an optical-size axis, size-specific design as a continuous parameter, the punchcutters' craft knowledge readmitted to the default stack after seventy years.

The part Gutenberg still wins

An honest history should end with what has not been recovered, and there is one substantial thing. Open a facsimile of the 42-line Bible and look at the columns: the right margins are even, the word spacing is calm, and there are no rivers of white running down the page. Gutenberg's compositors achieved that by justifying at the paragraph level, choosing among abbreviations, ligatures, and letterform variants across many lines at once with trained judgment. The Linotype's spacebands reduced justification to a per-line stretch. Computers inherited the per-line model because it is O(1) per line and requires remembering nothing.

The repair has existed for decades. Knuth and Plass published the paragraph-at-once line-breaking algorithm in 1981: consider the whole paragraph, assign demerits to every candidate set of breaks, minimise globally by dynamic programming; TeX has shipped it since, which is why theses and mathematics papers have visibly better-set paragraphs than nearly every website [24]. Karow returned to the scene too: his hz-program with Hermann Zapf in the early 1990s added micro-typographic tricks, hair-thin letterspacing and glyph-width adjustment, to reach further toward the manuscript ideal [12]. Browsers, rendering more text than every printing press in history combined, ran greedy per-line breaking for thirty years. The CSS property text-wrap: pretty, shipping in Chromium in 2023 and in Safari 26 in 2025, with Firefox support still absent as of this writing, applies paragraph-aware scoring, and Chromium's initial implementation confines its attention to the final lines of the paragraph, a bounded version of Knuth-Plass rather than the full algorithm [25]. Five hundred and seventy years after Mainz, the everyday reading surface of humanity is in mid-migration back toward the quality bar set by the first printed book. It is the clearest illustration of this essay's refrain: an assumption frozen for machine convenience in 1886 is being thawed one browser release at a time.

The pattern across six centuries

Read down the last column and the summary writes itself. Each era optimised the letter for the machine it had, and the cost of the optimisation landed on whoever the machine had not been designed around, on a delay of decades. The scripts with the smallest inventories and the most box-like behaviour, Latin above all, set the defaults; everyone else's writing became an "edge case" of infrastructure that was, from their side of it, broken at the core. The fixes, when they came, came from decoupling: Unicode splitting identity from appearance, shaping splitting appearance from storage, variations splitting a design from any single instance of it. Every major advance in this history is a decoupling, and every major regression is a coupling accepted for speed.

For anyone building software in 2026, that is not an antiquarian observation. The systems being frozen right now, model APIs, agent protocols, embedding formats, are having their rectangles-on-a-baseline moments, their one-master-through-a-lens moments, and the bills will arrive on the same decades-long delay, addressed to whoever the defaults were not designed around. The history of type is the best-documented six-century case study we possess of that process, which is a strong reason to know it better than one paragraph's worth.

Notes on sources

Dates in this essay follow the cited primary or institutional sources; where popular accounts disagree, the institutional source won. The 2,000 versus 9,000 to 12,000 characters-per-hour composition figures come from a Soviet-era technical encyclopedia [8] and should be read as representative magnitudes for skilled work, not as measurements from a single controlled comparison. Gutenberg's alloy composition is a reconstruction from later descriptions; his own formula is not documented [5]. The claim that IKARUS was introduced at ATypI Warsaw in 1975 rests on the Wikipedia article's account [13], and Karow's own retrospective confirms the 1975 public debut without my being able to verify the city in his text, so the Warsaw symmetry, while multiply attested, carries that caveat. The characterisation of Chromium's text-wrap: pretty as limited to a paragraph's final lines describes its documented initial implementation and may lag the current code [25]. The de Casteljau worked example and the quadratic-to-cubic equivalence were computed and cross-checked in a verification script before publication; the figures carry the same numbers as the prose.

Reuse and citation

The timeline table, the pattern table, and the de Casteljau figure are free to copy, reproduce, or adapt for any purpose, including commercial ones, with a link back to this page. If you are citing the essay itself, this form covers the common styles:

Nguyen, K. A. "How Letters Became Software." EFFOMA Research, 18 August 2026.
https://effoma.com/blog/how-letters-became-software

@misc{nguyen2026letters,
  author = {Nguyen, Kody Anh},
  title  = {How Letters Became Software},
  year   = {2026},
  month  = {8},
  url    = {https://effoma.com/blog/how-letters-became-software}
}

If you disagree with a date or a reading of a source, the primary sources are all listed below with enough detail to check independently; an email to the address on the About page with a better source is welcome and will be corrected in the text with credit.

References

1. Cozens, S. "A Brief History of Type." In Fonts and Layout for Global Scripts. simoncozens.github.io/fonts-and-layout, 2017 to 2021. The chapter this essay responds to; its rectangles-on-a-baseline argument is credited in section four.
2. "Bi Sheng." Wikipedia, citing Shen Kuo, Dream Pool Essays (夢溪筆談), jotting on movable type, Qingli era 1041 to 1048. See also Sinología Hispánica 7230 for an analysis of the jotting.
3. Bibliothèque nationale de France. "Jikji, a treasure of the world of printing." bnf.fr. Printed July 1377, Heungdeok-sa, Cheongju; UNESCO Memory of the World, 2001; 78 years before the Gutenberg Bible.
4. Goldin, P. R. Letter in "Where China Failed." The New York Review of Books, 25 March 2010. Movable type in premodern China lost to woodblock on print-run economics, not ignorance.
5. Bangert, J. (International Gutenberg Society). "Gutenberg's Inventions: Hand Mould." drupa.com. The hand mould as the sole component without precedent; alloy of lead, tin, antimony, reconstructed from later descriptions. See also Gutenberg Museum Mainz, "Gutenberg's invention," mainz.de.
6. Library of Congress. "The Gutenberg Bible." loc.gov/exhibits/bibles. Completion of printing probably late 1455, Mainz.
7. Angeles, L. "The great divergence and the economics of printing." The Economic History Review, University of Glasgow. Block printing as the rational commercial choice for a logographic script; movable type predicted only for very large projects.
8. "Typesetting." The Great Soviet Encyclopedia, 3rd ed., 1979. Manual composition at most ~2,000 characters/hour; Linotype-class machines 9,000 to 12,000.
9. "July 3, 1886: Front-Page Days Get Rolling, Thanks to Linotype." WIRED, 2007. The 90-key magazine, matrix circulation, and spaceband justification.
10. "The New York Tribune Publishes the First Application of the Linotype." historyofinformation.com, entry 3444, citing Schlesinger (ed.), The Biography of Ottmar Mergenthaler (1989). Page 4, 3 July 1886, identified by a wrong-font apostrophe.
11. "From Lead to Light: Lumitype, the First Successful Phototypesetting Machine." historyofinformation.com, entry 867, quoting Osterer & Stamm, Adrian Frutiger: Typefaces, The Complete Works. 1946 prototype; sixteen-font discs; first book 1953.
12. Karow, P. "Digital typography with Hermann Zapf." TUGboat 36:2, 2015. 26 February 1973 as the birth of digital typefaces; the IKARUS name; interpolation; the hz-program.
13. "Ikarus (typography software)." Wikipedia. Circle-arc outline model, on-curve points, IK format conversion to Type 1 and TrueType; introduced at ATypI 1975 in Warsaw.
14. Knuth, D. E. Digital Typography. CSLI Publications, 1999. Collected papers on TeX and METAFONT, including the pen-and-parameter model of letterforms.
15. Farin, G. Curves and Surfaces for CAGD, 5th ed. Morgan Kaufmann, 2002. The standard account of de Casteljau at Citroën (1959, unpublished) and Bézier at Renault, and of the algorithm's subdivision property.
16. Shimada, J. "The Font Wars." University of Washington CSE 590A paper, 2006. PostScript's 1984 debut, Type 1 secrecy, the alliance of Apple and Microsoft, ATM, and the wars' resolution.
17. Microsoft Typography. "A brief history of TrueType." learn.microsoft.com/typography/truetype/history. TrueType as royalty avoidance and a response to Type 1's technical limits.
18. Microsoft Typography. "OpenType specification: history and overview." learn.microsoft.com/typography/opentype. The 1996 merger format carrying both outline flavours plus GSUB/GPOS layout.
19. The Unicode Consortium. The Unicode Standard, Version 1.0, 1991. The characters-not-glyphs encoding principle, chapter 1.
20. Esfahbod, B. "Ten Years of HarfBuzz." Web Engines Hackfest, A Coruña, 2016. behdad.org/doc/harfbuzz10years-slides.pdf. Code lineage from FreeType and Pango; 2006 rewrite; 2012 adoption by Pango and Chrome.
21. Google / Noto Fonts. "Noto Nastaliq" source repository, github.com/notofonts/nastaliq. Nastaliq as an OpenType font; contributor listing as of August 2026.
22. Google Open Source Blog. "Introducing OpenType Font Variations." 14 September 2016, from ATypI Warsaw. The four-vendor announcement, GX revival, CFF2, and the bandwidth motive.
23. W3C. "WOFF File Format 2.0." W3C Recommendation, 1 March 2018. Levantovsky & Levien, eds. Brotli-based web font compression.
24. Knuth, D. E. & Plass, M. F. "Breaking Paragraphs into Lines." Software: Practice and Experience 11(11), 1981. The paragraph-at-once dynamic-programming line breaker.
25. "CSS property: text-wrap: pretty." caniuse.com, accessed 18 August 2026. Chromium 117+ (2023), Safari 26 (2025), Firefox unsupported; Chromium's documented last-lines scope.

Sources: primary and institutional pages as cited above, retrieved and cross-checked 18 August 2026; all worked mathematics verified in code before publication.

Last updated: August 18, 2026