By: Yifang Xia
The Gap Is Real, and It Is Conceptual, Not Technical
From the Directing Algorithmic Typography emerges a natural thought: there exists a family of fonts that move, vary, or respond, yet do not obviously count as algorithmic in any robust sense. A simple example would be a font animated by a looping GIF, or a variable font whose axes are moved by a human slider in real time. Both involve change and variation. Neither, strictly speaking, is algorithmic typography in the sense we have articulated: typography that uses computational rules or algorithms to generate or shape typographic forms.
The question, then, is: what marks the threshold?
Maçãs et al. (2019) draw a crisp terminological distinction worth taking seriously:
We distinguish generative typography from dynamic typography by the ability of a generative typeface to shape itself autonomously according to random or data inputs. Dynamic typography can be described by the computational generation of glyphs, which can be modified by changing manually the parameters.
They locate the threshold not in motion itself, not in variability itself, but in autonomy and source of input. Dynamic typography (kinetic, variable, movable) requires a human to pull a lever. Generative or algorithmic typography pulls its own lever, in response to a rule that processes an external or internal input.
But Maçãs et al.’s distinction, while clean, might appear to be too binary. A spectrum with several axes usually yields more productive thinking than a hard line.
Three Dimensions of the Threshold
Based on broader literature, we would argue the threshold between merely kinetic/variable and truly algorithmic involves three compounding dimensions:
First, the Locus of Decision-Making.
In conventional kinetic typography, motion is choreographed by a human animator. The letters move because a designer placed keyframes, as in traditional motion graphics lineage going back to Saul Bass’s title sequences (Martins & Brandão, 2023). The variation is human-authored, even if rendered computationally. In what Ford et al. (1997) called kinetic typography, the text is animated to convey meaning, but the decisions about when and how to move remain with the human author.
In algorithmic typography, by contrast, the locus of decision-making is displaced into the rule system. The designer does not decide what happens to each glyph. They design the logic that decides. This echoes Kowalski’s (1979) definition we previously invoked: algorithm = logic + control. The critical move is transferring control to a formal system, while retaining logic as the designer’s contribution.
Second, the Nature of the Input.
A variable font that responds to a user’s mouse movement is responsive, but the input is human and manual. The system is passive with respect to external data. What makes a font algorithmic in the stronger sense is that its input is processed rather than directly enacted.
Consider the spectrum:
The key is not simply that an external signal is present, but that the signal undergoes formal processing before it affects form. This is what Parente et al. (2019) describe as a “mapping from input (data) to output (letterforms) used as a visualisation mechanism.” The mapping is the algorithm.
Third, the Autonomy of Output Generation.
Perhaps most fundamental is that the system can generate glyphs or behaviors that the designer did not individually sanction. This is what separates parametric design from generative design. In parametric font type (Meta-Font, Multiple Master, standard variable fonts), the designer defines all the masters; interpolation connects them. The output space is fully surveyed by the designer in principle (Knuth, 1982). In generative algorithmic type, the system can produce outputs that fall outside the designer’s prior knowledge of the output space. The designer authors the rules, not the results.
Levin and Brain (2021) describe generative design precisely in these terms. It is “the activity of authoring a system of rules for automating design decisions,” (p. 162) with the implication that individual outputs are not authored but emerge. The Pereira et al. (2019) system exemplifies this logic. Its skeleton-filling drawing techniques produce letterforms the researchers describe as exhibiting “expressive” results that “push the boundaries between expressiveness and legibility” in ways that were not individually designed.
In a project, Word-As-Image for Semantic Typography, Iluz et al. (2023) asked the Stable Diffusion model “what would make this letter read as a bunny,” and let the model guide them through the letter design. That means, the semantics of bunny-ness live in the model’s weights, distilled from its training set, and nobody in that pipeline ever wrote them down. But that doesn’t mean they totally hand the logic over to algorithms. The human designers still made great efforts in keeping the letters legible, and making sure strokes must keep roughly particular mass and distribution. Here we encounter the necessity to divide “logic” in a more fine-grained way: construction logic, the knowledge of what the form should look like, and constraint logic, the knowledge of what the form may not stop being. In Pereira’s (2019) skeleton system the human authors both. In Word-as-Image the construction logic goes to the model while the human keeps the constraint logic.
These computational works interestingly argue from an engineering standpoint that the difference between kinetic and algorithmic typography is precisely the location of the decision-making agent shifting from human to generation rules.
What None of the Existing Literature Quite Resolves
Here we see a conceptual gap in the literature that this question touches, and no existing work fully addresses it. That gap concerns the ontological status of the rule. The literature consistently frames algorithmic typography as “rules + inputs = outputs.” But this formulation glides over a hard question: what kind of thing is a rule, and where does it live?
A variable font axis is a rule. A CSS animation keyframe is a rule. But we would not normally call a font with a weight axis “algorithmic” merely because it applies a rule to produce variation. What seems to distinguish algorithmic typography is not that rules exist, but that the rules operate at a level of abstraction above the individual glyph. The designer does not say “this glyph looks like this”; they say “glyphs are generated by this procedure.” The rule is generative, not descriptive. And sometimes, the rule can even be locked in a black box.
This maps onto a distinction in philosophy of computation between declarative and procedural knowledge. A static font, even a variable one with many axes, encodes declarative knowledge: here is the shape of what a letterform is. An algorithmic font encodes procedural knowledge: here is the process of how to produce a letterform.
Here we want to argue: algorithmic typography is distinguished not by motion or variation per se, but by the shift from declarative to procedural authorship of letterforms. The designer’s work migrates from specifying forms to specifying formation processes. This is coherent with what Jürg Lehni’s “Typeface As Programme” (2011) suggests when it proposes thinking of typefaces as software, as programs that run rather than shapes that are stored. Lehni’s framing asks whether a computer program could be assigned the routine tasks of letter design, and whether novel forms might evolve through the manipulation of fonts’ algorithmic data. The key word is evolve: forms that could not have been individually designed, but which emerge from the running of a program.
More to Ponder Upon
The recent wave of AI-driven typography research (post-2022, largely on arXiv) has swayed human designers’ control even more heavily. Projects like Liu et al.’s “Dynamic Typography: Bringing Text to Life via Video Diffusion Prior” (arXiv 2404.11614, presented at ICCV 2025) and the Kinetic Typography Diffusion Model (Park et al., arXiv 2407.10476, 2024) treat the automation of letter animation as the central technical problem. The former transfers the authorship of individual motion decisions to a formal system (here, a neural displacement field guided by diffusion priors). In the latter, animated text is generated from a diffusion model trained on roughly 600,000 clips. In both cases no readable rules can be found. “Logic” is distilled into weights from a training corpus the designer never saw. Both construction and constraint logic are largely dependent on the algorithms. Human designers are left holding little more than a prompt. Will we still call such purely technical projects “font design?”
References
Ford, S., Forlizzi, J., and Ishizaki, S. “Kinetic Typography: Issues in Time-Based Presentation of Text.” CHI’ 97 Extended Abstracts on Human Factors in Computing Systems, ACM, 1997.
Iluz, S., Vinker, Y., Hertz, A., Berio, D., Cohen-Or, D., & Shamir, A. (2023). Word-As-Image for Semantic Typography. ACM TOG 42(4), SIGGRAPH 2023 (Honorable Mention). arXiv:2303.01818. https://doi.org/10.1145/3592123
Knuth, Donald E. “The Concept of a Meta-Font.” Visible Language, vol. 16, no. 1, 1982, pp. 3–27. https://journals.uc.edu/index.php/vl/article/view/5329
Kowalski, Robert. “Algorithm = Logic + Control.” Communications of the ACM, vol. 22, no. 7, 1979, pp. 424–436. https://doi.org/10.1145/359131.359136
Lehni, Jürg. “Typeface As Programme.” Typotheque, 2011, www.typotheque.com/articles/typeface-as-programme
Levin, Golan, and Tega Brain. Code as Creative Medium: A Handbook for Computational Art and Design. MIT Press, 2021.
Liu, Zichen, et al. “Dynamic Typography: Bringing Text to Life via Video Diffusion Prior.” arXiv preprint arXiv:2404.11614, 2024. Presented at ICCV 2025. https://doi.org/10.48550/arXiv.2404.11614
Maçãs, Catarina, et al. “typEm: A Generative Typeface That Represents the Emotion of the Text.” Proceedings of the 9th International Conference on Digital and Interactive Arts (ARTECH 2019), ACM, 2019. https://doi.org/10.1145/3359852.3359874
Martins, Alexandre, and Bruno Mendes da Silva. “Digital Wor(l)ds: Using Dynamic Typography as a Mean of Artistic Expression in Digital and Audiovisual Settings.” Advances in Design and Digital Communication III, edited by Nuno Martins and Daniel Brandão, Springer, 2023, pp. 792–804. https://doi.org/10.1007/978-3-031-20364-0_66
Parente, Jéssica, Tiago Martins, and João Bicker. “Data-Driven Logotype Design.” 2018 22nd International Conference Information Visualisation (IV), IEEE, 2018, pp. 64–70. https://doi.org/10.1109/iV.2018.00022
Parente, Jéssica, et al. “Designing Dynamic Logotypes to Represent Data.” International Journal of Art, Culture, Design, and Technology, vol. 8, no. 1, 2019, pp. 16–30. https://doi.org/10.4018/IJACDT.2019010102
Park, Seonmi, et al. “Kinetic Typography Diffusion Model.” arXiv preprint arXiv:2407.10476, 2024. Published in Proceedings of ECCV 2024, Springer. https://doi.org/10.1007/978-3-031-72754-2_10
Pereira, Fábio André, et al. “Generative Type Design: Creating Glyphs from Typographical Skeletons.” Proceedings of the 9th International Conference on Digital and Interactive Arts (ARTECH 2019), ACM, 2019, pp. 1–8. https://doi.org/10.1145/3359852.3359866
