I thrifted a book Type Matters! by Jim Williams. It's not a great book, but it had one interesting tidbit in it, describing an obscure text justification setting. It says:

Range left, range right, centered or justified: there is also a fifth way of setting type within a given measure, called cogent. In the 1980s [...] an advertising agency called Cogent Elliott would send out type mark-ups requesting the type to be set as 'semi-justified', whereby the setting was range left but lines that were close to the measure were pulled out to the full width, to give a more defined edge to the right-hand side.

I had never heard of "cogent" or "semi-justified" text alignment, and searching for it online brings up almost no relevant results.

I found this idea interesting, so I had to try it out. Here's an interactive demo. Adjust the line width slider to see the effect:

It's a bit jarring at first — probably because this style of justification is so uncommon — but it's surprisingly readable after getting used to it.

Here it is implemented it in my (WIP) stroke font editor:

How does it work?

Type Matters describes semi-justification as ragged, where lines that are almost to the full width are justified. But then the question is: what does it mean "almost"? How do we decide which lines should be justified?

The basic justification algorithm (called greedy) puts words on a line with normal spaces between them, until the next word doesn't fit in the element's boundaries, and then distributes the remaining space evenly between the inter-word gaps of that line. The left-over word starts a new line, and the process is repeated.

The problem is that if the remaining space is large, it can produce horrible gaps in-between words. This happens usually if the line width is short, or if the text has long words (which languages like Finnish or German have plenty), rendering the text nigh unreadable. This is what we have on the web, and it sucks.

As I was trying to figure out the semi-justification logic, I realized that the problem is actually about word-spaces: what we really want to avoid is holes.

We can do that with bounding word-spaces. By bounding word-spaces, we don't need to decide which lines should be justified, because lines automatically self-select: if a line can reach the target width within acceptable spacing bounds, it gets justified, and if not, it stays ragged. This is achieved by restricting how much word-spaces are allowed to expand during space distribution. In addition, we can also allow the word-spaces to shrink for more flexibility. Here's how it works:

1. Puts words on a line one at a time, but with word-spaces shrunk by a minimum word-space value. When a word would exceed the target line width, move it to the next line.
2. Distribute the remaining space evenly among the word-spaces to reach the target line width. But, if the word-spaces would exceed maximum word-space value to fill the line, leave the line ragged (using normal word-spacing).
3. Repeat for each line, including the last.

That's it.

With moderate min and max word-space values (e.g. -25% and 25% of the normal space), most of the lines get justified, while some lines get ragged. In the "worst case" scenario, if the textbox is narrow, most lines just get ragged, whereas basic greedy justification would produce holes. But, if the textbox is wide enough, the result is a well justified paragraph, with occasional ragged lines. It never produces unacceptable results, but has the potential of producing great results.

Here's a (non-optimised) implementation in JavaScript:

class SemiJustify {
  // measureText should return the pixel width of a text string
  #measure
  constructor(measureText) {
    this.#measure = measureText;
  }

  justify(text, { maxWidth, minSpace, maxSpace, normalSpace }) {
    const words = text.trim().split(/\s+/);
    const lines = this.#breakLines(words, maxWidth, minSpace);

    return lines.map((words, i) => {
      const canJustify = words.length > 1 &&
        this.#totalWidth(words) + (words.length - 1) * maxSpace >= maxWidth;

      return {
        words,
        spacing: canJustify
          ? this.#calcSpacing(words, maxWidth, minSpace, maxSpace)
          : normalSpace
      };
    });
  }

  #breakLines(words, maxWidth, minSpace) {
    const lines = [];
    let line = [];

    for (const word of words) {
      if (line.length && !this.#fits(line, word, maxWidth, minSpace)) {
        lines.push(line);
        line = [];
      }
      line.push(word);
    }

    if (line.length) lines.push(line);
    return lines;
  }

  #fits(line, word, maxWidth, minSpace) {
    return this.#totalWidth(line) + this.#measure(word) + line.length * minSpace <= maxWidth;
  }

  #calcSpacing(words, maxWidth, minSpace, maxSpace) {
    const gaps = words.length - 1;
    if (!gaps) return minSpace;

    const spacing = (maxWidth - this.#totalWidth(words)) / gaps;
    return Math.min(Math.max(spacing, minSpace), maxSpace);
  }

  #totalWidth(words) {
    return words.reduce((sum, word) => sum + this.#measure(word), 0);
  }
}

and here's a crude example use for canvas:

const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
ctx.font = '9px Arial';

const measureText = (text) => ctx.measureText(text).width;
const justifier = new SemiJustify(measureText);

const text = "Justifying text usually means that all lines except (usually) the last are set to equal measure. Text justification is very common in books and other printed matter, and is regarded by many as an essential property of high quality typography. On the web, it's the opposite.";

const normalSpaceWidth = ctx.measureText(' ').width;
const result = justifier.justify(text, {
    maxWidth: 150,
    minSpace: normalSpaceWidth * 0.75,
    maxSpace: normalSpaceWidth * 1.5,
    normalSpace: normalSpaceWidth
});

// Render each line
let y = 9; // Starting Y position
const lineHeight = 12;
result.forEach(line => {
    let x = 0; // Starting X position
    line.words.forEach((word, i) => {
        ctx.fillText(word, x, y); // Draw the word
        x += ctx.measureText(word).width;
        // Add spacing (except after the last word)
        if (i < line.words.length - 1) {
            x += line.spacing;
        }
    });
    y += lineHeight;
});

The algorithm could be further improved with hyphenation, and even further with bounded glyph scaling and letter spacing adjustments. The SVG web component included above can be found here. I also tested mixing this with hyphenation in this codepen demo.

Fix justification for the web

The best justification systems are based on the Knuth–Plass line-breaking algorithm. It's what professional typesetting programs use. But it's also really complex, and requires a lot of tricky optimisations to be fast and reliable. That, and the fact that Knuth-Plass requires knowing the contents of the text upfront to make its calculations, is the reason the web (for example) only implements a simple greedy algorithm for text justification.

But anyone who has ever set type with text-align:justify; knows that the greedy justification can produce horrible holes if the line width is short or if the text has long words, rendering the text unreadable. As a consequence, the one rule for web typography has been to not justify text under any circumstances.

We can't have Knuth-Plass on the web — sad, but understandable. The proposed text-wrap:pretty; might bring it, or something like it, to web at some point, but the current implementations found in Safari and Chrome don't fix the issues with justification.

So, text-align:left; (or right) remains the only viable text alignment option for the web.

In my opinion, the semi-justified system could offer a real alternative. As I see it, it has no downsides:

1. It has essentially the same computational cost as regular greedy justification since it's still, in essence, a greedy algorithm.

2. It's simple to implement.

3. It's a progressive enhancement. My proposed syntax would be to use the already existing word-spacing property to accept a clamp function:

    p {
      text-align: justify;
      word-spacing: clamp(-25%, 0%, 25%);
    }
   

4. It's inherently responsive. The most common use case is clear: as the containing box resizes, the text inside gets automatically justified on desktop (wide screen), and ragged on mobile (narrow screen).

Related examples

In a briarpress discussion the same method is called "half justification":

I have a design book somewhere I believed mentioned a technique for justifying type that was called something like half justification. [...] The idea was that if the length of the text was within some predetermined distance of the maximum possible width the line would be justified. If it fell short of that it would remain ragged right.

Johannes Lang pointed out that Fraser Muggeridge gave a talk recently about this exact method: Justified and unjustified setting (at the same time)! The talk includes many examples, it's worth a watch.

kst pointed me to Johannes Ammon's talk/article Better Justification for the Web, in which he gives a great overview and history of the problem, and suggests using variable fonts for additional parameters for better justification (he calls his method "soft justification", here's a demo). The "further reading" section also has some great resources, like Bram Stein's TeX line breaking algorithm in JavaScript and Simon Cozens' line breaking algo for variable fonts for which there's also a demo.

End note

If you found this idea interesting and want to discuss it, or if you know of any examples of this method used, please contact me at hlotvonen@gmail.com or post a comment on mastodon.

UPDATE Summer 2025: I've released a new version of Moebius XBIN! This guide is completely rewritten for it.

MoebiusXBIN

MoebiusXBIN is an ASCII & text-mode art editor for MacOS, Linux and Windows, with support for custom fonts and colors.

Download

To download, click the link below and choose the package suitable for your OS.

Download the latest packages from Github

If you have suggestions or find any bugs let me know! You can email me at hlotvonen@gmail.com or make an issue at the Github page.

Introduction

Traditionally ASCII art^[1] is made in plain text, and displayed in text-mode using character sets stored in the ROM of computer graphics adapters. This has carried on to modern text-mode art editors, which are designed to produce files compatible with real retro hardware, even if they're rarely viewed with them.

The editor for making PC-ASCII, ANSI art^[2], and Amiga ASCII art is nowadays PabloDraw, and more recently Moebius. Those editors come with a few standard IBM PC and Amiga fonts, but which font is used to view them is wholly dependent on the viewer's system. There is no way to specify which font should be used to view the artwork (other than maybe writing something like "please view with font X" at the top of the artwork).

But as someone with no strong nostalgic relationship to retro computers, the magic of ASCII art is not necessarily in the aesthetic produced by these two fonts, but in the act of creating it: to me ASCII art is about trying to uncover the latent visual potentials of a small set of letterforms, by weaving them into imagery idiosyncratic to their textu(r)al properties.

The latent potential of both Amiga ASCII art and PC ASCII & ANSI art art is pretty well explored over the past 30–40 years, which made me think: what if you could change the font? What kind of possibilities would other character sets unlock? What is possible with ASCII art if you could change the look of the characters?

These same question were also asked back in the heydays of ASCII art, and in 1996 the art group ACiD created the XBIN (eXtended BINary) file format to overcome the limits of plain text ASCII and ANSI files. Instead of saving the ASCII art files as text, XBIN saves them as a raw image of the video memory, and also includes the font and color palette data. With XBIN, artists can make text-mode graphics with customized fonts and color palettes.

XBIN was released "ready to take the Art scene by storm", but it never gained any widespread adoption or support. However, both PabloDraw and Moebius do support (to some extent) viewing and saving XBIN files. The problem? You can't change the font!

But Moebius, made by Andy Herbert in 2019, is open source. So, in 2020 I forked it into MoebiusXBIN with the intention of adding a full support for the XBIN format and the ability to change the font. That was in 2020, and at the time of writing (2025), the editor has received multiple additional features, and has been used to explore the potentials of custom fonts by many artists.

Features in MoebiusXBIN

Quick summary of features:

1. Custom fonts. Choose and favorite from almost 2400 different fonts using the dedicated Font browser. Import and export fonts as PNG files.
2. Custom colors. Choose from around 200 hand-made color palettes made by the Lospec community. Use the dedicated Palette browser to choose and favorite them.
3. Multi-lingual ASCII art. Support for hundreds of encodings to match your input source and chosen font. Support for right-to-left and top-to-bottom writing directions. Basic Arabic text shaper for the CP864 encoding.
4. Beginner-friendly tutorial. The step-by-step MoebiusXBIN tutorial will teach you the workflow, shortcuts and features of the editor.
   ▶ (Click to open) View the tutorial as an image

   

5. ...and so much more! Check the full list on the Github page

How to use custom fonts

The main feature of MoebiusXBIN is using custom fonts. MoebiusXBIN comes with all the classic fonts, but also includes a few special text-mode art fonts, the complete list of VGA fonts compiled by VileR and hundreds of fonts found from various Amiga discs.

However, the easiest way to use or make your own font is finding a font you like using the Font browser (Font -> Font browser), exporting it as a PNG (Font -> Export Font as PNG), modifying it in a pixel art editor, and then importing it again (Font -> Import Font from Image (GIF/PNG)).

I can also recommend making custom fonts with VileR's amazing VGA font editor Fontraption. Watch a video tutorial for it on Youtube.

Examples

Acknowledgements & Thanks

• All credits go to Andy Herbert who made the original Moebius.
• Huge thanks for major contributions to grymmjack (who maintains his own fork of my fork, but I have now merged it), jejacks0n, michael-lazar and bart-d.
• Uses modified Google's Material Icons. https://material.io/icons/

Included fonts:

• GJSCI-3, GJSCI-4 and GJSCI-X appears courtesy of GrymmJack
• FROGBLOCK appears courtesy of PolyDucks
• Newschool fonts collected and modified from the NewSchool pack, courtesy of XBIN workshop participants at the Estonian Academy of Arts in 2021.
• structures font by Gladys Camilo
• TES-* fonts by me.
• Topaz originally appeared in Amiga Workbench, courtesy of Commodore Int.
• Topaz Kickstart versions uncovered by heckmeck, courtesy of Commodore Int.
• P0t-NOoDLE appears courtesy of Leo 'Nudel' Davidson
• mO'sOul appears courtesy of Desoto/Mo'Soul
• Viler's VGA font collection, with additional info on sources in the FONTS.TXT
• Discmaster fonts collected from discmaster.textfiles.com

Footnotes

Note:

This post is a companion piece to my article The origins of DEL (0x7F) and its Legacy in Amiga ASCII art. That article is all about the character DEL, what it is, how it was used, and why it even has a visual representation, but with a focus on Commodore's Amiga computers. Whereas AmigaOS's Topaz font renders DEL with diagonal lines, IBM's PC renders it... as a house. This bonus article is about that.

This article wouldn't have happened without the great help and insights of Michael Walden and VileR, thank you!

If you want to comment on something (minor or major), please send me an email at hlotvonen@gmail.com. I would greatly appreciate it, and if something needs fixing I would gladly update the article with proper credit.

The rise of Code Page 437

Released in 1981, the IBM Personal Computer (PC) launched IBM's first microcomputer model line. Alongside it, they introduced an 8-bit character set, which later became known as Code Page 437 (CP437). Unlike earlier IBM machines, the PC was built using off-the-shelf components instead of proprietary IBM technology. This spawned a wave of third-party clones marketed as "IBM-compatible" systems, which lead to IBM PC architecture quickly becoming the dominant global computing standard. By the end of the 1980s, 84% of all sold microcomputers were either IBM PC's or its clones.^[1]

The rise of PC also meant the widespread adoption of CP437, making it one of the most copied and recognizable character sets ever. VileR's Ultimate Oldschool PC Font Pack lists over 200 fonts based on CP437 from various IBM PC models and their clones.

CP437 was based on American Standard Code for Information Interchange (ASCII), which defines the first 127 characters. This was a big change for IBM who had previously used the fundamentally different EBCDIC standard. But as ASCII covers only 96 printable characters of the total 256 available in 8-bit code, IBM had to figure out what to do with the rest of them. Instead of basing their choices on any predefined standards extending ASCII, or copying others, they decided (yet again) to do their own thing.

A set of "not serious" characters

The extended bits (characters 128–255) of CP437 contain mainly a mishmash of international text characters, box drawing shapes and mathematical symbols. But for the undefined control characters they did something wildly different. Dr. David J. Bradley, one of the creators of the IBM PC, recounts the origins of the ASCII smiley character in an email conversation with Benj Edwards of vintagecomputing.com:

"Now, what to do about the first 32 characters (x00-x1F)? ASCII defines them as control codes, carriage return, line feed, tab… These characters originated with teletype transmission. But we could display them on the character based screens. So we added a set of “not serious” characters. They were intended as display only characters, not for transmission or storage. Their most probable use would be in [text] character based games."^[2]

The first 32 characters (x00-x1F) of CP437 mentioned by Bradley include smileys, playing card suits, musical notes, a solar symbol, gender symbols and arrows. What Bradley doesn't explicitly mention is the character at 0x7F, which is also a (sort-of) control character used in teletype transmission. It's assigned to the Delete character, which was used to obliterate undesirable characters on paper tape by punching it full of holes. The all-holes pattern in ASCII is at the 127th code point, represented by 0x7F in hexadecimal. This character is like all the other 32 control characters in that it doesn't have a defined visual representation, nor any particular use in digital computers like the IBM PC. So, even though Bradley doesn't explicitly mention 0x7F, it's represented in CP437 as a tiny pixel-house (⌂), suggesting it might also belong to the "not serious" group of characters.

According to Bradley, the "not serious" characters were developed during a 4-hour plane travel. He's of course exaggerating, but gave it as an "indication of the rapidity in which many significant decisions were undertaken". But even though they developed them relatively quickly, they must have based them on something.

What is this something? IBM could have followed an existing standard and taken the graphics for control characters from ANSI X3.32-1973—but they are ambiguous and hard-to-use (see part 2 of The origins of DEL (0x7F) and its Legacy in Amiga ASCII art). Instead, going with these "not serious" characters was arguably a better choice, especially as a business decision. Characters like the smiley face at 0x01 became iconic, precisely because they offered a simple way to represent player characters in text-based games like Rogue and ZZT.

IBM was by no means the first to include "not serious" characters. For example, Commodore's PETSCII character set from 1977 is known for its graphical shapes which also include card suites.^[3]

Even the American National Standards Institute's (ANSI) X3.2 committee considered including some "not serious" symbols for an official 8-bit ASCII extension.

But, why add these quirky characters, when arguably more useful characters, like extending support for additional languages or writing systems, could be added? Bob Bemer ("The Father of ASCII") defends their inclusion in an article for the Interface Age in July 1978:

"Presumably the card suits will strike your eye, and you will wonder why so many other useful symbols were ignored in favor of these. Don't worry, they will always come in handy; it's sometimes useful to have symbols whose meaning you can reassign without harm to programming languages, etc."^[4]

This is definitely the case with Code Page 437's house symbol (⌂). It is ambiguous enough that it can resemble many different things, not just a house. For example, in the DOS games By Fire & Sword (1985) it's a town, in ZZT (1991) it stands for "energizers", in Bugs! (1982) it's the player's gun, in Target (1982) it represents player's ammo, and in Numjump (2017) they're deadly spikes.

PC ASCII artists have used the house symbol, not as a specific thing with meaning, but purely for its shape and size, to create what is called "newskool", or filled ASCII art. In the classic 8×16 pixels-per-character IBM VGA font, it's one of the few characters that sit one pixel higher from the baseline.

When combined with other characters that are just slightly larger or smaller creates an illusion of a continuous shape: ·∙•↔*⌂S§¼╣$♫b%⌂≈←·.

It's also fairly wide and "dark" in its typographic color, so it fills the space it occupies, without leaving any considerable gaps of negative space. In other words, it doesn't stand out when used carefully.

Its angled top makes it useful for creating curves, as seen in ddrj's drj-mmc.ans from 2004 (house characters are highlighted in red):

Theories on the origins of CP437's house

But what about IBM? Why did IBM decide to include a symbol representing a house in their character set? It's a strange glyph; adding a smiley is readily arguable, and playing card suits have existed in prior character sets, but a house—as far as I can tell—didn't exist as a glyph anywhere before IBM's Code Page 437. It seems to have come out of thin air. To my knowledge, there are no (surviving) documents on the design process of the character set. The little bit we know comes from a few interviews, like the one with David J. Bradley, and from meticulous research done by people like VileR. So, the only thing I can do is speculate. Here are my thoughts:

Theory #1: House as a symbol for home computers

My first thought was that maybe the house was included as a symbol for IBM's new line of personal home computers? Before IBM PC's launch in 1981, IBM had largely been known for their business computers. So, it makes sense that, as IBM was entering the growing market of personal computers, they wanted to signal to the home users that their PC had something fun to offer—hence the "not serious" glyphs, like the smiley, which were added with text-based games in mind. So maybe they added the house glyph for the same reason? Surely the smileys must have a house to live in! It's compelling to think this might be true, but to be clear, this is pure speculation, and there's nothing to support this claim.

Theory #2: It's related to backspace

Another "hunch" was suggested by VileR. He entertained the idea that the house character itself was associated with the action of deleting text, or related to the backspace symbol ⌫ (U+232B). If you rotate ⌫ 90˚ clockwise, you do get a house ⌂ (with an × in it). It's an interesting idea, but there doesn't seem to be anything to support this claim either.

Theory #3: House as a symbol for "home reset"

Or maybe it is related to "Home" key, which resets the cursor to the beginning of the text? In 1976, Robert Suding (who worked for IBM from 1967 to 1975)^[5] writes in BYTE magazine about how to build a television display interface, using the Motorola MCM6571L 7×9 dot matrix character generator. In this computer chip, DEL is rendered as a full block (■), but Suding repurposes it as "home reset". He describes it as a routine that writes 512 spaces (effectively clearing the screen), and then resets the cursor to the home position (top-left of the screen).^[6]

Could it be that IBM PCs developers wanted to symbolize this "home reset" with a house graphic in their product? This seems almost too good to be a coincidence—yet there's nothing substantial to support this theory either.

Theory #4: It's borrowed from System/23 Datamaster

In the Benj Edwards' email interview, David Bradley also mentions that the choice of "serious characters" was based on the immediate ancestor of PC at IBM, the System/23 Datamaster.^[7] VileR analyzed the Datamaster character ROM image recently shared online by Jaume López, which confirms that some character sequences were copied to CP437 unchanged (üéâäàåçêëèïî). But, there is no house symbol, or anything resembling it.

Theory #5: It's borrowed from Wang word processing machines

In a blog post Weird Tales, Michal Necasek of OS/2 Museum examines claims made by Bill Gates that Microsoft wanted IBM to copy some Wang word processing characters ("smiley faces and boxes and triangles and stuff") into the IBM PC's character set because they were considering creating their own Wang clone. Necasek half-debunks and half-confirms these claims, as none of the Wang character sets have smileys, yet they do share some strikingly similiar characters with CP437 that are unlikely to be a coincidence. These include left/right triangles, a box, a diamond, double exclamation mark, and several arrows.^[8] But again, none of the Wang character sets include a house symbol, so IBM couldn't have copied it from there.

Theory #6: It comes from Blissymbolics

So, IBM didn't get the house glyph by copying it from other character sets. But it's unlikely that IBM's team designed the house symbol in a vacuum. If it's not from another computer system, then maybe they found it by looking at books for existing symbol systems and iconography?

For example, a hotel icon used by the ICAO in the 1970s is quite similar in shape to CP437's house.^[9]

Another possibile influence is Blissymbolics. It was originally developed in 1949, but gained some renewed popularity in the 1970s and 1980s.^[10] The Blissymbolics house glyph is striking similar to IBM's character at 0x7F.^[11] If IBM was looking at symbol books, searching for inspiration for their new character set, it's possible they would have come upon Blissymbolics. The timeline fits: a book Teaching and Using Blissymbolics was published in 1980, at the time when IBM was developing CP437.

Theory #7: Botched copy of a dot-stretched Wang delta

Or maybe it does come from Wang? VileR makes an interesting observation: a 1979 Wang character set for the 2236DE terminal includes a delta symbol ( Δ ) at position 0x9A. At first glance this seemed unrelated to IBM's house symbol at 0x7F. But after viewing the ROM data as a bitmap, VileR discovered two interesting things. First, Wang's delta wasn't a clean equilateral triangle (angles at 60°, 60°, 60°); to avoid uneven displacements between scanlines, which could produce very obvious "jaggies" on low-res CRTs, the delta was instead rendered as a right triangle (angles 45°, 90°, 45°). However, because of this, the triangle's side-corners had to be chopped off, to fit it into its 7×7 pixels-per-character space. Secondly, VileR discovered that the bitmap's pixels were spaced-out, implying that the glyphs relied on some sort of dot-stretching effect in the display circuitry. After these realizations, rendering the bitmap with his CRT emulator revealed that Wang's delta actually resembles IBM's blocky house symbol.

So, if Bill Gates was correct about IBM copying characters from Wang, it's entirely possible that the people at IBM, who were copying glyphs directly from a Wang terminal screen, misinterpreted the delta as a house, especially considering, as Bradley notes, that the whole process was rushed. This is not a definitive proof, but a compelling theory nonetheless!

Theory #8: Is it delta?

But, in an email conversation, Michael Walden speculates that it might not even be a coincidence that the DELete character has DELta as its printable character glyph.

Delta as a symbol ( Δ ) originates from the Greek alphabet. CP437 already includes some Greek characters in the 0xEO–0xEB range, notably 0xEB being the symbol for Greek small delta ( δ ). These characters were not included to support Greek language, but as math symbols. In mathematics and other sciences, the uppercase delta is often used to denote a "change of any changeable quantity", which might have provided a good reason to include it in the character set.

Delta doesn't only appear in Wang's character set, but in many character sets before it. For example, the APL programming language, which originated at IBM in the 1960s, includes delta ( Δ ), and inverted delta ( ∇ ) in its syntax. As a curious but unrelated coincidence, the IBM name for the inverted delta is DEL—the same as the control character DEL (Delete) at 0x7F.^[12]

The APL symbols appeared on some early IBM APL keyboards, like in the 1971 IBM 3270. VileR also notes that IBM's first desktop machines from the mid 1970s, the 5100/5110/5120, were intended for APL from the get go, but there's no evidence that they ever influenced the development of IBM PC in any way, even if they are in the same model numbering system (IBM PC is 5150). It's also worth noting that IBM's APL character sets, like the Code Page 909, sometimes include both delta and the house symbol. As such, it doesn't seem like there's a strong connection between the house and APL's delta.

Theory #9: It IS delta?!

Hold on... let's examine our basic assumptions. How can we be absolutely certain that IBM even intended for the glyph ⌂ at 0x7F to represent a house? What if the whole premise is wrong?

When I browsed through the original 1981 Technical Reference manual for IBM PC, I realized that there's no mention of a "house" anywhere. In fact, the character explicitly listed at position 0x7F isn't a house at all—it's a delta ( Δ )!

Was it intended to be delta all along?

But of course it's not so simple. The 1982 edition of IBM BASIC Manual displays the code point 0x7F quite unambiguously as a house!

What is going on? Was the 1981 Technical Reference printed in error, and corrected later? It doesn't seem like it: the 1984 revised edition of the IBM PC Technical Reference still display 0x7F as delta.

And it's not a mistake: 0x7F is even labeled as delta in the IBM PCs source code (in the System BIOS character generator routines).

Still, the original 1981 IBM PC System BIOS font clearly renders it as a house: ⌂. It seems very unlikely that anybody would actually associate the shape of it with the delta character—let alone use the house character as delta in any scientific syntax.

Maybe it's just some careless disparity between printed material and the actual font rendering? It isn't so either: 0x7F isn't consistently rendered as a house in every CP437 font, as can be seen from the following chart, which display the 0x7F character from various CP437-compatible VGA fonts:

While most of the fonts render 0x7F as a house, some of them are quite undeniably deltas (listed near the bottom of the chart).

To make matters more confusing (or maybe in an attempt to prevent further confusion?), in 1984, IBM's own authoritative registry of glyph names (GCGID) officially names 0x7F in CP437 as "small house". In fact, as Michael Walden pointed out to me, originally the whole character set had no name, until this registration. Code Page 437 was not born as a real code page at all—it was merely a bunch of graphical glyphs, stored in the Read-Only Memory (ROM) of the System BIOS, available for the computer to use immediately on booting. Because the characters were implemented in the hardware, the font, and its derivatives, were often just called "OEM fonts", where OEM stands for "Original Equipment Manufacturer". All "official" IBM names, for the character set and its glyphs, were given retroactively in 1984.

But even officially naming the Code Page 437, and its glyphs, was not enough to correct their rendering. In 1986, the IBM PC Convertible system font renders 0x7F as delta, and the 1986 IBM PC/AT Technical Reference still lists and labels 0x7F as delta. Even in 1989, the Olivetti MS-DOS Software Installation Guide renders the 0x7F as delta.

Theory #10: It MUST be a delta because even the GREEK delta looks like a house!

As I was taking another look at VileR's oldschool PC fonts page on the original IBM BIOS font, something caught my eye. Because the IBM PC was sold in many non-English speaking countries, the character set had language specific variants. The Greek versions included the actual Greek uppercase delta. And—this came to me as a complete surprise—its glyph looks like a house too!

If even the actual Greek uppercase delta is, quite unmistakenly, rendered as a house, then the theory that DEL is just a badly formed uppercase Greek delta character with the bottom corners cut off (due to a lack of horizontal pixels) starts to seem more and more convincing.

But yet again, it's not so simple. VileR pointed out to me that we don't actually know what the official IBM PC Greek font looked like! The original pixel data of the IBM Greek CP851 character set could be (presumably) found in IBM's Greek video card ROMs, or on IBM's National Language Supplement diskettes. But, neither the ROMs, nor the language diskettes, have ever been made available anywhere. The only Greek fonts that have survived are sourced from software and video cards made by third party vendors, not by IBM. But while most of the third party Greek fonts I found are styled like IBM's, and render 0x7F as a house, they aren't necessarily based on actual IBM sources. And, the one Greek font VileR has found, an unknown MS-DOS CP851 font, which might be a direct copy of an actual IBM PC font, renders the Greek delta as a delta, not a house!

Delta theory doubt

There is just one thing I cant't quite comprehend. Let's assume for a second that DEL was supposed to be delta. Did IBM seriously not try different ways of drawing a delta, before settling on the house glyph? With a little bit of effort, it is completely possible to draw a convincing delta, even in 8×8 pixel space. Here's a chart to compare. The first three are IBM's renditions of the "delta", the rest are my own attempts I threw together in 10 minutes. I think that any of the versions I drew could have been more clearly understood as deltas. So, if IBM did go through some versions of the delta, they would have likely landed on the same, or very similar shapes to mine—yet they still chose the house-looking glyph to represent it. Why would they do that?

Click on the patterns to change the view. You can also edit/draw on the canvas, see if you can come up with something better:

Theory #11: It's no mistake

A comment on hackernews pointed out that every character in CP437, not just the delta/house, which would typically have diagonal lines at steeper angles than 45˚ are forced to 45˚ by extending them first with straight lines. This can be seen most clearly in letters A, V, N, 7 and Æ. Because the same design feature appears throughout the character set, delta's transformation into a house starts to look less like a mistake, and more like a deliberate decision. Perhaps VileR's suggestion, that designers of early bitmap fonts were reluctant to use angles other than 45˚ and 90˚ to avoid uneven displacements between scanlines, is the reason for this choice.

So, if IBM copied characters from Wang character sets, maybe the delta character wasn't misinterpreted, or mistakenly drawn, as a house by IBM's designers after all, as theorised earlier. Instead, maybe the designers intended it to be a delta, but in their stubborness to avoid "jaggies" rendered it illegible, without realizing that, while A and V can still be clearly read as A and V, a more uncommon symbol like delta, rendered as ⌂, wouldn't be as easily understood as ∆. As a consequence, nobody associated CP437's "delta" shape with the actual delta symbol, but percieved it as a funny little house. Because the character set already had "not serious" characters like the smiley, a house glyph wouldn't have been unexpected.

What DO we know?

But even after all these theories, the only thing we know for certain is that even IBM was confused, or just didn't care, whether 0x7F should be a delta, or a house. The fact is, that while the character at code point 0x7F in the 1981 IBM PC's System BIOS font might look like a house, we can't definitely claim that it was intended to look like a house. The only thing we can say for sure, is that 0x7F has been labeled as "delta" in the IBM PC's System BIOS since 1981, and that the IBM's official registry named it "small house" in 1984. That's it.

What does this tell us? The consistent inconsistencies in IBM's technical documentations, fonts, and registries, sounds like a classic case of miscommunication between the different departments of IBM. Did the font's designers intend 0x7F to be a house, but the engineers interpreted it as a delta, mislabeling it in the System BIOS? Or did the designers intend it to be delta, but the botched rendering made it look like a house, and publications like the IBM BASIC Manual perpetuated the wrong interpretation until IBM decided to make it official in the registry? Or what? There is no clear answer.

Whether IBM meant 0x7F to be a delta, or a house, remains a mystery. But it doesn't really matter. What the house character looks like, is, after all, just a matter of interpretation. The legacy of CP437 is not defined by IBM's intentions, but by all the different ways designers, programmers, ASCII artists and other users adopted it. It is delta and house, but also rocket, players ammo, gun, spike, energizer, or whatever else we want it to be. As IBM engineer Charles E. Mackenzie observes in Coded Character Sets, History and Development:

"There is an aspect of human nature which surfaces in data processing. Experience has shown that if graphics are provided on a computing system, they will be used in one way or another by customers, even if they have no intrinsic meaning."^[13]

This is probably best exemplified by how the house character is used in PC ASCII art. In the hands of ASCII artists, the character goes beyond meaning and returns to pure form, demonstrating that there is no shape that has an "intrinsic" meaning, until we give them meaning.

To see how ⌂ was used in PC ASCII art, I wrote a script that scanned the 16colo.rs archive for any artwork containing 0x7F. Here are some of my favourites:

Reader's theories: It represents a tab stop, or a similar part

After I published the article, many people commented that the house reminded them of some physical part of earlier typewriters and word processors.

Dru Nelson suggested it's related to the cursor indicator from the original IBM selectric typewriter.

Indeed, it does look like it! But, firstly, if the house glyph was intended to be used as a cursor (shown underneath the character position), then why wasn't it positioned touching the top edge of the character cell? The house character is almost always positioned near the baseline of the character cell instead. Secondly, the character was named "delta" in the System BIOS, so if it was meant to be a cursor, wouldn't they have named it so? Thirdly, the CP437 character set already includes an upwards triangle ▲ and ^, both of which could work as cursor indicators already. Fourthly, IBM PC indicates its cursor position with a blinking underline—the same as Wang terminals—so there was no need for a separate "cursor" symbol anyway.

Robert Kersbergen also suggested to me in an email that the house resembles the "scope" of some typewriters (used to position the typeball or type hammer), but this theory is also on shaky ground for the same reasons as above.

Many people also commented that it looks like a tab or margin stop, but so far I haven't managed to find any pictures of such use before IBM PCs launch in 1981. When I've asked the commenters to provide some sources, or name the devices, they've come empty handed. Maybe people remember them from word processors that came after 1981?

Sure enough, the margin stops in MS Word do resemble the house character quite a bit. But, this is a relatively recent development: the house-resembling-markers were added to Word in 1993 for version 6. Before that, MS Word indicated tab and margin stops with simple triangles, numbers, and square brackets.

What about other word processors? WordPerfect, indicated tab stops with ▲, and WordStar used the exclamation point (!). There is, however, IBM's own DisplayWrite program for DOS, which did use the house symbol to indicate the center line, but it came out in 1984, three years after the launch of IBM PC. It seems unlikely that IBM would have anticipated its use for this minor purpose, especially considering that IBM's earlier computer, the DisplayWriteR from 1980, indicated the center line, not with a house, but with a triangle.

Also, if the house was indeed intended to represent a margin or tab stop, then why didn't they add its glyph to code point 0x09, which is already standardized in ASCII as "horizontal tabulation"? And, ECMA-17 from 1968 already has a standardised graphical representation for horizontal tabs, which is a right arrow. All in all, while people might nowadays associate the house symbol with a tab marker, this association is quite likely based on their memories of MS Word or other modern word processors. There doesn't seem to be any concrete evidence of its use for this purpose before 1981. But I would gladly be proven wrong. If you know something more, send me an email: hlotvonen@gmail.com

Further reading

If you enjoyed this read, you might also want to check out the "main" article which digs deeper into the history of DEL character, and how it was represented and used in the Amiga computers. It's not quite as "juicy" of a story as this one, but interesting nonetheless: The origins of DEL (0x7F) and its Legacy in Amiga ASCII art

Footnotes

tl;dr: This article is a detailed (but not exhaustive) micro-history on the character DEL (0x7F) as it appears in Amiga's Topaz font ( ⌂ ), and how it was used in Amiga ASCII art between 1993–2005.

In part 1, "What is DEL", I try to form a comprehensive understanding of how DEL(ETE) originated as a way to obliterate errors on punched tape, and how it found use as a timing control for mechanical printers.

In part 2, "The graphics of DEL", I take a closer look at how normally non-printing characters, like DEL, were given a standardized graphical representation through ECMA-17 in 1968, and how DEL was actually represented in various early bitmap fonts between 1970s–1990s.

Part 3, "DEL in Amiga ASCII art", is about the particular shape and design of Topaz's ⌂. I analyze over 3000 Amiga ASCII artworks made between 1993–2005 to see how DEL was used, and showcase some of them.

I also wrote an bonus article focusing specifically on IBM PC's DEL: Why is there a "small house" in IBM's Code page 437?.

Keywords: DELETE character, Amiga ASCII art, textmode, bitmap fonts, character sets, control characters, ASCII, ECMA-17, punched tape, telegraph, ITA2

PART 1

What is DEL (0x7F)?

Introduction

One day I received an unexpected email from Michael Walden.

He had read my BA thesis on Amiga ASCII art and wanted to point out something curious that I had missed. The character set used in AmigaOS is identical to the ISO/IEC 8859-1 character encoding standard^[1], except for one character: the character at code point 0x7F.

This observation might seem trivial, but I was intrigued. This character has always been somewhat of a mystery to me. Let me explain…

Diagonals in Amiga ASCII Art

The default font of Amiga, Topaz, is really good for making ASCII art in "outline" style because many of its characters "touch" the edges of the 8×16 pixels-per-character cell. Slashes placed diagonally form a continuous slanting line, and rows of underscores form straight horizontal lines. Combined in a textmode grid, these characters can be assembled into an endless variety of shapes, forming the basis for the majority of Amiga ASCII art. The seamless connectivity of the glyphs, as a result of their systematic familiarity, is what makes the unique aesthetic of Amiga ASCII art:

Besides the slashes and underscores, there's a total of 256 characters to play with. Every diagonal in every character of Topaz follows the same basic rule: two pixels up, one to either side (e.g < > / \ % X Y Z K ^ 2 4)^[2]. All, except for one character: the character at code point 0x7F.

Topaz represents 0x7F as two diagonal lines ( ⌂ )^[3], which makes it very distinct compared to all the other characters because of its unusual angle: ⌂ is the only glyph where the diagonals go two pixels up and two pixels to the right. Because 0x7F doesn't follow Topaz's inherent geometric "rules", it doesn't tile well, which makes it tricky to use in Amiga ASCII art. It's like a puzzle piece that belongs to a different set, yet finding uses for it is an interesting challenge (I'll come back to this in part-3).

Is it a coincidence that the same character that deviates from the standards, is also the character that deviates visually from all the other characters? Or is there something more to it?

The Contradiction of a Non-Printable Glyph

As I was taking a closer look at the ISO/IEC 8859-1 standard, I realized that 0x7F is the code point for the control character DELETE (DEL), which is a non-printable character! To quote directly from Wikipedia, the Delete character "is supposed to do nothing"^[4], thus its graphical representation is supposed to be empty and undefined.

But... if DEL is supposed to do nothing, and look like nothing, then why does Topaz have a glyph for it? I would assume that if a character has a graphical representation, then it must have some meaning or function, right? But if so: what is it? What reasons did Topaz's designers have that justified diverging from the standards, and give DEL a distinct graphical representation? Why not follow the standards and just leave it empty?

Even though I had used ⌂ quite a bit in ASCII art, I had never realized that everything about this strange glyph—from its design to its mere existence—seemed to be in contradiction. Maybe Walden is onto something.

These questions kept bugging me, so I wanted to get to the bottom of understanding the reasons for ⌂ existence in Amiga's Topaz at the code point 0x7F. I wanted to know: what is 0x7F, and why does it look like it does? Because I'm mainly interested in the typographic and artistic application of Topaz in making Amiga ASCII art, I also wanted to know: what is the creative potential of ⌂ in Amiga ASCII art?

What is DEL?

What even is DEL? Why does it exist? What is its purpose?

Aivosto's comprehensive article on Control characters in ASCII and Unicode defines it as follows:

"Outdated. An ignorable character originally intended for erasing an erroneous or unwanted character in punched tape. In this standard use, DEL wouldn't affect the information content of data, even though it may have affected the information layout and the control of equipment. Standards also allowed DEL to be used as media-fill or time-fill (even though a NUL may be more appropriate)."

I roughly know what punched tape is, but I was born too late to truly understand how it was used, so this definition raises more questions than it answers. What does it mean it's outdated? What does it mean that it's ignorable? What does it mean that it "doesn't affect content, but may affect layout"? What is "control of equipment"? What are media-fill and time-fill? What is NUL and why would it be more appropriate? Wikipedia doesn't help much. The entry on Delete character states that "it is supposed to do nothing", while the 1987 C programmer's guide to serial communications^[5] says that DEL is like NUL in almost everything, but NUL is not interchangeable with the word "null", which is a synonym for "nothing". There's a lot of very confusing terms and concepts here.

To understand all this, and work my way up to answering the question of "why is DEL represented as ⌂ in AmigaOS", I needed to ask more basic questions: How did early telecommunication systems develop, and what effect did they have on the design of modern digital communications?

The Evolution of Character Encodings

It all starts in the early 1800s when scientists discovered that electric current could transmit signals nearly instantaneously over long distances, which lead to the idea of using it for sending messages. There was a problem though: how do you encode the alphabet into a format that could be sent over a wire, and reliably decoded and reconstructed on the other end?

There were multiple experiments, Morse code being the most successful at first. But, a more lasting and practical solution came in the form of character encoding systems developed during the mid 1800s. The grand idea was simple but ingenious: each character (a letter, number, or other typographic symbol) could be represented as a fixed-length sequence of binary digits (bits).

The 5-bit Code of ITA2

In the 1870s a French telegraph engineer, Émile Baudot, develops the Baudot code, and in 1901 Donald Murray refines it into what became known as ITA2 (International Telegraph Alphabet No. 2). ITA2 is a 5-bit code, which means that each character is assigned to a specific sequence of five bits.

On its own, five bits can represent only 32 elements (2⁵ = 32 code points), which is not quite enough to handle all letters, numerals and punctuation needed for basic communication in English. To alleviate the limited space available in five bits, ITA2 employs a "locking shift scheme" to switch between two modes: in letter mode bit sequences represent letters from the Roman alphabet, and in figure mode the same bit sequences represent numerals and various punctuation marks. This effectively doubles the amount of printable characters to 56 (some are reserved for special characters). The two shifts resemble the modern day use of the SHIFT key to access lowercase and uppercase characters.

ITA2 code was mostly used in special telegraph machines equipped with keyboards that were connected to tape perforators, typewriter-like printers, or both. A blank tape can be considered to contain only NUL characters, which are represented by five unpunched spaces (⓪⓪⓪⓪⓪). When an operator strikes a key, the tape perforator punches holes corresponding to the character, into the tape, overpunching the NUL characters. The pattern of five punched holes (❶❶❶❶❶) activates the letter mode and ❶❶⓪❶❶ activates the figure mode. Any binary sequence following a mode shift prints the character in that mode. For example, ⓪⓪⓪❶❶ prints A if letter mode is activated, or - (dash) if figure mode is activated instead.

Correction of Errors on Punched Tape

Writing messages like this is slow and error-prone. There is no "undo" on punching a hole through paper. A teleprinter manual from 1958 estimates that "in manually-prepared unchecked tape one error may be expected to occur in every 300 to 2000 characters."^[6], which seems like a lot, but is likely far fewer than what a typical person would make today.

Write the previous paragraph in the textbox below to see how few you errors make while typing (I've disabled the Backspace key):

If you made no mistake, congratulations! But more likely, you made at least one typo. Not being able to simply erase errors feels weird. Nowadays, with ubiquitous spell-checking and auto-correct, we take text deletion and editing for granted.

Obviously, even back in the day, operators needed some way to correct typing errors. With the original Baudot code, errors had to be literally cut out of the tape, and corrections pasted back^[7]. A simpler, and more common, practice was to follow an error with a recognizable character sequence e.g. EEE or XXX, although it caused uncertainty on "how far back" should be ignored^[8].

The improved ITA2 solved the problem with a clever trick: precisely because there is no "undo" on punching holes, all the operator has to do, is punch any erroneous part full of holes. This is done by reeling back the tape by pressing a lever, backtracking to the typo, and striking the letter-shift key (❶❶❶❶❶) over it. Conveniently, this action works on any character as they're all the same length in bits, and each includes at least one unpunched ⓪-bit.

What makes this solution so clever is how it exploits the fundamental way the telegraph system works. In normal operation, telegraph machines are kept idle in a "marking" state, with electrical current flowing continuously, producing a steady stream of ones (❶❶❶❶❶❶❶❶❶❶...). In this state, the machine doesn't advance the paper tape or cause any printing action; it does nothing. Only when the machine receives a zero bit (❶❶❶❶❶❶❶❶❶❶⓪...), it knows that a message is incoming.

So when the receiving machine encounters an all-ones pattern (❶❶❶❶❶) within a message, it either idles (just like in marking state) or, if it was in figure mode, shifts to letter mode. But if the machine is already in letter mode, shifting to letter mode again does nothing; the machine simply ignores those bits and continues from the next character. As a result, no trace of the deleted typo, not even a blank space, appears in the final printed message.^[9]

Here's a simplified ITA2 tape perforator simulator to demonstrate this. Try writing something. Press Reset to start a new message. ⨂ shifts to figure mode, and ⨀ shifts to letter mode. To correct a typo, Reel to the unwanted character, and press the letter mode symbol ⨀ on it.

The Usefulness of Wasting Time

Besides removing typing errors and shifting to letter mode, DEL is used as a "time-waster" character. Telegraph machines and teletypewriters typically process data at fixed timing intervals (like a metronome), rather than waiting for each operation to finish before starting the next one. This creates a timing problem: different operations take different amounts of time to complete. The DEL character solves this with its ability to tell the receiving machine to idle.

An operation that often needs such timing accommodations is when the printer carriage (= the mechanism that holds the paper) moves back to the left margin to start a new line, triggered by a combination of CR (carriage return) and LF (line feed). Because the horizontal movement of the carriage takes longer than the time it takes to process subsequent characters, the following character could be printed mid-movement, resulting in misaligned text (e.g., overlapping characters or text appearing at the wrong horizontal position). By inserting a DEL character right after CR and LF, the machine is instructed to idle for a brief moment, as the carriage completes its movement, before continuing printing. The processing delay caused by DEL characters, used to "synchronize" the data stream with the printer's physical capabilities, is why DEL is referred to as a "time-waster" or "time-fill" character.^[10]

For this reason, the ASCII standards also state that the "addition or removal of [DEL] characters may affect the information layout or the control of equipment, or both"^[11], meaning that DEL characters could have a very important role in determining where and when text is printed, and should not be removed from the data.

Understanding how DEL actually functions in telegraphy clears up the confusion I had about statements that DEL is "ignorable" and "supposed to do nothing". Because initially I was interpreting these terms through everyday language, I thought that "nothing" meant "unimportant", and "ignorable" to mean it could be deliberately disregarded. But in the context of paper tape, mechanical devices, and character encodings, these terms just describe how DEL should be processed. When DEL is called "ignorable", it's not worthless—it's a specific instruction for the machine to "skip the character without action". When it "does nothing", it's not useless—it's actively preventing other operations from occurring. DEL's usefulness comes precisely from its ability to exist in a data stream while causing no processing action—making it not an absence of function, but a function in itself.

ASCII immortalizes DEL

While ITA2 remained in use in telegraphy, the limited range of characters possible with 5-bit encoding was insufficient for the needs of emerging data processing technologies. By 1960, over 25 different character codes were used in computers and other systems in the US alone—most of them incompatible with each other. This created two pressing problems: individuals struggled to learn multiple, slightly different codes, while large organizations faced inefficiencies from maintaining incompatible systems that couldn't directly exchange data.^[15] A new unifying character set was urgently needed: one that would establish a standard for mapping bit combinations to characters. And so, in August 1960, this task was taken on by the American Standards Association (ASA), forming the X3.2 subcommittee on Coded Character Sets and Data Format.

The result was the American Standard Code for Information Interchange, a 7-bit (2⁷ = 128 code points) character encoding system better known by its acronym ASCII. In the 1960s, computers relied primarily on physical media like punch cards, paper tape, and teletypewriters, so ASCII dedicated 33 of the 128 code points for managing these devices. ASCII preserved the earlier convention from ITA2 in assigning the final code point (127, where all seven bits are ❶) to DEL, maintaining its function as a physical obliteration of an undesirable punching on paper tape.

Although ASCII only requires 7 bits, its values are commonly represented using two hexadecimal digits (equivalent to 8 bits). DEL's all-holes-punched pattern ❶❶❶❶❶❶❶ is thus padded with an extra ⓪-bit to become ⓪❶❶❶❶❶❶❶. In hexadecimal notation this pattern is written as 0x7F, where 7 represents the first four bits (⓪❶❶❶) and F the last four bits (❶❶❶❶). The prefix 0x is a convention from programming languages to denote hexadecimal numbers—without it, a value like 10 could be interpreted either as 10 (decimals) or 16 (hexadecimals).

ASCII became immensely popular in facilitating the transfer of textual information across various systems and devices. Almost all of computer and character encoding systems developed after 1960s are based on ASCII (or are mostly ASCII compatible, IBM's EBCDIC being a notable exception) for the first 127 code positions.^[16] ASCII remained the most commonly used character set on the Internet until 2007 when it was overtaken by UTF-8^[17]. Even though ASCII itself is not widely used anymore, Unicode inherits the ASCII code points, thus cementing DEL to the 0x7F position in perpetuity.

But, neither ASCII nor Unicode defines the graphical representation of DEL, because it's a non-printable character. So the question remains: why does Amiga represent DEL with a diagonally striped glyph?

PART 2

The Graphics of DEL

DEL gets a printing symbol

With the rise of digital data processing and computer programming in the 1960s, managing errors became essential. While typos in everyday documents are inconvenient, in programming, even a single mistake could lead to system crashes, mission-critical failures, or incorrect outputs. Most typing errors are noticed and corrected immediately. But what if the error is caused by an invisible control character like the DEL?

In a letter to the director of production development at the Teletype Corporation in 1962, British computer pioneer Hugh McGregor Ross suggests a solution to the problem: the normally non-printing DEL should have graphic representation, as a way to highlight errors in print:

"Experience shows that when these errors are being corrected it is all too easy to make further mistakes. It is considered most important that at all stages the occurence [sic] of any error, together with its correction, should be highlighted in some way to permit a third overall scrutiny and check. [...] To accord with the computer principle that all errors be highlighted, a printing symbol needs to be associated with the Delete character."^[18]

But which symbol? A 1960 Survey of Coded Character Representation by Bob Bemer ("the father of ASCII"), reveals that almost none of the roughly 70 machines at the time had a clearly defined printing symbol for DEL.^[19] An exception was the 1958 Ferranti Pegasus computer, which used a heavy asterisk (🞷) to represent obliteration.^[20] However, Ross, who worked at Ferranti, opposed this choice. Though he doesn't explicitly state his reasons, he may have worried that the asterisk could be misinterpreted, as it already had multiple different meanings and uses, but none that were strongly associated with deleting.

The symbol of shading

To replace the heavy asterisk, Ross proposed a "symbol of shading" to visually represent ERASE (aka DELETE). While working at Ferranti in 1961, he implemented this symbol for their 7-track flexowriters (= devices that combined a typewriter, printer, and paper tape puncher) used with the Orion and Atlas computer systems.^[21] The symbol also appears in his 1961 document Punched tape codes, where he proposed standardized encodings for paper tape. In his hand drawn designs, the symbol of shading for ERASE is represented by evenly spaced 45˚ diagonal lines—twenty three years before a strikingly similar design would appear to represent DEL at the same all-holes-punched position in Amiga's Topaz font.^[22]

The standardisation of DEL's representation in ECMA-17

Ross was active in promoting his ideas for character codes, so he joined the Technical Committee 1 (TC-1) committee at The European Computer Manufacturers Association (ECMA). TC-1's task was to define common character sets and their coded representations for input/output media and data transmission. In 1963, the committee officially decided that DEL should have a a printed representation^[23], and started working on assigning graphical symbols for all non-printing control characters. This allowed control characters to be analyzed, troubleshot and documented visually. Their work culminated in 1968 with the ECMA-17 standard, which introduced graphical symbols for control characters—including DEL and space. With this standard, Ross' design of evenly spaced 45˚ diagonal lines became the official representation for DEL. ^[24] The ECMA-17 standard was adopted into both US and international standards with minimal changes, becoming ANSI X3.32-1973 in the United States in 1973, and ISO 2047 internationally in 1975.^[25]

The adoption of the "symbol of shading" and ECMA-17

After Ross' proposal to represent DEL as a "symbol of shading" in 1961, it started to appear in other systems too, especially on ones based on "new" experimental technology.

Because electro-mechanical printers were extremely slow, with "print rates of perhaps 6 characters per second", and a typical calculation output being up to 100,000 characters long, printing would take an exessively long time. This frustration of having to wait for printouts lead to some eccentric inventions in search for speedier printing.^[27] The 1963 informational film produced by General Dynamics, The Mark of Man, demonstrates one such invention. Their high speed S-C 4020 plotter/printer works by using an obscure cathode ray tube (CRT) technology, called the Charactron. Unlike conventional CRTs, the Charactron displayed characters by shooting electron beams through stencilled characters etched on a tiny metal plate. And, in a scene emphasizing how these character matrices could be customized, Ross's distinctive diagonal-lined "symbol of shading" appears.^[28]

And then it appears again, in the Stromberg-Carlson S-C 5000 printer ("the first printer to start a fire") ^[29], produced somewhere between 1957 to late 1960s.

Charactron inspired other similarly weird tech, like Raytheon's Symbolray monoscopes, which were used to display graphics in their DIDS-400 computer terminals in 1967. Instead of drawing text directly on screen, it shot electron beams at a metal plate stencilled with tiny characters. The beams were "collected", and converted into an analog video signal corresponding to the stencil characters. Yet again, we can find Ross' symbol of shading in some of the Symbolray character sets.^[30]

DEL represented by a checkerboard symbol

Even though the Charactron and monoscope methods could display almost any kind of shape on screen (as long as there was a stencil made for it), they had a few fundamental problems. First, it was extremely difficult to accurately align the beams to hit the correct character stencils, and then to display it on the intended position on the screen. Even the smallest drift in the beam would degrade the clarity of the displayed text. Second, beam movement caused an annoying flicker and blurring.

To overcome these problems, a student at MIT in 1969 developed one of the first dot-matrix character generators for CRTs. Instead of using a character set stencil, the characters were generated as dots in a grid (typically 5 × 7) and stored in a solid state Read-Only Memory (ROM). With this approach, the electron beam was simply turned on or off based on the stored patterns during the raster scanning process, and could be used with any standard low-cost CRT (like TVs), while producing a much sharper text.^[31] Ross' symbol of shading is included in the scientific symbols set of this early dot-matrix character generator.

The trade-off for clarity and simplicity was a loss of fidelity in what kind of shapes could be drawn. Because the designs of these early bitmap fonts were constrained by their small cell sizes, often 5 × 7 pixels-per-character, the diagonal lines of the symbol of shading could not be rendered clearly anymore. If the diagonal lines were placed too close to each other, the character would end up looking more like a checkerboard symbol ( ▒ ) rather than clearly separate diagonal lines. But, while the checkerboard pattern didn't accurately resemble Ross' symbol of shading anymore, it still fulfilled its purpose as a symbol of shading.

The mass manufacture of character generator chips

During the 1970s computer components got smaller in size, their production costs reduced, and manufacturing volumes increased. This development lead to the mass production of desktop-sized computers. One such manufacturer of computer components was Motorola, who started producing cheap dot-matrix character generator ROM chips. Their 1975 MCM6570 character generator chip was based on the ECMA-17 standard, which included graphic symbols for all control characters and DEL, rendered again as a checkerboard pattern.^[32] In 1977, its successor, the MCM6674, was used in the TRS-80 Model I, one of the earliest mass-produced retail home computers.^[33]

Despite TRS-80's decent commercial success, it failed to make the symbol of shading, or any other ECMA-17 symbol, known to a wider audience. Even though the ECMA-17 symbols were present inside the MM6674 character generator chip, the TRS-80 wasn't capable of displaying them (or lowercase letters) without hardware modifications.^[34]. But even when modified (usually to enable those lowercase letters), the purpose of the ECMA-17 symbols were not understood very well. Even Motorola itself mistakenly advertised them as "math symbols"^[35]. This lack of awareness of the ECMA-17 symbols continues to this day: a recent TRS-80 cloning project calls them "hieroglyph-like"; the TRS-80 expert RetroStack calls them "odd symbols"; and "the most complete TRS-80 text font" by KreativeKorp misclassifies them as mathematical, technical or geometric shapes.

This confusion is understandable. The ECMA-17 symbols, including Ross' symbol of shading, were designed for paper tape and electromechanical systems (e.g. ⍾ symbolizing an electric bell), not digital displays. As TRS-80 was squarely a digital computer, the ECMA-17 symbols seemed like some cryptic artifacts, locked inside the TRS-80's character generator chip.

The legacy of DEL

Beyond appearing in the 1984 Amstrad CPC^[36], the ECMA-17 standard largely faded into obscurity. However, one of its 34 characters managed to endure: DEL. Even though graphical symbols for control characters 0–31 were not widely adopted, many systems and software continued to include the diagonal lines symbol (or a similar representation) at the 0x7F position.

This checkerboard pattern can be found in character sets for Apple II (1977)^[37], the dot-matrix printer based DECwriter III (1977)^[38], Exidy Sorcerer (1978), various systems that used the TMS9918 video display controller by Texas Instruments (1979)^[39], Elektuur Junior (1980), Kaypro II (1982), in many "RAMfonts" bundled with the Hercules Plus graphics card (1986), and in some software, like SEI Soft's FontEdit II (1994). Hewlett-Packard also had specifically designed "symbol sets" for printers, many of which included the checkerboard pattern at 0x7F, first appearing in 1978 in the HP Roman encoding.^[40]

An interesting example showing the utility of graphically representing control characters can be found from the 1983 remote display terminal system UNIVAC UTS 20. It included a line monitoring function, which displayed all characters graphically for "troubleshooting communications problems".^[41]

However, the graphic representation for DEL wasn't necessarily always a glyph of diagonal lines, or a checkerboard pattern. Some are close enough that the glyph's function remains roughly the same. For example, many Teletext character sets^[42], Mattel Aquarius^[43], Robotron Z9001, Otrona Attaché, the morse set of RM Nimbus PC-186 and Canon AS-100 (CP/M) among many display DEL as a full block ( █ ) instead. FM-Towns and the DEC VT220 terminal displays DEL as a glyph containing the letters "DL".

And then there's the 1981 IBM PC: its infamous Code Page 437 represents DEL as a "small house" ( ⌂ ). This is such a weird deviation from all other character sets that I had to write a separate article on it: Why is there a "small house" in IBM's Code page 437?

To get a more complete picture on how DEL appears in all the various microcomputer systems, I put together the following chart. It displays the graphical representation of 0x7F from 1259 character sets, compiled from Rob Hagemans' hoard of bitfonts and from VileR's VGA textmode fonts. It's ordered purely based on the visual properties of the characters. Click on the glyps to display more information about them. (Note that some characters might have extra whitespace around them which might not appear in real hardware.)

The overwhelming amount of ⌂ characters skews the chart, but if we disregard those and compare the remaining sets, it seems clear that the standard choice for visually representing DEL was either as a symbol of shading in the form of diagonal lines ( ⌂ ), checkerboard ( ▒ ), full block ( █ ), or as a symbol combining the letters DT, DL or 7F.

The graphical representation of DEL in Amiga's Topaz fonts

Amiga computers were produced in a few different models by Commodore from 1985 until the company's bankruptcy in 1994. When the Amiga first starts up, the only fonts available to use are Topaz-8 and Topaz-9, both of which are stored in the "Kickstart" Read-Only Memory (ROM).

The number, Topaz-8, refers to the font's height, which means that the font is actually 8×8 pixels-per-character in size, and not 8×16 as I claimed in the introduction. But, because Amiga's default video mode was 640×200 (NTSC) or 640×256 (PAL), each pixel was "stretched" vertically to fill the screen. This meant that, in effect, each pixel had an aspect ratio closer to 2:1, resulting in the font looking like it was 16 pixels tall. This is the reason for it's modern appearance as a 8×16 px font, and for its consistent look and two-pixel line thickness. So, the raw ROM version of the characters like the slash ( / ) have diagonals at 45˚ angle, while DEL doesn't. But when stretched to 2:1, the DEL gets transformed into its more familiar 45˚ diagonal lines form ⌂.

The Kickstart firmware has seen several updates since its release. Alongside those updates, Amiga's Topaz fonts have also gone through an evolution. The original serif versions of Topaz (Kickstart versions up to 1.4) were designed by Bob Burns and the original sans-serif versions (Kickstart versions from 1.4 onwards) were designed by Peter J Cherna.^[44]

When comparing the differences between each Kickstart version, I was surprised to find out that Topaz-8 initially rendered DEL as a checkerboard, from Kickstart 0.7 (released in 1985) until Kickstart 1.4 (released in 1990).^[45]

On the other hand, the Topaz-9 font has always included the same diagonal lines symbol for DEL.

Conclusion on the graphics of DEL

This research originated from Michael Walden's claim that the AmigaOS character set is identical to the ISO/IEC 8859-1 standard, except for the DEL character. This lead to the follow-up questions, why does Topaz have a glyph for DEL, and why represent it as diagonal lines. I didn't expect I'd be writing nearly 14,000 words to answer these questions, but I think I've finally come to a conclusion.

As the evolution of the diagonal lines glyph ⌂ is traced throughout the history, from Hugh McGregor Ross's proposal for DEL to be represented as a "symbol of shading" in 1961, to its standardisation in ECMA-17 in 1968, and to its adoption in so many different character sets, AmigaOS's choice for representing DEL as diagonal lines doesn't seem like an outlier after all. Instead, it's clear they were just following a decades long convention. On the other hand, nearly every bitmap font since the first dot-matrix character generator in 1969 (that represented DEL with some kind of "symbol of shading), rendered DEL as a checkerboard. To my knowledge, Amiga is the first to actually represent DEL as Ross had intended it, with diagonal lines. Was Topaz's designer, Bob Burns, aware of ECMA-17, or was it just coincidental attempt to represent "shading" somewhat differently? This question remains open.

Then, coming back to Walden's claim: does AmigaOS follow the ISO/IEC 8859-1 standard or not? Or perhaps a more accurate question is: if a character code standard like ISO/IEC 8859-1 doesn't explicitly define a graphical representation for a character (like DEL), but a system like Amiga implements its own graphical representation (based on another standard, like ECMA-17), is it compliant with the standard or not? The answer might simply be a matter of perspective. Keeping in mind that character encoding standards are primarily concerned with the binary values attached to characters and their semantic meaning or function and not their exact rendering, and that by definition DEL's graphical representation is undefined, and that DEL was also largely obsolete by 1980s, yet still an inseparable piece of the ASCII standard, then representing DEL visually might not be strictly compliant with ISO/IEC 8859-1, but also not contradicting it. Therefore, I think that AmigaOS does follow the ISO/IEC 8859-1 standard, just extends it in a standards-compatible and useful way, by visually representing DEL with the checkerboard/diagonal lines glyph.

What does the Delete key do?

At this point I had still one lingering question in mind regarding the DEL character. I know what DEL is. I know why it can have a graphical reprsentation. But, how do I actually input or use the DEL character?

My Windows keyboard has a key for Delete, Del and Backspace, and my Mac keyboard has a Delete key where Backspace usually is. On the Windows keyboard, when I press the Backspace key, the character to the left of the cursor is deleted, and when I press Delete, the character to the right of the cursor is deleted. On Mac it's the opposite, pressing Delete removes the character to the left, but I can do Fn+Delete to forward delete. I can also press Ctrl+H to delete backwards, or Ctrl+D to delete forwards. On Windows, the Numpad Del does a forward delete if Numlock is off. But how are they related to the DEL character? If I have a font with a graphical representation for DEL, how can I type it?

BS and DEL

The answer is rather complicated and confusing, and starts with understanding how DEL was used in conjunction with backspace. To recap, a common way to backwards delete on paper tape was to move the tape back by pressing a backspacing lever and then overpunch with the all-holes Delete. Initially the backspacing lever itself didn't punch anything, it would just move the tape, but later on it became its own character (BS at 0x08). This was necessary to achieve overprinting on initial punchout and any subsequent print-outs. Overpunching was useful feature for multiple reasons, most commonly to achieve diacritics. As an example, u BS ^ would produce û, and u BS _ underlined u.

BS was also combined with DEL to produce backwards delete. But this posed a difficulty on how computers should interpret DEL during tape editing and subsequent print-outs. When the tape is first created, the simultaneous print shows the original erroneous character, then the DEL character on top of that. But any subsequent print-out shows only the DEL character, because the original incorrect character didn't exist anymore—it was physically and permanently transformed into a DEL character. A technique called "line reconstruction" was developed to overcome this, based on a few simple rules: never manually move the carriage, and all print-outs should match what's on the tape. With these rules in mind, the computer could be programmed to read the data to a buffer (without immediately printing them), then processing it sequentially, so that BS moves backwards in the buffer, and DEL overwrites the position. After the buffer process is completed, the line is printed, ignoring any DEL characters.^[46]

DEL vs Backspace

The differing interpretations on how to deal with DEL in various media had lasting effects. What worked on paper-based media proved problematic for the digital screen-based text input and output. Ultimately, the question on how exactly to use and interpret DEL was (and still is) context dependent, lacking a clear consensus.

The many varied and contradicting functions, interpretations and implementations of DEL is a total mess. So, when I press the Delete key on my keyboard, the keyboard sends a scan code for the Delete key, the operating system translates this to virtual key code based on the currently active keyboard layout, and this virtual key code is interpreted differently based on the application—and this could be literally anything from printing the DEL character to deleting a file. The physical key has nothing to do with the ASCII DEL character, other than having a shared history and name.

DEL in AmigaOS

But what about Amiga then? When the Delete key is pressed on an Amiga system, the raw keycode is translated by the system into the ⌂ character OR action based on the current keymap and console device handling. To my knowledge, by default it invokes a CSI escape sequence that deletes the character to the right of the cursor.

The raw keycode can be captured though, as noted in the Amiga 500 user manual: "Keys can be program-controlled-that is, their use can be defined by the software being used".^[49] One could program a software to find any non-printable character and return 0x7F, displaying the ⌂ character. This is the case for example in the RAWKEY keymapping example on AmigaOS wiki^[50] which is a program that converts raw keycodes to ASCII, and replaces any unprintable or control characters with ⌂. In this program, printing the DEL key as a visually highly distinct character is more informative than printing nothing, a space, or a string of escape sequences from directly outputting control characters.

To help with inputting characters, the Amiga Workbench 3.1 has a menu option to "Insert ASCII" by providing the index (0-255) of the character's code point. If I wanted to insert 0x7F, I would write 127 in the prompt.

But when I draw Amiga ASCII art on macOS using contemporary specialized ASCII editors (like Moebius), all the characters are simply listed in a table which can be mapped to function keys F1–F12.

Displaying Amiga ASCII art on the web

Nowadays to actually type the character at code point 0x7F requires the use of "alt codes". On Windows, this can be done by holding down the Alt key, then typing the decimal number of DEL 127 using the keyboard's numeric keypad, and then releasing Alt. On Mac this is not possible by default, but can be done by enabling Unicode Hex Input as text input source (instructions), then holding down the Option key, then typing the Unicode hexadecimal of DEL 007f, and then releasing Option. These will produce the code 0x7F.

However, displaying the glyph at 0x7F is not always possible—it's wholly dependent on the application. For example, here's DEL (0x7F) using the Topaz font: . If you view this on Chrome, you will see the glyph. However, if you view this on Firefox, it will not display, because it's blocked at the browser level (for what reason I don't exactly know). On the web, it's more common to display Unicode characters using HTML entities like  or , but these methods produce the generic symbol for "unrepresentable character", even on Chrome: � �. Using a Javascript snippet document.write(String.fromCharCode(0x7F)); displays the glyph correctly on Chrome, but not on Firefox: .

This is of course a big problem for displaying Amiga ASCII art containing DEL characters on the web. Even asciiarena.se, THE website dedicated to archiving, sharing and displaying Amiga ASCII art, haven't been able (or aren't bothered) to solve this issue. Artworks containing DEL characters simply don't display them. For example, the rendering for SNAFUALV.TXT by sNAFu from 1995 is completely broken on the site. (However, the artworks on asciiarena.se could be shown correctly at least on Chrome, but the DEL glyph is not even assigned to any code point in the Topaz font they use.)

The other option, as employed by the site 16colo.rs, is to render ASCII art as images (see for example h7-impure.txt by h7 from 2021). This preserves all formatting and special characters like DELs, but it's slightly disappointing that ASCII art, which is supposed to be just text, is displayed as images.

ASCII to Unicode

Is there really no way to display ASCII art, including DEL characters, reliably as text on the web?

The answer is no, if we want to use the original code points. But a way to preserve ASCII art as text, while being able to display DEL and other control characters, is to convert the troublesome characters to their Unicode equivalents or best-fit approximations. A similar glyph to ⌂ could be ▨ (U+25A8), 🮙 (U+1FB99), ␥ (U+2425), ▒ (U+2592), 🮕 (U+1FB95) or maybe it could even be mapped to ␡ (U+2421). In 2022 the Terminals Working Group at Unicode made a Proposal to add further characters from legacy computers and teletext to the UCS^[51], adding hundreds of new graphic characters to provide compatibility with a wide range of home computers manufactured from the mid-1970s to the mid-1980s. Even though Amiga was not among them, three new specific symbols for delete were added: symbol for delete in the Apple II character set ␧ (U+2427), in the TRS-80 character set ␨ (U+2428), and in the Amstrad CPC character set ␩ (U+2429). These were accepted to Unicode version 16.0 which was officially released just last year in 2024. In my opinion, the closest graphic approximation for Topaz's DEL would be 🮙 (U+1FB99), but its name is a generic "upper right to lower left fill", while semantically better fit would be the new ␩ (U+2429), which is a "symbol for delete medium shade form".

Converting ASCII to Unicode is not trivial though. There needs to be some program or process to do it, and the font needs to map the right Unicode values to the corresponding glyphs.

For this site I ended up using a much simpler, although improper, method. My preferred ASCII art tool Moebius, which is predominantly programmed for creating PC ANSI art, already has an ASCII to Unicode conversion feature. I can either save the file as "Unicode ANSI", or simply copy-paste from the program to another text editor, and it will convert any control characters to Unicode. However, PC ASCII uses IBM's code page 437, so the conversion is specific to it. For example, 0x7F gets automatically converted to the Unicode equivalent of code page 437's symbol for DEL ( ⌂ ) at U+2302, rather than to any of the aforementioned symbols that would better fit Amiga's DEL symbol. The ease of use is too great for me to care though, especially because semantic correctness for control characters is not a priority (for me) in Amiga ASCII art.

To then display ASCII art on the site, I made a font of Topaz glyphs, and mapped the ⌂ glyph to U+2302. This way I can make Amiga ASCII art with Moebius, then simply copy paste it to my code editor, wrap it with a <pre class="amiga"> element, give it two lines of CSS, and it just works:

.amiga {
  font-family: 'Topaz_Plus_a1200_CP437';
  line-height: 1;
}

(Additionally, I made a web component that uses regular expressions to find escape sequences and transforms them to <span class="fgX bgX"> elements to display ANSI colored Amiga ASCII.)

PART 3

DEL in Amiga ASCII art

Scanning the archive for DEL

Inspired by this whole research, I downloaded an archive of Amiga ASCII art containing 3153 works made between 1992 to 2015, and wrote a script scanning them for the DEL character. The script found DEL used on 15617 lines of text in 410 different files, which is a lot more than I expected. But on a closer look, the actual number of files with unique uses is probably closer to a few hundred because many files contained repeated uses of the same few ASCII logos, adverts or images. (The complete results can be found here)

The earliest file containing DEL is from 93, although the character is actually used in a BBS advert added in 1995. Therefore, the earliest deliberate use as part of ASCII art seems to be from 1994. The files are not properly dated, so it's impossible to say who used it first, but an ASCII artist called "xClUZiWe" or "xcz" was among the first to use it frequently and with purpose. The use of DEL in Amiga ASCII art properly took off in 1995, continuing strong all the way to 1999. From 2000 onwards, it's seen less and less as the whole ASCII scene started fading. Since around 2015 Amiga ASCII art has experienced a slight resurgence, as has the use of DEL, but I wanted to focus on the historic use of DEL, so I didn't include art made after 2010s in my search.

Below I have curated a selection of artworks that incorporate DEL in one way or another. The files are grouped by year. The individual artworks are usually part of larger collections ("collys"), some of which have a unified layout or theme. Crudely copy-pasting them here inevitably removes them from their original contexts, so I recommend viewing them in full using a dedicated ASCII software. For this the Windows only ASCII art editor / viewer PabloDraw is best, as it includes a browsable folder view.

If trying to spot the ⌂ characters is too time consuming, clicking on the ASCII art highlights the DEL characters! Other than that, I will let the art speak for itself. Enjoy!

1994

1994/dss_xcz!.txt

1994/pss_rw.txt

1994/xcz-phq.txt

1995

1995/cor-vns.txt

1995/ds!-hopp.txt

1995/ds!-bob4.txt

1995/cnb-sch.txt

1995/snafualv.txt

First colly in which the 0x7F is used extensively as the "main" character. It's completely broken on (asciiarena.se)[https://www.asciiarena.se/release/SNAFUALV.TXT]

1995/-t-satc3.txt

1995/e^d-name.txt

1995/e^d-blc.txt

1995/os!-isbm.txt

The colly includes "Ping Pong" and Pac-Man in a similar style.

1995/m's-sign.txt

1996

1996/os!-eotw.txt

1996/ed_fc.txt

1996/-t-ap3e.txt

1996/beuty.txt

1996/hos-dts!.txt

1996/-t-loved.txt

1996/-t-tatf2.txt

1996/-t-tatf3.txt

1996/e^d-t0!7.txt

1996/e^d-barc.txt

1997

1997/u'r-bomb.txt

1997/se-atrip.txt

1997/se-pain.txt

1997/p^d-ambb.txt

1998

1998/la!-mia.txt

1998/l124-iso.txt

1998/l124-m98.txt

1998/la!-tdh.txt

1998/dzn-pac.txt

1998/blz-devs.txt

1998/cp!-hom.txt

1999

1999/k0-st8wa.txt

1999/sea-erre.txt

1999/la-cld.txt

1999/c½w-purefeelings.txt

1999/c½w-purefeelings.txt

1999/c½w-klam.txt

2000

2000/lot-rave.txt

2000/lot-noco.txt

2001

2001/1oo-apoc.txt

Further readings

There's a lot more to say about DEL, especially about the technical aspects of character codes. I left most of that out on purpose to center my attention on the visual aspects of the glyph. However, if you are interested, there are many well written and extremely detailed articles on the minute details of telegraph machines, character code standards, control characters, early computing history and so on.

On coded character sets and ASCII, there's the massive 535 page Coded Character Sets, History and Development by Charles E. Mackenzie (1980), the slightly more approachable An annotated history of some character codes by Tom Jennings (1999, last update 2023) and The Evolution of Character Codes, 1874-1968 by Eric Fischer (2000). Aivosto's Control characters in ASCII and Unicode (2011, last update 2022) is an excellent and in-depth look focused on control characters. David M. MacMillan's Codes that Don't Count is more about the telegraph codes with a particular attention on Teletypesetters. The most invaluable source of material has been Source documents on the history of character codes compiled by Eric Fischer and shared gratuitously on the Internet Archive. But if I were to recommend something more "enjoyable" and thought-provoking to read, it would be The machine in the ghost: digitality and its consequences by Robin Boast (2017), which takes a more social and human approach to the developments of digital communication.

For texts on ASCII, there's not much unfortunately. On text art, there's WiderScreen's 2017 issue on text art as both an object of study and artistic work, and the book From ASCII Art to Comic Sans: Typography and Popular Culture in the Digital Age by Karin Wagner (2023). VileR has a great article on Game Font Forensics (2024) which has a somewhat similar theme investigating old bitmap fonts. On Amiga ASCII art specifically, there's my own BA thesis on Amiga ASCII art from 2015, which I translated to English and published here on my blog in 2023.

Footnotes

The problem

I have been trying to identify practical reasons why hand-coding websites with HTML and CSS is so hard (by hand-coding, I mean not relying on frameworks, generators or 3rd party scripts that modify the DOM).

Let's say, I want to make a blog. What are the actual things that prevent me from making—and maintaining—it by hand? What would it take to clear these roadblocks?

There are many, of course, but for a hand-coded programming oriented blog one of these roadblocks is syntax highlighting.

When I display snippets of code, I want to make the code easy to read and understand by highlighting it with colors. To do that, I would normally need to use a complex syntax highlighter library, like Prism or highlight.js. These scripts work by scanning and chopping up the code into small language-specific patterns, then wrapping each part in tags with special styling that creates the highlighted effect, and then injecting the resulting HTML back into the page.

But, I want to write code by hand. I don't want any external scripts to inject things I didn't write myself. Syntax highlighters also add to the overall complexity and bloat of each page, which I'm trying to avoid. I want to keep things as simple as possible.

Leveraging OpenType features to build a simple syntax highlighter inside the font

This lead me to think: could it be possible to build syntax highlighting directly into a font, skipping JavaScript altogether? Could I somehow leverage OpenType features, by creating colored glyphs with the COLR table, and identifying and substituting code syntax with contextual alternates?

<div class="spoilers">
  <strong>Yes, it's possible!</strong>
  <small>...to some extent =)</small>
</div>

The colors in the HTML snippet above comes from within the font itself, the code is plain text, and requires no JavaScript.

To achieve that, I modified an open source font Monaspace Krypton to include colored versions of each character, and then used OpenType contextual alternates to essentially find & replace specific strings of text based on HTML, CSS and JS syntax. The result is a simple syntax highlighter, built-in to the font itself.

If you want to try it yourself, download the font: FontWithASyntaxHighlighter-Regular.woff2

And include the following bits of CSS:

@font-face {
  font-family: 'FontWithASyntaxHighlighter';
  src: 
    url('/FontWithASyntaxHighlighter-Regular.woff2') 
    format('woff2')
  ;
}
code {
  font-family: "FontWithASyntaxHighlighter", monospace;
}

And that's it!

What are the Pros and Cons of this method?

This method opens up some interesting possibilities...

Pros

1. Install is as easy as using any custom font.
2. Works without JavaScript.
3. Works without CSS themes.
4. ...but can be themed with CSS.
5. It's fast.
6. Snippets of code can be put into <pre> and <code>, with no extra classes or <span>s.
7. Clean HTML source code.
8. Works everywhere that supports OpenType features, like InDesign.
9. Doesn't require maintenance or updating.
10. Works in <textarea> and <input>! Syntax highlighting inside <textarea> has been previously impossible, because textareas and inputs can only contain plain text. This is where the interesting possibilities lie. As a demo, I made this tiny HTML, CSS & JS sandbox, with native undo and redo, in a single, web component.

Cons

There are, of course, some limitations to this method. It is not a direct replacement to the more robust syntax highligting libraries, but works well enough for simple needs.

1. Making modifications to the syntax highligher, like adding more language supports or changing the look of the font, requires modifying the font file. This requires some knowledge of font production, which most people don't have.

2. It only works where OpenType is supported. Fortunately, that's all major browsers and most modern programs. However, something like PowerPoint doesn't support OpenType.

3. Finding patterns in text with OpenType contextual alternates is quite basic, and is no match for scripts that use regular expressions. For example, words within <p> tags that are JS keywords will be always highlighted: <p>if I throw this Object through the window, catch it, for else it’ll continue to Infinity & break</p>.

4. Multiline highlighting with manual line breaks will sadly not work.

   This is common, for example, in comment blocks and template literals:

    <!-- This line gets highlighted...
    but not this, because I made a manual line break...
    -->
   

How does it actually work?

Here's roughly how it works. There are two features in OpenType that make this possible: OpenType COLR table and contextual alternates.

OpenType COLR table

OpenType COLR table makes multi-colored fonts possible. There is a good guide on creating a color font using Glyphs.

I made a palette with 8 colors.

I duplicated letters A – Z, numbers 0 – 9 and the characters . # * - and _ four times. Each duplicated character is then suffixed with .alt, .alt2, .alt3 or .alt4, and then assigned a color from the palette. For example, all .alt1 glyphs are this color.

I also duplicated all characters twice, and gave them suffices .alt1 and .alt5 and assigned them colors used in <!-- comment blocks --> and "strings within quotes"

The two other colors I used for symbols & | $ + − = ~ [] () {} / ; : " @ % and ', and they are always in one color. Numbers 0 1 2 3 4 5 6 7 8 9 are also always a certain color, unless overriden by other rules.

OpenType contextual alternates

The second required feature is OpenType contextual alternates. Here's a great introductory guide to advanced contextual alternates for Glyphs.

Contextual alternates makes characters "aware" of their adjacent characters. An example would be fonts that emulate continuous hand writing, where how a letter connects depends on which letter it connects to. There is a nice article covering possible uses here.

JavaScript syntax rules

The core feature of contextual alternates is substituting glyphs. Here is a simplified code for finding the JavaScript keyword if and substituting the letters i and f with their colored variant:

sub i' f by i.alt2;
sub i.alt2 f' by f.alt2;

In English:

1. When i is followed by f, substitute the default i with an alternate (i.alt2).
2. When i.alt2 is followed by f, substitute the default f with an alternate (f.alt2).
3. As a result, every "if" in text gets substituted with if.

OpenType doesn't support many-to-many substitutions directly, but @behdad on Mastodon had a great suggestion: keywords could be elegantly colored by chaining contextual substitutions.

To do this, I made a lookup which substitutes each letter with its colored variant.

lookup ALT_SUBS {
    sub a by a.alt; 
    sub b by b.alt; 
    sub c by c.alt; 
    [etc.]
    sub Y by Y.alt;
    sub Z by Z.alt;
} ALT_SUBS;

I moved this lookup rule to the Prefix section, which just means it doesn't get applied automatically unlike the other lookups.

Then, I made a lookup rule for each keyword in the contextual alternates section. Here's one for console:

lookup console {
    ignore sub @AllLetters c' o' n' s' o' l' e';
    ignore sub c' o' n' s' o' l' e' @AllLetters;
    sub c' lookup ALT_SUBS
        o' lookup ALT_SUBS
        n' lookup ALT_SUBS
        s' lookup ALT_SUBS
        o' lookup ALT_SUBS
        l' lookup ALT_SUBS
        e' lookup ALT_SUBS;
} console;

First two lines tells it to ignore strings like Xconsole or consoles, but not if there's a period like console.log().

The third line starts by replacing the first letter 'c' with its colored variant c, by using definitions from the other lookup table "ALT_SUBS". This repeats until each letter is replaced by its color variant, and the result is console.

Identifying JavaScript keywords is fairly straightforward. Logic is the same for each keyword, and I used a python script to generate them.

HTML & CSS syntax rules

But for HTML and CSS... I had to get a bit more creative. There are simply too many keywords for both HTML and CSS combined. Making a separate rule for each keyword would inflate the file size.

Instead, I came up with this monstrosity. Here's how I find CSS value functions:

lookup CssParamCalt useExtension {
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' @CssParam parenleft by @CssParamAlt4;
  sub @CssParam' parenleft by @CssParamAlt4;
} CssParamCalt;

@CssParam is a custom OpenType glyph class I've set up. It includes the characters A – Z, a – z, and -, which are all the possible characters used in CSS value function names. Because the longest possible CSS value function name is repeating-linear-gradient(), with 25 letters, the first line of the lookup starts with @CssParam repeated 25 times, followed by parenleft ((). This lookup will match any word up to 25 letters long, if it's immediately followed by an opening parenthesis. When a match occurs, it substitutes the matched text with its alternate color form (@CssParamAlt4).

This lookup works for both CSS and JavaScript. It will colorize standard CSS functions like rgb() as well as custom JavaScript functions like myFunction(). The result is a semi-flexible syntax highlighter that doesn't require complex parsing. The downside is that if you have a really long function name, it stops working midway: aReallyLongFunctionNameStopsWorkingMidway(). I've repeated the same principle for finding HTML tags and attributes, and for CSS selectors and parameters.

Unknown length rules

Comment blocks and strings between quotes also required extra care, because their length can be anything. OpenType doesn't support loops or anything resembling regular expressions. For example, I can't just tell it to simply substitute everything it finds between two quotes.

However, I got a great suggestion from @penteract on Hacker News to use a finite state machine for these kinds of situations. Here our aim is to colorize eveything between /* and */ gray:

lookup CSScomment useExtension {
  // stop if we encounter a colored */
  ignore sub asterisk.alt1 slash.alt1 @All';

  // color first letter after /*
  sub slash asterisk @All' by @AllAlt1;
  sub slash asterisk space @All' by @AllAlt1;
  
  // color /* itself
  sub slash' asterisk by slash.alt1;
  sub slash.alt1 asterisk' by asterisk.alt1;
  
  // finite state machine to color rest of the characters
  // or until ignore condition is met
  sub @AllAlt1 @All' by @AllAlt1;
} CSScomment;

The last line is the important one. The lookup will just continue replacing characters if the previous character is already colored.

End note

The full process is a little bit too convoluted to go into step-by-step, but if you're a type designer who wants to do this with their own font, don't hesitate to contact me.

I'm also not an OpenType expert, so I'm sure the substitution logics could be improved upon. If you're interested in learning more about OpenType, I recommend reading The OpenType Cookbook and the complete OpenType™ Feature File Specification.

If you have any ideas, suggestions or feedback, let me know. You can reach me at hlotvonen@gmail.com or leave a comment on Mastodon.

Changing the color theme

You can change the color theme with CSS override-colors! Browser support is great at ~94%.

Alternative built-in color themes

Additionally, two alternative color themes Night Owl, and Light Owl were added by niutech. You can download them from the FontWithASyntaxHighlighter GitHub page. Night Owl theme is made by Sarah Drasner.

In order to modify the built-in color palette, you have to edit the font source file. To do so, you can edit the color palettes values in lines 112-120 of the FontWithASyntaxHighlighter.glyphs file and then build the font with fontmake.

Projects using this font

Here's some cool projects that are using or are inspired by this font:

1. Holograph is a visual coding tool built on tldraw & its GitHub page
2. @celine/celine is library for building reactive HTML notebooks & its GitHub page & blogpost
3. Shaders art made with pure CSS & its GitHub Page
4. Mdit, a simple Markdown previewer & its GitHub Page
5. Web Component for making a Textarea element into a syntax highlighted codeblock
6. It might also be used as an example for displaying the potential uses for color fonts in the W3C CSS Fonts Module Level 4 specification
7. Web Component with syntax highlighting
8. An OpenType font with built-in TEX syntax highlighting
9. Labelary ZPL viewer & editor
10. garten.salat.dev blog
11. L’invasion du HTML mutant
12. (Did you make a project using this font, or know a project that uses it? Let me know please!)

Potential future

Many people suggested that this concept could be taken one step further with harfbuzz-wasm. With harfbuzz-wasm a real parser could be used instead of my crazy opentype lookup rules. Essentially, all the cons could be eliminated... Any harfbuzz-wasm experts who wants to take this on?

Licence

The original font (MonaSpace) has SIL open font license v1.1, which carries over to my modified version. So, you're free to use the font in any way that the SIL v1.1 license permits.

As for the code examples, they are MIT licensed. The tiny sandbox web component can be found here: https://github.com/hlotvonen/tinybox

Source

The original source .glyphs file is hosted in this GitHub repository. UFO files were kindly added by niutech. Or, you can modify the font with some scripting & build with fontmake.

More examples

as, in, of, if, for, while, finally, var, new, function,
do, return, void, else, break, catch, instanceof, with,
throw, case, default, try, switch, continue, typeof, delete,
let, yield, const, class, get, set, debugger, async, await,
static, import, from, export, extends

true, false, null, undefined, NaN, Infinity

Object, Function, Boolean, Symbol, Math, Date, Number, BigInt, 
String, RegExp, Array, Float32Array, Float64Array, Int8Array, 
Uint8Array, Uint8ClampedArray, Int16Array, Int32Array, Uint16Array, 
Uint32Array, BigInt64Array, BigUint64Array, Set, Map, WeakSet,
WeakMap, ArrayBuffer, SharedArrayBuffer, Atomics, DataView, 
JSON, Promise, Generator, GeneratorFunction, AsyncFunction, 
Reflect, Proxy, Intl, WebAssembly, Error, EvalError, InternalError, 
RangeError, ReferenceError, SyntaxError, TypeError, URIError, 
setInterval, setTimeout, clearInterval, clearTimeout, require, 
exports, eval, isFinite, isNaN, parseFloat, parseInt, decodeURI, 
decodeURIComponent, encodeURI, encodeURIComponent, escape, 
unescape, arguments, this, super, console, window, document, 
localStorage, sessionStorage, module, global

<!-- this is a comment! -->
/* and this */
// and this
<!-- however...
it breaks when your code goes to a newline.
there's no way to keep context line to line...
-->

<!-- can't disable highlighting JS keywords in between tags -->
<p>
  give me a break...
</p>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Syntax Highlighter Example</title>
  <style>
    body {
      background-color: rgb(255, 0, 0);
      font-family: 'Arial Narrow', sans-serif;
      line-height: 1.44;
      color: #333;
    }
  </style>
</head>
<body>
  <header>
    <h1>Welcome to the Syntax Highlighter Test</h1>
  </header>
  <nav>
    <ul>
      <li><a href="#section1">Section 1</a>
    </ul>
  </nav>
  <main>
    <section id="section1">
      <h2>Section 1</h2>
      <p>This is a <span class="highlight">highlighted</span> paragraph.</p>
      <img src="/api/placeholder/300/200" alt="Placeholder image">
    </section>
  </main>
  <script>
    console.log("This is a JavaScript comment");
    function greet(name) {
      return `Hello, ${name}!`;
    }
    document.addEventListener('DOMContentLoaded', () => {
      console.log(greet('Syntax Highlighter'));
    });
  </script>
</body>
</html>

.crazyBackground {
  /* don't try this at home */
  background:
    radial-gradient(
      100% 50% at 50% 50%,
      hsl(90 90% 45%) 0% 5%,
      hsl(250 70% 40%) 50%,
      hsl(50 50% 50%)
    ),
    radial-gradient(
      100% 100% at 50% 25%,
      hsl(90 40% 85%) 30%,
      hsl(40 80% 20%) 60% 90%,
      transparent
    ),
    linear-gradient(
      90deg,
      hsl(150 90% 90%) 0 10%,
      hsl(10 10% 20%),
      hsl(150 90% 90%) 90% 100%
    )
  ;
  background-size:
    5% 10%,
    10% 200%,
    25% 100%
  ;
  background-blend-mode:
    color-dodge,
    difference,
    normal
  ;
  animation: fire2 60s linear infinite;
}

@keyframes fire2 {
  from {
    background-position: 0% 0%, 0 30%, 0 0;
  }

  to {
    background-position: 0% -100%, -100% 30%, 200% 0%;
  }
}

// Variables and constants
let variable = 'Hello';
const CONSTANT = 42;

// Template literals
const name = 'World';
console.log(`${variable}, ${name}!`);

// Function declaration
function greet(name) {
  return `Hello, ${name}!`;
}

// Arrow function
const multiply = (a, b) => a * b;

// Class definition
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  sayHello() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

// Object literal
const config = {
  apiKey: 'abc123',
  maxRetries: 3,
  timeout: 5000
};

// Array methods
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(num => num * 2);
const sum = numbers.reduce((acc, curr) => acc + curr, 0);

// Async/await
async function fetchData(url) {
  try {
    const response = await fetch(url);
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

// Destructuring
const { apiKey, maxRetries } = config;
const [first, second, ...rest] = numbers;

// Spread operator
const newArray = [...numbers, 6, 7, 8];

// Conditional (ternary) operator
const isAdult = age >= 18 ? 'Adult' : 'Minor';

// Switch statement
function getDayName(dayNumber) {
  switch (dayNumber) {
    case 0: return 'Sunday';
    case 1: return 'Monday';
    // ... other cases
    default: return 'Invalid day';
  }
}

// Regular expression
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

// Symbol
const uniqueKey = Symbol('description');

// Set and Map
const uniqueNumbers = new Set(numbers);
const userRoles = new Map([['admin', 'full'], ['user', 'limited']]);

// Promises
const promise = new Promise((resolve, reject) => {
  setTimeout(() => resolve('Done!'), 1000);
});

// Export statement
export { greet, Person };

Discussion

I received a lot of great feedback from the discussions at Mastodon and Hacker News.

Acknowledgements

Thanks to jfk13 on hn, and @pixelambacht on Mastodon for pointing out that 'calt' is turned on by default, and that 'colr' is not an opentype feature that needs to be "turned on".

Thanks to penteract on hn and @behdad on Mastodon for suggesting better substitution rules.

Thanks to @kizu and @pixelambacht on Mastodon for suggesting color theming with override-colors CSS rule.

As said earlier, if you have any ideas, suggestions or feedback, let me know. You can reach me at hlotvonen@gmail.com or leave a comment on Mastodon.

Thanks to all who sent emails, messages and commented!

In the dimly lit “printing cellar” of Media Museum and Archives Merkki is a remarkable and curious object. It’s a mosaic of tightly arranged brass rule and spacing material, made by a Finnish typographer Valto Malmiola in 1937. Note, it’s not a single piece of metal, and it’s neither engraved nor etched… it’s thousands of individual metal bits, pieced together by hand, and locked tightly into a frame for printing.

When inked and pressed onto paper, it creates an image of the famous Finnish composer Jean Sibelius.

But, to me at least, the resulting image itself is not what’s interesting here. After all, it’s a fairly conventional portrait of Sibelius. What’s interesting and what makes the whole thing remarkable is how it’s made and how it came to be. It’s essentially a form of proto-ASCII art: intentionally (mis)using techniques and materials originally intended for printing text to create a complex image. What led to its creation? What is it anyway? Where did Malmiola get the idea to use letterpress in such an unconventional way?

The Use of Rules

Malmiola writes about the inspiration for the picture in the Finnish printing arts periodical Kirjapainotaito:

“When our renowned master composer Jean Sibelius turned 70 in 1935, [...] I was struck with a strange dream of trying to replicate his image using impractical typographic methods. I had previously seen pictures "set" with Monotype fonts and decorations in foreign graphic design trade journals, particularly "The Inland Printer", so I decided to try, but not with type and ornament, but with rule.^[1]

To give a bit of context, in letterpress printing, rules are strips of metal, often brass or type-cast metal, used for printing lines. They’ve been an integral part of printing since the early 1500’s.

Rules are typically used for decoration, as a border around the edges of pages, or for creating simple designs on book covers or brochures. A variety of tones from light grey to solid black can be made by combining rules of different widths. Rules also have a functional use as dividers for adding structure and visual hierarchy in tables, catalogues, and other layouts.

Instead of using brass rules conventionally, Malmiola used them like building blocks. By carefully arranging rules of varying thicknesses in horizontal and vertical lines, he managed to make complex images.

For those unfamiliar with letterpress techniques, or those who have never attempted to do a complex arrangement, the sheer insanity of Malmiola’s task might not be obvious.

Each element is carefully chosen or cut neatly into precise lengths and arranged in a way that leaves no air-gaps. Even the smallest unfilled space could lead to an unstable structure and make the whole thing unprintable. The level of precision, patience and skill needed to do what Malmiola did should should not be understated. How was it made?

The Construction of the Print

To plan the construction, Malmiola experimented with several approaches. He writes that the first attempt was a pitiful failure. The second attempt fared better. He came up with a “coding” system to classify different types of lines and spaces according to tonal values, by measuring the lights and shadows of the reference image, and marked each line with the resulting string of code. But he found the process too laborious and abandoned the idea. He also experimented with a “square system”, but doesn’t elaborate what he meant by that. ^[2] My guess is that he tried using grid paper to map tonal values.

Unfortunately Malmiola doesn’t reveal his final method, but Paavo Haavi, who worked with Malmiola at K. K. Printing, says he used a one-to-one photographic enlargement of the reference image to help in the typesetting process^[3]. The reference Malmiola likely used is a photo of Jean Sibelius that appeared on the cover of Suomen Kuvalehti -magazine in 1925.

What’s clear, just by observing the image, is that Malmiola used what’s essentially a manual half-toning process by plotting the reference image into tonal values, which he then painstakingly constructed with brass rule, piece by piece. This kind of half-toning process is typically done by a photographic screen or some automated system, but Malmiola had to do it by hand. Where the reference image required a black area, Malmiola used a thick rule stacked tightly next to each other, and where a gray tone was required, he alternated between fine rules and spacers, creating illusions of various gray tones.

The final print measures just 28 × 37,5 cm (~11" × 14.7" in.) but is crafted using a staggering 30 000 ciceros of brass rule ^[4] (which equals to around 135 meters or ~442 feet) in addition to some spacers and quadrants for the white space.

Haavi also recounts that Malmiola presented the print to Sibelius in person, who reportedly exclaimed, “Tehän se vasta taiteilija olette!”^[5], translating roughly to “Whose the true artist here!” Whether this was sincere or said tongue-in-cheek is not clear, but Sibelius signed the picture anyway and gave permission to include it in the prints, suggesting at least some level of validation and recognition for Malmiola.

Malmiola announced the finished piece in Kirjapainotaito and sold the prints for 10 mk (equivalent to about 4 € today, adjusted for inflation). Given the relatively small size of the Finnish typography scene at the time, there weren’t many who would actually appreciate such a print. The potential for profit was likely quite limited, so as an incentive, Malmiola sold the prints “for the benefit of war orphans”^[6]. But despite his efforts, Malmiola had difficulties in selling his prints. As Haavi notes, he had to resort to selling them on the streets of Helsinki and through newspaper ads for years after the print was made.

After Malmiola’s death, the original letterpress forme of the Sibelius-print was donated to the hand typesetters guild, and later on to the printing industry workers’ trade division, the Helsinki Print Workers’ Association (HKY). HKY sold prints of it, and used the profits to “enhance the professional skills of young people working in printing”. In 2015, HKY loaned the Sibelius forme to the Media museum and archive Merkki’s printing cellar, where it remains on public display.

Malmiola’s Other Prints

In addition to the Sibelius-print, Malmiola made at least four others.

1. Bullfinches pecking at rowan tree berries, print on the cover of Kirjapainotaito in 1938

In 1938, Malmiola created a print featuring bullfinches pecking at rowan tree berries for the 30th anniversary cover of the Kirjapainotaito magazine. Malmiola explained that the tree represents “the tree of professional knowledge”, while the birds symbolize the friends and readers associated with the Kirjapainotaito magazine. ^[7]

He writes about the making of it as follows:

“In this context, we dare to say a few words about the construction of this issue’s cover. Firstly, such a practice should not be pursued by anyone, but since people in the world have so many hobbies… The rowan berries are monotype ornaments the size of cicero em, turned upside down and vaguely shaped with a file to intentionally create a ragged feel. In nature, the birds’ backs are blue-gray, but by using semi-bold lines, the illusion of a third color is evident. […] The slightly incorrect alignment of colors is intentional and enhances the image’s ‘atmospheric content,’ and poor printing, if one generally knows how to print poorly, gives the picture a piquant effect. It remains for the reader to make the final judgment on the validity of the moods elicited by the ‘image’. ^[8]

While the Sibelius print is quite dull in its precise imitation of the reference image, this artwork manages to take advantage of the unique properties of the technique. The inherent limitations in the material qualities of letterpress and brass rule, which result in sharp and square angles, gives the print almost a digital, or pixelated, look. What was, at the time, probably thought of as clumsy and naive, seems almost strikingly contemporary now. There is a nice balance between the rigid mechanical precision of typographic forms and the organic natural forms of the tree and birds, giving it a certain charm that’s missing in the Sibelius-print.

According to Haavi, the forme for this print was disassembled after printing to release the material back into use.^[9]

2. Lighthouse, print on the cover of Kirjapainotaito in 1939

In 1939, Malmiola’s pictorial typography had become well known among the readers of Kirjapainotaito.

This print is a lot simpler than the previous ones he made, because Malmiola used a Monotype machine to make it, instead of composing the image with pre-made brass rules, like he had done earlier with the Sibelius-print. The Monotype machine also forced him to use only horizontal rules. The magazine includes a short description of the cover:

“The composer of the structure explains that the image was derived from the theme ‘the waves of time strike harshly.’ The line material used is from monotype casting, which explains why the image surface could be modified by even breaking the material, something that, of course, would not be acceptable or even permissible with ordinary lines. ^[10]

He programmed the machine to cast custom-sized rules from type metal (= an alloy comprising lead, antimony, and tin). Unlike brass, type metal was bulk material and reusable. This meant that any errors could be corrected by melting the metal down for reuse, which made it a more cost-effective option than the expensive brass. The process, however, still demanded a lof of manual effort in hand-setting type and trimming the rules to the exact lengths needed to construct the image.

3. Carradale-print, 1942

In 1942 Malmiola finished another piece to commemorate the 300th anniversary of Finnish printing art.

As far as I know, this is Malmiola’s largest print, measuring 45 × 53 cm (~18" × 21" in.) and uses an astonishing 72 000 ciceros of rule (around 325 meters or ~1 065 feet). Even though it was also made with a Monotype machine, and uses only horizontal rule, it took Malmiola 140 hours to complete.^[11]

Even though Monotype machines make it possible to reuse the material, Malmiola’s wanted to preserve the layout, rather than melting it down. The type metal needed for the construction of the print was provided by the Valtioneuvoston kirjapaino (Government Printing Office), and not by Malmiola’s own employer, K. K. Printing, who probably lacked the required material (or the will to give it). Yet, according to Haavi, the forme was melted anyhow, after an apprentice dropped it on the floor.^[12]

The print is based on a photo by Allan C. Green of a four-masted steel barque named Carradale (which Malmiola incorrectly called a frigate), built in 1889. In 1914 the ship was sold to Finnish shipowner J. Tengström, and the photo appeared in various magazines at that time (see for example 1922 Nuori Voima № 48). ^[13]

4. Forest-print, 1943

I don’t know much about the creation of this print, but I saw it for the first time when I visited the offices of Helsingin Kirjatyöntekijäin Yhdistys ry in Helsinki. This print also uses only horizontal rules, but the construction is much less precise than any of the others, resulting in some charming raggedness, which works well with the gloomy moon-lit forest scene.

Malmiola’s Inspiration for the Technique

Many Finnish typographers followed and read foreign typographic journals, which inspired new ideas and techniques. In the late 1920’s, pictorial typography had emerged as a new trend in Germany. This method of producing images became a trendy topic in typographic trade journals. For example, Arthur Grams’ article “Das Buchdrucker als Architekt” (“The Printer as an Architect”) in Typographische Mitteilungen in July 1929 writes about pictorial typography in a way that explains its potential in typesetting:

“Most colleagues are simply unaware of the wealth of forms, particularly elementary forms, concealed within the typesetting case. Yet, it is in these elementary forms that the full and grand allure of picture composition truly emerges; the elementary forms render it an expressive medium for the new demands of the era. They may occasionally appear somewhat grotesque; however, this should not discourage one from exploring their subtleties. We must endeavor to continuously uncover new facets in picture composition, because the elements it comprises are our elements: type! Type belongs to the printer! That is the essence and purpose of picture composition; it is from this perspective that one must consider the matter.^[14]

This new style spread from Germany, and inspired typographers like Valto Malmiola. Malmiola experimented with this style as early as 1933, and advocated for its use in an article titled “Yritys ‘kujeilla’ asiallisesti” (“An Attempt to do ‘Trickery’ Earnestly”) in Kirjapainotaito for December 1933^[15]. He agreed with the idea that typographic elements are not just laying out text, but could be used for artistic expression. This early experiment probably inspired Malmiola to attempt a more ambitious project later on, leading to the creation of the Sibelius-print.

In 1937, when Malmiola wrote about the creation of the Sibelius-print in Kirjapainotaito, he mentioned having seen pictures typeset with Monotype fonts and decorations in The Inland Printer.^[16] There are not many pictures set with Monotype in The Inland Printer that would match the year 1934 or 1935, but I found this portrait of Franklin D. Roosevelt, composed of 17 000 monotype characters in the May 1935 edition:

This image is not created with brass rule, but with dots and colons. The gray tones are not achieved by purely half-toning optical illusion, but by having a tinted background (originally green) in the shape of the head^[17].

While this image matches Malmiola’s description, I suspect his actual inspiration might have been something else. In January 1936, Graafikko, another Finnish trade journal, featured work by a Viennese printer, Carl Fasol. Fasol had developed a method of printing which he called “Stigmatype” already as early as 1860. Some of the stigmatype prints resemble the style and method of construction of Malmiola’s prints. Fasol introduced his invention to the public in 1867 with typeset picture of flowers and a picture of Gutenberg. Both images were reveled and he gained recognition especially among typographers.^[18] Fasol turned this into a series of Album for Printing Art, and traveled around Europe selling them, including Finland.^[19].

As a side note: the article also mentions some of Fasol’s prints were donated to Suomen Kirjapainomuseo (Finnish Printing Press Museum), which never actually existed, but the material is currently in the archives of Tekniikan Museo (The Museum of Technology). I went to look for the prints, but sadly couldn’t find them.

Beyond Fasol, there are many other typographers who used rules and other type elements to create pictorial typography in various delightful ways. Just to name a few, there’s Georg Wolffger in 1670, Monpied and Moulinet in ~1840’s and a whole trend of bending and twisting rules into all kinds of shapes in the 1870 – 1890’s. A comprehensive exploration of this phenomena would be required to put Malmiola’s work into proper context, but falls outside the scope of this post.

What’s interesting, is that these early practitioners of pictorial typography had recognized the potential of using small, modular, pixel-like elements to construct images. It laid the groundwork for how we understand and manipulate images today by showing how complex images can be made from simple, repeating parts. These early techniques were the building blocks for modern digital imaging, influencing everything from 4-color offset printing to bitmap graphics.

But... Why?

Pictorial typesetting was not always met with enthusiasm. It was often dismissed as a gimmick or childish dabbling, not just by traditionalists, but also by the rising avantgarde of typography. Jan Tschichold’s hugely influential book The New Typography, published in 1928, strictly forbade the use of any decorative elements or pictorial compositions made with type elements.

“The New Typography has absolutely nothing to do with ‘pictorial’ typesetting (Bildsatz) which has become fashionable recently. In almost all its examples it is the opposite of what we are aiming for.
— Jan Tschichold in The New Typography ^[20]

Traditionalists, on the other hand, wanted typography to follow the established norms and styles of classical printing. In Finland, V. A. Vuorinen, a member of the Kirjapainotaito editorial team wrote an article in April 1934 titled “Latomisvälinen kuvittamisesta” (“Illustrating with typesetting tools”). In it, he stated that since typesetters usually lack formal artistic training, they should stick to what they know: simple typographic layouts.

“Finally, it should be mentioned that, in my opinion, a cobbler should stick to his last. Illustration is such a demanding task that not everyone is capable of it. At least I have come to the conviction that if a typesetter uses all his means and strength to produce good, proper typography, the value and artistry of the work becomes many times better than just dreaming of images. […] Let pictorial typesetting be seen as a pastime that can be indulged in between more important tasks, but when it’s necessary to produce something quickly, let’s work with letters and proper arrangements if there are no ready-made picture plates available, and most often leave the doomed-to-fail typesetting with illustrative means to the side. ^[21]

Both the avantgarde and traditionalists viewed typographic experimentation, like what Malmiola was doing, as ridiculous and detracting from the primary purpose of typography: clear communication.

Vuorio’s article might have been written as an indirect response to Malmiola’s “Yritys ‘kujeilla‘ asiallisesti” (“An Attempt to do ‘Trickery‘ Earnestly”) in Kirjapainotaito for December 1933^[22]. In it, Malmiola suggests that the method of creating pictorial typography should be taken seriously. But even then, Malmiola often downplayed his art, referring to his practice as merely a “hobby”. Did he do so to shield himself, and his work, from being too harshly judged as unprofessional by his colleagues?

Malmiola wrote that this kind of work “ought to be executed using straightforward methods; the design should be presented with just a few outlines, and importantly, there needs to be a hint of humor, as too serious an attempt might end up being inadvertently comical.” These thoughts seem somewhat unexpected, especially when contrasted with Malmiola’s solemn portrayal of Sibelius. Maybe Malmiola wanted to prove that his method had real potential for serious and respectful artistic expression by choosing Sibelius as his subject. Maybe he wished that by making a portrait of the renowned composer Jean Sibelius on his 70th birthday would make the technique seem more professional than how it was percieved by others.

Whatever the case may be, Malmiola’s dedication appears to have been driven more by passion, curiosity, and enjoyment rather than by financial or other superficial motives. As noted by Haavi, at that time, many typesetters, including Malmiola, took great pride in their profession and were interested in the discourse happening on an international level^[23]. Malmiola was a frequent contributor to Kirjapainotaito, writing short articles and essays, especially about pictorial typesetting. In April 1933 Malmiola wrote an article titled “Mielikuvitus latojan apuna” (“Imagination as an Aid to a Typesetter’s Skills”) where he argued that typesetting, while not a traditional art, requires imagination and creativity to produce exceptional work, and most importantly, to find joy in the work^[24]. This seems to have been the case for Malmiola, as he worked on his “hobby” during his free time and quieter work periods.

However, I get a sense that he wanted to share his art with a wider audience to show that letterpress was capable of producing actual art, and to contribute to the field he was passionate about. The Sibelius-print was showcased at the 1938 International Handicraft Exhibition in Berlin ^[25], and was featured in the Printing Art Quarterly -magazine ^[26], alongside the works of A. M. Cassandre, J. C. Leyendecker and László Moholy-Nagy.

Malmiola’s art would not have come to be without the support of his foreman Atte Syvänne, the technical director of the K. K. Printing, and member of Kirjapainotaito editorial staff. Under his leadership, the K. K. Printing had evolved into a well known general printing house in Finland. Syvänne was known for encouraging his employees, and it’s apparent, that in his role as Malmiola’s supervisor (or as the overseer of Malmiola’s own supervisors), he actively supported Malmiola’s interest in pictorial typesetting.^[27]

It’s also worth noting that not many foremen in the printing industry would have allowed the use of valuable resources, such as 30 000 ciceros worth of brass rule, for personal “hobby” projects. But Syvänne shared a passion for the art of printing with Malmiola, and permitted him to use resources for his experiments.

Syvänne also dabbled in pictorial typography himself, and one of his experiments appear on the cover of Kirjapainotaito in June 1936, a year before Malmiola’s Sibelius-print. This might have influenced and inspired Malmiola in his own typographic experiments.

Valto Malmiola’s Short Biography

As a morbid contrast to the playfulness of his work, I found out that he was a supporter for Nazi ideology after reading his article “Työn aateluus”. This, of course, casts a shadow on his legacy and I debated for a long time if I should even write about him. But, because I already sunk a lot of time into this research, and because his art is unique in the context of (Finnish) typography, and because his work is part of a bigger typographic phenomena, I decided to go ahead anyway. While his work is fascinating, it’s important to view his person with a critical understanding of this context. That said, fuck nazis and fuck Malmiola, may he rot in hell.

Valto Malmiola (1893–1950) was a Finnish typographer and made a long career at K.K. printing house.

1893: Born in Hämeenlinna 25. 10. 1893. Originally known as Johan Waldemar Malmberg.
1914–1917: Moved to Helsinki in his youth, learned typesetting at K. F. Puromiehen’s printing house.
1917-1918: Briefly worked at Huvudstadsbladets nya tryckeri.
1918: Sentenced to four years in a penal colony for “aiding in treason.”
1930: Participated in a study trip and acted as secretary with the Taideteollisuuskoulu’s (School of Art and Design) graphic evening course.
1931: Won both first and second places in a typesetting competition hosted by Kirjapainotaito magazine.
1933: Published multiple articles in Kirjapainotaito,“Mielikuvitus latojan työtaidon apuna”, “Ne latojattarien ohjelmat”, ‘Eräs puoli “ohjelma” -kysymyksestä’, ‘Yritys “kujeilla” asiallisesti’
1933: Involved in establishing a café-restaurant for graphic artists, featuring international magazines and books.
1935: Legally changed his name to Valto Malmiola.
1937: Created the Sibelius portrait.
1938: Displayed the Sibelius portrait at the International Handicraft Exhibition in Berlin.
1938–1943: Produced various prints including the Bird print (1938), Lighthouse print (1939), Carradale print (1942), and Forest print (1943).
1950: Passed away in Helsinki on October 11, 1950, after a long illness.

His son Orla Valdemar Malmiola (1919 -1995) worked as a printing house foreman.

Acknowledgements

I want to thank Markku Kuusela, a researcher at the Media Museum and Archives Merkki, and typesetter Juhani “Jussi” Lahtinen for their invaluable assistance in my research. Thanks also to Grafia ry for giving me a grant that made this research possible. Additionally, I am thankful to Emilia Västi, the Collection Manager at The Museum of Technology, for her help in searching for the elusive Carl Fasol print in their archives. Lastly, special thanks to Gladys Camilo for proofreading the article.

Image sources

• Figure 1. Malmiola, Valto. Sibelius. 1937. Letterpress forme of brass rule and spacing material. Photograph by Heikki Lotvonen, January 2023.
• Figure 2. Malmiola, Valto. Sibelius. 1937. Letterpress print, 28 × 37,5 cm. Photograph by Heikki Lotvonen, December 2023.
• Figure 3. Typo: A Monthly Newspaper and Literary Review, Volume 2, Issue 22 (27 October 1888), Design in typography. — Rules | NZETC. (n.d.). https://nzetc.victoria.ac.nz/tm/scholarly/tei-Har02Typo-t1-g1-t10-body-d1.html
• Figure 4. Typo: A Monthly Newspaper and Literary Review, Volume 2, Issue 22 (27 October 1888), Design in typography. — Rules | NZETC. (n.d.). https://nzetc.victoria.ac.nz/tm/scholarly/tei-Har02Typo-t1-g1-t10-body-d1.html
• Figure 5a. Malmiola, Valto. Sibelius. 1937. Letterpress forme of brass rule and spacing material. Photograph by Heikki Lotvonen, January 2023.
• Figure 5b. Malmiola, Valto. Sibelius. 1937. Letterpress print, 28 × 37,5 cm. Photograph by Heikki Lotvonen, December 2023.
• Figure 6. Malmiola, Valto. Sibelius. 1937. Letterpress print, 28 × 37,5 cm. Photograph by Heikki Lotvonen, December 2023.
• Figure 7. Helander, Ivar Rafael. Portrait of Jean Sibelius on his 60th birthday. Cover of Suomen Kuvalehti, 05.12.1925, nro 49, Kansalliskirjaston digitaaliset aineistot
• Figure 8. Malmiola, Valto. Bullfinches. 1938. Cover of Kirjapainotaito : graafillinen aikakauslehti, 01.02.1938, nro 2,Kansalliskirjaston digitaaliset aineistot
• Figure 9. Malmiola, Valto. Bullfinches. 1938. Letterpress print. Photograph by Heikki Lotvonen, December 2023.
• Figure 10. Malmiola, Valto. Lighthouse. 1939. Cover of Kirjapainotaito : graafillinen aikakauslehti, 01.11.1939, nro 11, Kansalliskirjaston digitaaliset aineistot
• Figure 11. Malmiola, Valto. Carradale. 1942. Letterpress print, 45 × 53 cm. Photograph by Heikki Lotvonen, December 2023.
• Figure 12. Carradale (ship). (n.d.). John Oxley Library, State Library of Queensland.
• Figure 13. Malmiola, Valto. Carradale. 1942. Letterpress print, 45 × 53 cm. Photograph by Heikki Lotvonen, December 2023.
• Figure 14. Malmiola, Valto. Carradale. 1942. Letterpress print, 45 × 53 cm. Photograph by Heikki Lotvonen, December 2023.
• Figure 15. Malmiola, Valto. Untitled. 1943. Letterpress print. Photograph by Heikki Lotvonen, December 2023.
• Figure 16. Malmiola, Valto. Yritys "kujeilla" asiallisesti.. Illustrations in Kirjapainotaito : graafillinen aikakauslehti, 01.11.1933, nro 11, s. 18, Kansalliskirjaston digitaaliset aineistot
• Figure 16. Dresden, S. (n.d.). Typographische Mitteilungen, 20.1923, p. 90, https://digital.slub-dresden.de/werkansicht/dlf/308006/90#
• Figure 18. Inland Printer/American Lithographer. 1935-05: Volume 95, Issue 2.
• Figure 19. Fasol, Karl. Das Gutenberg-Haus in Mainz. In Diesem Hause Errichtete Johann Gutenberg Mit Fust Im Jahre 1450 Eine Gemeinschaftliche Druckerei, Welche Später von Gutenberg Allein Betrieben Wurde 1860, https://data.onb.ac.at/rep/BAG_10375637.
• Figure 20. Otto Ellandi Отто Элланди. Ellandi, Otto. 1985. Small book. Photograph by Heikki Lotvonen, December 2023.
• Figure 21. Syvänne, Atte. 1936. Cover of Kirjapainotaito : graafillinen aikakauslehti, 01.06.1936, nro 6, s. 1, https://digi.kansalliskirjasto.fi/aikakausi/binding/927036?page=1, Kansalliskirjaston digitaaliset aineistot
• Figure 22. Valkonen, Topi. Malmiola työn äärellä. 1948. Oil on canvas. HKY offices, Helsinki. Photograph by Heikki Lotvonen, December 2023.

Footnotes

One of the ideas behind Glyph Drawing Club was to be able to emulate the style of Amiga ASCII specifically, but with "smooth" vector lines instead of pixelated bitmap fonts, and the "Tesserae" font supplied with Glyph Drawing Club is kind of answer to that. But there's still something in the raw interfaces of ascii art editors and in the extremely limited selection of shapes in Amiga ASCII that can't really be replicated.

I wanted to keep the type design process in the old school ascii art editors and only afterwards transform the logo into something more contemporary. Thus, I modified the original Amiga ASCII font Topaz (ttf version by https://www.trueschool.se/) into a "contemporary" version with straight interconnecting lines and ligatures.

Now I can do ASCII type in an ascii art editor, copy paste the ASCII into Illustrator, and then change the font into the new modified version of Topaz and get a filled, more contemporary look.

If you want to do the same or test the font, follow the small technical tutorial below!

1. Download & install Moebius ASCII art editor.

2. In Moebius change the font to Topaz 2+ from View -> Change Font -> Amiga -> Amiga Topaz 2+ and draw some type with ASCII!

   Helpful tips to draw ASCII:

   • configure the top key mappings to include at least / \ | and any other symbol that is hard to type fast. If you use Mac, make sure your F1, F2 keys work as function keys (System Preferences -> Keyboard).
   • You can select an area by dragging your mouse across the drawing. You can move this selection by pressing m and "stamp" it with s. You can also press t to make the selection "transparent" and u to paste it under.

1. After you are done with the ASCII version, select it and copy it to your clipboard (cmd/ctrl+c).
2. Open Illustrator, create a new text box and paste the ASCII into it.
3. Download & install TesseraeTopaz8x16 font from here.
4. Change the font into TesseraeTopaz8x16. Make sure in your paragraph styles the line height is the same as font size and there's no kerning values or other offsets / shifts.
5. Select the text box, and go to Type -> Create Outlines. If you get weird subpixel shifts when outlining, just scale the font super big, then outline, then scale back to desired size.
6. Select everything & merge the paths from Pathfinder. If you want a "filled" version, and not outlined version, just ungroup the vectors, select the outer path and delete it. Now you should have a smooth vectorized version of your ASCII drawing!

Note:
I've added several ligatures and made some "text art" modifications to the TesseraeTopaz8x16 font. For example letters h, y, k, t, Y, X, v, V, i, l, z, Z are heavily modified to allow continuous shapes. Ligatures such as ._ and _. makes underscore 150% times it's width so it lines up with the | symbol below it, et cetera. Test how the font behaves by switching between the original Topaz to TesseraeTopaz! Check some of the font's features below:

What you are drawing with in Glyph Drawing Club are actually font files, and the shapes are individual glyphs from font files. It might be a lesser known or used feature of Glyph Drawing Club, but you can draw with ANY font with Glyph Drawing Club. All you need is an OTF or TTF font file, and then you can drag and drop that font straight into the editor window and that font will be loaded & ready to be used.

The problem with non-GDC font files is that they are not designed to fit into a square cell, because fonts usually have varying amounts of space around them, so it's difficult to line them up perfectly.

On the other hand, if you are a type designer and particularly interested in the modular method of creating type, it might be worthwhile to use Glyph Drawing Club for prototyping, generating interesting shapes, experimenting and just having fun with your own modular pieces.

This tutorial is for making your own modular typefaces for Glyph Drawing Club and it's quite simple really (the technical aspect at least!).

What we want to make is basically a font where each glyph has a square bounding box. We need to do this, so when you draw with your modular font in GDC, there are no unwanted spaces around the shapes and that features like rotation and flipping works correctly. Because we are basing our font in a square, you can easily rotate a square 90 degrees without any weird issues. The square is there only for technical reasons, but you can absolutely make any type of modular system your heart desires!

Setup

This tutorial assumes you have Glyphs. Let's get set up.

1. In Glyphs create a new font (File -> New)
2. Open Font Info (File -> Font Info... or CMD + I).
3. In the Font tab fill in Family Name, Designer, Designer Url etc.
4. In the Masters tab under Metrics set the values of Ascender, Cap Height and x-Height all to 800, Descender to 0 and Italic angle to 0°.
5. Still in the Masters tab, click the plus icon next to Custom Parameters, then from the "New Parameter" find hheaAscender and set the value to 800.

Add glyphs

Glyphs App works with unicodes, but since we are making a modular typeface we don't really want to put our modular building blocks into the wrong Unicode. The code point for "A" for example shouldn't have anything else than a shape representing an "A" in it, so we'll be using Unicode's Private Use Area in the E000-F8FF range. In Unicode, a Private Use Area is a range of code points that will not be assigned characters by the Unicode Consortium, so this is the perfect place to put our own modular shapes that don't have a counterpart in the Unicode.

1. Hit CMD+A to select all the letters, numbers & symbols that are loaded in by default, and click the small minus sign on the bottom left side to remove them.
2. Copy any amount of code points from this list.
3. From the top menu click Glyph -> Add Glyphs..., paste in the codes and click Generate.
4. You should see a list of glyphs generated in the overview. Select all of them with CMD+A and in the bottom left you should see a value 600 under the <-H-> icon. Make that value 800 and hit Enter. Now all bounding boxes for the glyphs should be a perfect square, ready to be used in Glyph Drawing Club.

(Optional) Making a grid

One thing you might want to do with your own modular typeface is to base it on a grid system so it's easier for you to make shapes that connect to each other. The typefaces (like Tesserae) in Glyph Drawing Club uses a simple 4x4 grid, so if you want to make a Tesserae compatible modular font, you should too. But of course, you can base your modular typeface on any grid system (or no grid at all).

1. Open one of the glyphs by double clicking it in the overview.
2. Right click anywhere on the page and select "Add Guide". Click on the guide (easier if you click the small circle), and set X to 1000, Y to 0. Then create 4 more guides, and for each guide set the Y value every 200 interval, so you have guides at Y 0, Y 200, Y400, Y600 and Y 800.
3. Add 5 more guides, but this time set the angle at 90°, Y at 1000 and X every 200 interval.
4. Shift + click all the guides to select them all, right click and select Lock Guides. Right click again and select Make Global Guide.

Drawing shapes

Now you are all set up for making your own modular building blocks! The only thing left to do really is to draw those shapes. This is really up to you, but here's a few helpful tips:

• The square shape we have is the size of one cell in Glyph Drawing Club. To make shapes connect to each other nicely, make sure at least part of your shape goes all the way to one side of the square but not over (so some vector points would be at x0, x800, y0 or y800).
• Depending on what you are making and contradicting the previous point, the shapes you draw can go over the square grid! Note that if you go over the square inverting the shapes in GDC don't work as expected anymore. It just inverts the square but not the shape that goes over the square.

• Make sure that your shapes have correct path direction. For simple shapes you can just click Paths -> Correct Path Direction.

Export & Use in GDC

Once you've made all the shapes, the only thing left is to export your font and test it.

1. Click File -> Export and choose OTF. Do not check Autohint or Remove Overlap.
2. Open the folder where you exported your font, then drag & drop the font file (.OTF) to anywhere in Glyph Drawing Club window. Your new font should now be loaded and ready to use!
3. Note: Switching to different fonts is a bit of a hassle at the moment. If load in your custom font, but then you want to use Tesserae for example, you need to choose some other font from the dropdown first, and then choose Tesserae. I'll work on a fix for this in the future!
4. If your font doesn't work or there's weird spacing issues, make sure the hheaAscender custom parameter is set to 800 in the font info!

Rearranging glyphs in Glyphs App

Glyphs App doesn't provide any easy way to reorganise your glyphs. I guess it's not on their priority list, as the use case is such a niche. I mean who would want to have B before A in their font. But for modular fonts it's a different matter because the shapes we draw don't have any standardised order to them, so we might want to reorganise them ourselves.

The way to change the order of glyphs in Glyphs App is to open Font Info, and adding a custom parameter "glyphOrder" in the Font tab, and then simply pasting a list of unicodes your font has. It's a pain to do manually, so I made a little tool to help: Easy glyphOrder sorting for Glyphs App.

1. Upload your font file (OTF, TTF)
2. Click on the shapes, and use `arrow keys` to reorder them. `Esc` to deselect.
3. Once you are done, copy the list of unicodes.
4. Open your glyph font file in Glyphs app, open Font info (`CMD+I`), navigate to Font tab.
5. Add new custom parameter, set property to "glyphOrder" and paste the unicode list as values.

Merging is fast and easy. Follow these steps:

1. Export your glyph drawing as .svg

2. Open the exported .svg file in Adobe Illustrator
3. Select the Selection Tool (V) and press Cmd + a to select everything
4. Open Pathfinder window (Window -> Pathfinder)
5. Open Pathfinder options which you find by clicking the hamburger menu icon

6. Make sure "Remove Redundant Points" is checked, click OK

7. Click Merge TWICE

(optional) Transparent background

1. Deselect everything by clicking off canvas, and then select the Direct Selection Tool (A)
2. Click on any white area, and go to Select -> Same -> Fill Color

3. Hit delete or backspace

Introduction
What is Glyph Drawing Club?
What is modular design, text art and ASCII art?

Basics
Getting started with the basics
Change the size of the canvas
Moving around the canvas
Undo / Redo
Preview image

Saving your work
Saving and exporting your work

Advanced
Area selection tools
Working with layers
Using glyph sets
Paint mode
Glyph offsets and scaling
Incorporating color
Working with other fonts

Problems?
Troubleshooting

What is Glyph Drawing Club?

Glyph Drawing Club is a free online modular design and text art tool, suitable for creating custom type design, illustrations, patterns and more.

Open the editor ↗

The editor is based on an adjustable grid into which users can “draw” with a set of geometric patterns or with any typographic symbol from any font.

Creating images with Glyph Drawing Club requires a lot of precision and relies heavily on keyboard interaction and shortcuts instead of just the mouse. Learning how to use Glyph Drawing Club is simple and you can jump right in without a lengthy tutorial, but if you want to achieve faster workflow and higher precision it's important to familiarise yourself with the program, its various features and shortcuts. This tutorial tries to cover everything there is to know about how to use Glyph Drawing Club.

What is modular design, text art and ASCII art?

There's no satisfying answer to properly encapsulate modular design, text art or ASCII art as one thing. Text art has a history spanning several thousand years from visual poetry to typewriter art to even knitted crafts that all have widely different aesthetics and process of making. What's common with all of these art forms is that they are all somewhat modular, combining several smaller elements within a larger system or structure. They are also constrained somehow by the limits of the tools used. For example, ASCII art was born out of the constraint textmode had in early computers. Textmode is a computer display mode in which content on a computer screen is represented in characters rather than individual pixels. In order to create images you'd form a sort of mosaic with a set of typographic symbols on to a rectangular grid of character cells, each of which can contain one typographic symbol.

Working with constraints is what drives the creative process when doing any type of text art. While working with limits frees up part of the thought process by taking some decisions off the table, it's also mentally challenging and stimulating: how do I make these constraints work for me and allow me to achieve what I want? How can I push the limits of this process or tool? Making an image this way feels like a puzzle to solve where the pieces don't quite fit together so you have to get creative... and the outcome is often quite delightful with all its quirkiness.

One could say Glyph Drawing Club is just a vector drawing program (which it is), but it's this method and process of creating that makes it unique and exciting. Glyph Drawing Club is inspired by old skool ASCII art editors such as PabloDraw and utilises aspects of them such as keyboard heavy workflow, a limited selection of symbols and a uniform grid while bringing an improved workflow, customisation and openness to the creative process making it more fun and versatile.

Getting started with the basics

Let's get started! Open glyphdrawing.club. On the left side of the page is your canvas, and on the right sidebar are all your tools.

1. Click on any glyph under Glyph selection. Press "Next" and "Previous" buttons to browse more shapes.
2. Press q to draw.
3. Move around the canvas with arrow keys.
4. Press f to flip, r to rotate or i to invert.
5. Erase with space bar or e

And that's it! By placing shapes next to each other you can start creating your mosaic: be it custom type, illustration, pattern etc. With these basics you can create anything and everything, but to speed up your workflow I recommend familiarising yourself with the rest of features and keyboard shortcuts.

Important note about Tesserae

The default font Tesserae 4x4 is specifically designed to be used with the Glyph Drawing Club. It's based on a 4 by 4 grid, meaning that all the shapes in the font can connect to each other from one or more of the 4 segment points on each side, either perpendicularly or diagonally. This allows you to place glyphs next to each other creating one seamless shape. I recommend exploring different shapes, rotating, inverting and flipping them and see how they connect to other shapes.

Change the size of the canvas

You can adjust the size of the canvas from the "Settings" tab by clicking the buttons next to the "Canvas height and width". You can also add or delete rows or columns at your cursor by clicking the Add/Delete Row/Column buttons.

If you want to start over and reset the canvas completely, press the "Empty Canvas" button.

Moving around the canvas

There are two main ways to move around the canvas:

1. Press Arrow keys or WASD to move the red cursor

   • You can also press Alt+Arrow keys to move 5 cells at a time

2. Left click on the canvas

Undo / Redo

The amount of undos is limited, so don't rely on it too much!

• Press Cmd or Ctrl + z to undo last action on the canvas
• Press Cmd or Ctrl + Shift + z to undo last action on the canvas

Preview image

• Press and hold p to preview your image
• Or press h to hide and show the grid

Saving and exporting your work

Your canvas is automatically saved into your browsers local storage, which means that you can safely close the glyphdrawing.club site, and find your canvas intact when you reopen the site the next time (on the same computer, browser and if you haven't cleared your browsing data). This also means that you should only work in one instance (tab) of glyphdrawing.club, because the storage is shared between instances.

Save and load files

• You can save your canvas by writing your filename in the input field and clicking "Save". This will prompt you to download a filename.gdc file, which is your working file similar to something like .psd or .ai file.
• You can load any filename.gdc file by clicking the "Choose file" button next to "Load from file".

Export as PNG and SVG

• You can export your canvas either as PNG or SVG by clicking the "Export" buttons.
• You can specify the resolution of the PNG file with the "Size" input field. The default value is 5, which is 5 times the actual size of your canvas.

License

You are free to use anything you make with GlyphDrawingClub anywhere (private or commercial), without credits or licensing info.

Area selection tools

Getting familiar with area selection tools and how to use them is the fastest way to speed up your workflow. I highly recommend using these and memorising the shortcuts.

Select an area

1. Move the red cursor to the point where you want to start the selection
2. Press Shift + s to start a selection area.
3. Use the arrow keys and move the red cursor to the point where you want to end the selection.
4. Press Shift + s again to lock in the selection.
5. Alternatively, you can select an area with your mouse by holding Shift and holding left click down and dragging out an area.
6. You can also select the whole canvas by pressing Shift + a

Deselect

• To deselect an area press Shift + d

Copy & paste

• After you've made a selection (as indicated by the red marching ants), move your cursor to a new spot on the canvas and press Shift + c to paste in the selected area. The paste starts from the top-left corner of your selected area.
• Note: Pasting a selection will erase anything in its path. If you want to paste something on top of another area that has glyphs in it, make sure they are on different layers.
• If you want to use a glyph already on the canvas but can't find it from the glyph list, you can move over the glyph and press c.

Transform glyphs in the selected area

• Press Shift + m to mirror selected area (on x-axis)
• Press Shift + f to flip selected area (on y-axis)
• Press Shift + i to invert all the glyphs in the selected area
• Press Shift + y to rotate glyphs individually in the selected area
• Press Shift + u to flip glyphs individually in the selected area

Note: the following transformations only work if your selection is a square (for example 3 x 3). You can make sure if the selection is square by the small "s" that appears inside the red cursor, or by checking the top right corner of the canvas area that says "selection x:# y:#".

• Press Shift + r to rotate the selected area.
• Press Shift + t to transpose selected area. Transposing means that each glyph will be mirrored on a diagonal axis (axis goes from top-left to bottom-right of your selected area).

Fill & empty selected area

• Press Shift + q to fill selected area with the selected glyph
• Press Shift + e to empty selected area

Move selected area

• Press Shift + h to move selected area left
• Press Shift + j to move selected area down
• Press Shift + k to move selected area up
• Press Shift + l to move selected area right

Note: Moving a selected area will erase any glyph in its path on the same layer. If you want to move something on top of another area that has glyphs in it, make sure they are on different layers.

Working with layers

Layers work a bit differently in Glyph Drawing Club than on other editors. Rather than the whole canvas sharing a layer, each individual cell has its own predefined amount of layers. Each cell has 4 layers you can place a glyph on.

Layers come in handy in many situations. To name the most common cases:

• If you are working on a complex image you might want that extra level of detail by overlapping several glyphs on each other.
• If you can't find a suitable shape you can make a "new" shape by using layers and overlapping two or more glyphs.
• You are working with multiple colors

Note: When you move the red cursor on top of a cell, the layers tab shows you which glyph you have on which layer.

Select a layer

• Select the Draw tab
• Select the layer you want to place glyphs in by clicking on the numbered radio buttons below the "Layers" section
• You can also select layers with , and . hotkeys.

Moving glyphs from one layer to another

• If you want to move a glyph from layer 1 to layer 2 for example, simply press the right arrow button below layer one. This makes glyphs in layer 1 and 2 swap places.
• If you want to move all glyphs in a selected area from one layer to another, make a selection and press the arrow buttons.

Hide layers

Sometimes it gets hard to see what is what on each layer, so you can press the "hide" checkbox under the corresponding layer to hide all the layers on the canvas.

Keyboard shortcuts with layers

If you want to affect all layers with a keyboard shortcut you can press ctrl + any shortcut. All of the aforementioned keyboard shortcuts work this way, including the selection area transformations. For example:

• If you want to rotate a cell that has multiple glyphs on multiple layers, you can press ctrl + r instead of just r.

Using glyph sets

Sometimes you want to use a limited amount of glyphs, but it gets annoying to constantly shift through pages to find and use the same glyphs again and again. For this reason you can use glyph sets to save a selection of 10 glyphs for faster use and access.

Creating and using a glyph set

• Press m to activate glyph mapping or click the "map keys" checkbox under "Glyph sets" section in the draw tab.
• Select a glyph from the "Glyph selection"
• Press any number from 1 to 10 on your keyboard. This will "map" the selected glyph into that number key.
• Press m again to stop the mapping or click the "map keys" checkbox again.
• Press number keys from 1 to 10 that has a glyph mapped into it. This will insert the mapped glyph onto the canvas.

Note: You can create multiple glyph sets by clicking the "Add" button, select previous glyph sets by clicking the numbered buttons, or delete selected glyph set with the "Delete" button.

Paint mode

Glyph Drawing Club also includes a simple "paint mode" for drawing with the mouse. Paint mode is useful especially when sketching or if you want the red cursor to follow your mouse cursor.

• Click the Paint mode checkbox under "MODES & TOOLS" section in the draw tab.
• When paint mode is activated, the red cursor follows your mouse cursor.
• "Paint" by clicking on the canvas or holding down Left click

Glyph offsets and scaling

Even though Glyph Drawing Club has a grid, you are not limited to the grid lines. Below the "Glyph fine tuning" section in the draw tab you can scale and move the glyphs in x and y -axis. This is especially useful if you need finely position your glyphs, scale certain glyphs to make bigger arcs for example or you are using a different font that's not designed for glyph drawing club.

• With "Glyph size modifier" you can scale a glyph by one "pixel" at a time or by doubling its size.
• With "Glyph offset X" and "Glyph offset Y" you can move or shift the glyph in x and y -axis, while still technically assigned to the cell. The amount the glyph is shifted is 1/8th of the width of the glyph.
• Press "Reset to default" to reset a glyph into its default state, removing all offsets, scaling in addition to rotation, flipping, inversion.

Note: Sometimes if you use a lot of offsets and scaling it's hard to see which cell the glyph is actually assigned to. You can alt+click on a shape to move your cursor to the cell it's placed on.

Note #2: Sometimes if you offset or scale a glyph, it appears "under" or "above" another glyph next to it, when you want it to be the other way around. This happens usually if you move a glyph down or to the right. One way to avoid this is to move the glyph to a cell below the glyphs you want to overlap and offset to the left and up instead.

Incorporating color

• Colors can be used from the Color tab or by holding down x
• Each layer can have a foreground color and each cell can have a background color
• Colors are "indexed", meaning that if you use a color, it's linked to its index in the color palette. This allows you to easily change colors and palettes and these changes will apply to any glyphs using that color index.
• You can replace color palettes with the dropdown menu. There are several predefined palettes you can choose from.
• You can create multiple palettes by clicking the "Add" button, select previous palette by clicking the numbered buttons, or delete selected palette with the "Delete" button.

Select and use foreground colors

• Select foreground color by clicking on a color in the color palette. Currently selected color is indicated by the red border around it. Glyphs that are inserted on the canvas now use that color (index) as their foreground color.
• Press v to color glyph with the selected foreground color (Shift+v for area selection)
• Modify selected color by using the R, G, B sliders.
• Numbers on top of the colors indicate which layer in the current cell uses which color.
• If using a limited color palette you can check which colors are currently in use on the canvas by clicking the "Show only used colors" checkbox.
• You can also use a foreground coloring brush by ticking the "FG" checkbox in the coloring tab.

Select and use background colors

• Each cell can also have a background color, which is under all the other layers.
• Select background color by right clicking on a color in the color palette. Currently selected color is indicated by the blue border around it. Glyphs that are inserted on the canvas now use that color (index) as their background color.
• Press b to color cell with the selected background color (Shift+b for area selection).
• You can also use a background coloring brush by ticking the "BG" checkbox in the coloring tab.

Create cohesive color palette

• The slider under "Create cohesive color palette" brings all the colors in your current palette and on the canvas slightly "closer" to the color shown next to the slider, on a range from 0% to 100%.
• You can change the cohesion color by clicking on the colored box, and using the R, G, B sliders.
• Less saturated fore- and background colors work best with a saturated cohesion color.

Working with other fonts

With Glyph Drawing Club you can actually use any font you like!

Select one of the default fonts

• The default font for Glyph Drawing Club is Tesserae 4x4, but you can also select from a selection of preset default fonts under the "Glyph selection" section in the Draw tab and selecting a font with the "Select a preset font" dropdown menu.

Use any font

• You can also use any other .ttf or .otf font. You can load custom fonts by drag & dropping them from a folder in your computer straight into anywhere on the glyphdrawing.club site.
• If you use a custom font, you might want to adjust grid size from "Cell size" section in the "Settings" tab to better work with your font.
• If you use a font with an alphabet, you can write on the canvas by activating "Typing mode" in the "Draw tab" under "Modes and tools". This allows you to write with the keyboard normally (note that keyboard shortcuts don't work while typing mode is on).

Troubleshooting

• You can't insert anything on the page or you are inserting black squares

  • Check that you don't have Typing mode on in the "Draw tab" under "Modes and tools"
  • Check that you don't have glyph set mapping on in the "Draw tab" under "Glyph Sets"
  • Check that your foreground is not the same as your background color in the "Colors" tab

• Nothing appears on the page when opening glyphdrawing.club

  • Your browser might be outdated. Update your operating system and download the newest version of Chrome or Firefox (or your preferred modern browser)

• Glyphdrawing.club keeps crashing

  • Check if your file is 5Mb in size. 5Mb is the current limit for the files, and bigger ones will crash Glyph Drawing Club.
  • If it's something else, it's probably another bug. Please send me an email at hlotvonen@gmail.com describing your problem and check your console if there are any errors (Ctrl+Shift+J on Windows or Ctrl+Option+J on Mac).

If you have any questions, best place to ask is Glyph Drawing Club discord: https://discord.gg/gJNDZ2M but you can also send me a message on instagram or email (links in the sidebar). Happy drawing!

We decided amongst us that each would design one spread for the book.

A typeface can potentially have up to 144,697 characters covering a wide variety of scripts, languages and symbols, all defined in the Unicode standard. But for 99% of basic everyday use in any (latin) language you only need around ~200 different glyphs. If a typeface has more glyphs than that, it's very rare that they get used, and I feel it's a fairly thankless job for the type designer to spend so much time designing all these characters which might never see the light of day. In my spread I wanted to use these more uncommon and obscure typographic symbols to show at least a bit of appreciation.

To utilise the full range of characters in Saol Text, 482 characters in total, I figured I'd make ASCII art with it. In ASCII art type loses its sound-meaning and characters become building blocks for illustrations, which meant that I could use any character from Saol Text purely based on its form.

Turns out, it's not really worth it trying to emulate ASCII with a non-ASCII font in InDesign (or any other Adobe software). In order to use a glyph that you can't type with a keyboard, you need to either copy-paste it from somewhere or click the glyph from the "glyphs" tab to insert it. This process just takes too much time and is too cumbersome to do that it kills any creativity.

In the end I ended up copy-pasting an old Amiga ASCII picture I had made and changing the font to Saol Text to achieve my goals, but it wasn't what I had wanted to do. I wanted to make ASCII art with non-ASCII fonts.

I wanted a tool that would have the following features:

1. Full range of glyphs in the font easily accessible.
2. Place selected glyph with a press of a key.
3. Uniform grid of cells into which glyphs can be placed.
4. Works with any font.

Such program didn't exist which meant that if I really wanted it, I'd have to make it myself. I had no idea how though, as I had only ever made simple websites thus had no knowledge of software or application development. At the time I was studying in a graphic design MA and decided to make it my final project to figure it out.

I told the idea to my friend Ian Tuomi. He got excited about it and really helped me get started. With him we figured out that an ASCII picture is basically a spreadsheet table where each cell holds the data required to display the individual glyphs and its various transformations. He also suggested to make it a web application with React and MobX which makes modifying the "spreadsheet" and displaying the changes really easy. I can’t thank him enough for his help.

We developed the editor during the spring of 2018 and released it to the public as part of my graduation exhibition from graphic design MA at Sandberg Instituut in Amsterdam.

For the exhibition I had also invited people to submit illustrations and experiments made with the editor for a collaborative 100-page, Risograph-printed zine that ended up being filled with amazing work from 27 artists worldwide (Glyph Drawing Club User Guide v.1.0.0.).

Since then, I’ve released many new features and updates to the site, and GlyphDrawing.Club has grown from a simple editor into a very capable modular design tool. Most notable features since the User Guide 1.0.0. and launch have been the addition of vector export, layers and coloring tools along with many smaller features that enhance the workflow.

With all the features that are now in place I feel like I finally have what I initially wanted; an ASCII art tool I can use with any font!

For the default font used in the editor I designed a modular typeface Tesserae. It started out as a vectorised version of the classic Commodore 64 PETSCII font, a square monospace font including geometric shapes.

The magic of square is that it can be rotated by 90 degrees and it still occupies the same space. If a square tile is then split diagonally into two triangles – one side black the other white – and these squares are placed next to each in various rotations of 90 degrees, you can get some visually hypnotising patterns. This is the idea behind Truchet tile system.

Tesserae works in the same way, but instead of a single square pattern, there's now over 900 different patterns. Combine that with rotating, 4 layers, inverted shapes, different colors, etc. and the possibilities for any kind of modular design work are almost literally endless. It’s very fun and satisfying to use, and because of Tesserae, the editor is used more for modular design than it is for emulating ASCII art.

I’ve seen people make amazing things with it from expressive custom type design to crazy elaborate illustrations, and I’ve also had the pleasure of teaching design with the editor in a few different schools and events. It’s been awe-inspiring to see people from all over the world make things with it that I would have never dreamt of.

This text is an edited version of a text that was originally published in the Glyph Drawing Club User Guide v.2.0.0. in 2019.

E-zines were text files written by Hackers, freaks, nerds, Sci-Fi fans, outcasts, psychotic weirdos, mad dealers and kindred folk, about what was happening in their lives, to reach out to other people with similar interests, lonely people scattered around the world connecting in CYBERSPACE and creating their own micro cultures around their hobbies and beliefs. Most of these e-zines would be about hacking and anarchic subjects […] especially nowadays where it seems that all these original romantic vibes of the cyberpunk/space world are falling apart with corporate institutions dumbing everything down. CYBERSPACE is not facebook, twitter, LinkedIn or your google+ prison which scans every fart you make to sell you more useless stuff you don't need for your consumer selfie "look at me I am so happy" lifestyle. CYBERSPACE extends all over the place, lightyears removed from your lolcatz and facebook likes...a transcendental hyperreality matrix from seedy little corners only visited by enlightened freaks to an infinite world of clandestine knowledge that extends into infinity without CONTROL.

— Legowelt, ORDER OF THE SHADOW WOLF -cyberzine

Legowelt’s romantic view of the pre-internet era feels far removed from the internet of today. Platforms that dominate the market for community building, like Reddit and Facebook, are highly controlled, commercialised, and give users little to no ability to self-govern or build their own digital space. Legowelt's description of “cyberspace” seems to be the polar opposite: a place for people to build communities around their niche interests with other like-minded people and without the control of any external authorities.

Even though some of this off-beat mentality has persisted in the internet culture at large, finding and especially joining these kinds of communities nowadays is a difficult task. While researching e-zines, I found a community that seemingly embodied a fraction of this "cyberspace" era even today: the world of ASCII art^[1]. For my bachelor's thesis in 2014, I wrote about Amiga ASCII art and the method of producing images with a small set of typographic glyphs. Even though I enjoy the often delightful and obscure visual quality of ASCII art, I was more interested in what it represents. To me, ASCII art is like folk art of the digital era, and it carries a faint echo of the "cyberspace" era. Partaking in the community of ASCII artists made me feel like I belonged to some arcane, long-forgotten society.

However, the questions of how this community originated and how it organized itself remained open for me. Why does ASCII art exist? Does the ASCII art community have the kind of qualities that define the "cyberspace" era?

To understand how ASCII art came to be, we must have a look at another overlapping community: the software pirates. In the early 90s, the process of distributing warez moved from sending files on a disk via snail mail to distributing files via the digital networks of Bulletin Board Systems (BBSs)^[2]. On the Internet, any number of people can visit the same website, but BBSs work in a different way. BBSs allow a finite number of persons to access the board at any given time; often, only one person at a time. With some additional hardware and software any computer could be turned into a BBS, and other people could connect to it by “calling” it over a telephone line. This meant that connecting to a BBS was inherently an intimate experience between the caller and the system operator, as the host could see on their screen how the visitor navigated the board, and the host could initiate a chat discussion with the user at any time.

People who had their own BBS tailored their boards to suit a specific interest or topic, but boards sharing cracked copies of games and software were the most popular. Michael Hardagon explains in his thesis how these autonomous, dial-in computer systems dedicated to software piracy were, "worlds unto themselves – secret, sub rosa societies that unified form and system outside the boundaries of the familiar."^[3] These pirate BBSs and the communities around them were thought of as alternative, anarchic spaces that resisted authoritarian forms of consumer capitalism: sharing files illegally was done not only for the purpose of sharing free software, but for ideological purposes. Pirates and hackers were battling against companies who would enclose their software and games behind digital copy protections by giving them away effectively for free on BBSs. The pirates believed in common ownership of the means of production, free self-expression, and self-management in digital realms. They wanted to challenge the conventions of societal authority and fight the controlling systems of retailers and businesses. This kind of ideology goes hand in hand with the late 80s and early 90s "Cyberpunk" mentality, which George Borzyskowski describes as, "primarily an intellectual attitude about personal survival, empowerment and control within, and in defence against, an all embracing governmental and corporate technological infrastructure which seeks to dominate society for commercial and political ends."^[4]

As BBSs were circuit based, unlike the internet, access to them was very limited. This technical limitation forced system operators to regulate the time users spent on their boards by imposing limits on how much time an individual could spend on them during a given day. Especially popular boards like the pirate boards were accessible only to a small inner circle of "elites": those within the community who had status as brokers of some in-demand digital good – for example, the newest warez, best hacking tools, or the like. The exclusive nature of this platform meant that the digital underground organised itself into a strict hierarchical structure in which users were separated based on their reputation and status. Users with more status had more access to privileged goods, and the quest for status became a competitive sport among users and different bulletin boards.

This is where ASCII comes in: those users who didn't have any technical knowledge or couldn't share warez to gain status and access to pirate BBSs could turn to making ASCII art. ASCII art was the only way to display graphics and images on the boards, as the bulletin board systems were purely text based. Therefore, system operators sought out such artwork in order to give their boards the “elite” look and feel that made them unique, "secret, sub rosa societies". ASCII artists would spend hours on end crafting intricate text mosaics – such as logos (which advertised the name of a BBS), screeners (a complex picture shown after a user logged in to a BBS), and stats screens (part of the BBS's interface) – that they would trade with BBS hosts in order to gain access to their boards and would in turn enhance their reputation as a skilled artist within the community. As such, ASCII art was mainly created to gain access to boards, rather than just for the sake of art. In this way, ASCII art became a commodity to serve the needs of the software pirates: in exchange for my art being used on your board, I will get access to your board.

Even though digital piracy is often described as a major threat to many industries (especially software, music and cinema) and even to the entire philosophical framework on which capitalism is based (by effectively converting private property into public property and diminishing the returns on surplus value generated in the productive processes), it's important to recognize that pirates were not attempting to create an anti-capitalist space, but rather a differently organized capitalist space with a more autonomous relationship to commodification and consumption.^[5] As such, the social models of these communities fell into reproducing and reinforcing the ideology of capitalist social relations: strict hierarchical structures in which (digital) capital accumulated to a selected few, while digital labourers worked in order to produce commodities, i,e., ASCII art, to be used in trade. While the pirates struggled against elements of control and management in favour of individual autonomy, and even developed organized social and cultural practices to achieve these aims, they were still generating and reproducing the structure of the society from which some of them were trying to escape. The digital underground represented a realm in which they could wield the same kind of exclusionary power that they complained about in "real life".

It's important to note that BBS users were predominantly white and male, based in Europe and North America, and typically young and unattached.^[6] Therefore, it's not surprising that the ideological qualities of these communities were not necessarily progressive or well thought out but instead rather naïve. For example, the images ASCII artists decided to reproduce were often quite sexist: images representing female forms were often passive, and overtly sexual, on the verge of being pornographic; while male forms were depicted as heroic, aggressive, and muscular, with powerful poses, perhaps representing typical male teenage fantasies. These images were usually inspired or directly copied from comic books, games, or popular culture, while logos and fonts were heavily influenced by graffiti and 3D effects. While "ripping" was considered normal, stealing someone else's ASCII artwork and presenting it as one's own was deemed one of the worst offences within the community. Getting caught doing so would cause loss of status and reputation. On the other hand, art groups and individual artists competed against each other in technical and artistic excellence. Those who achieve excellence were dubbed "elite". As an ASCII artist it was important to develop one's own style of drawing in order to possess a unique signature style that could be recognized.

From 1995 onwards, the distribution of digital goods slowly started to move from BBSs to the Internet, which in turn also started to dissolve the link between the pirates and the ASCII artists. The internet provided several different capabilities that BBSs never could. Now, any number of people could connect to an internet-based server, instead of the previous one-person-at-a-time structure of the BBSs. When broadband connections became more available around the 2000s, they were many times faster than the slow connections previously made across telephone lines. The internet was also truly global, unlike BBSs. Telephone calls across continents were very expensive, which meant that BBSs were limited to mainly national calls. Additionally, the telephone network was never intended for sharing large packets of data to large crowds, so it was only natural that the pirates would proceed to the internet. With this transformation in the pirate scene, ASCII art lost its value as a commodity, as it was no longer used to gain access to pirate boards. On the internet, anybody could connect at any time to illegal file sharing sites; it was simply faster, cheaper, and more adaptable for the purposes of sharing digital goods.

Many forms of ASCII were platform dependent, so displaying ASCII on the internet was impossible, or a big hurdle. Types of ASCII art like Amiga ASCII, ANSI, and PETSCII couldn't be displayed on the internet for a variety of reasons: the character encodings, colours and file systems that made the BBS environment unique were different, and had now been replaced by a unified standard that allowed all platforms to speak with each other. Instead of 16 colours, you could have millions. The character encodings on ASCII art no longer translated to the universal character encoding specification of Unicode, which was used on the internet. Images could also be displayed more easily and quickly on the internet, as opposed to on BBSs, which were text based. The whole purpose of ASCII art was to use characters to create images on a system that didn't allow images, but with the internet that purpose disappeared, and so the need for ASCII-based images was no more.

The decline of the ASCII community wasn't immediate, though. In fact, the height of the art scene era was in the mid- to late 90s, at the same time that pirates were moving their systems to the Internet. While originally ASCII art was made for the pirate BBS scene, a new type of BBS began to emerge: the dedicated art BBS. ASCII artists wanted to separate themselves from the illegalities of the warez scene by forming art groups and starting their own BBSs. These BBSs were not focused on hosting illegal files, but instead showcased the art and the artists. But as the masses followed the warez to the internet, and, in turn, the popularity of BBSs was in decline, the ASCII artists faced a question: what was the point of creating ASCII artwork if it would only be admired by other artists?^[7] Once the link tying warez trading and ASCII art together was broken, the key motivation for creating such works effectively disappeared.

To give a perspective on the volume of art pieces released by the dedicated art BBSs during their peak, we can look at some numbers: in 1995, over 800 Amiga ASCII collections were released; and within the ANSI art community, around 900 ANSI "art packs" were released in 1997. Amiga ASCII collections were long text files comprising individual ASCII pieces, usually done by a single person, and ANSI art packs were collections of individual art pieces done by many artists belonging to an art group. Combining these numbers, and keeping in mind the fact that each colly and art pack carried dozens, or even hundreds of individual art pieces, we can gain some sense of the popularity of the medium. The number of single works released yearly were easily in the tens of thousands in its heyday. By 2006, the numbers had declined to only a couple art packs or collys per year, totalling perhaps a few hundred ASCII art pieces.

After the break-up of ASCII and the pirate scene, ASCII art’s main raison d’être changed from its use as a commodity, to art for art's sake – a role that it has continued to perform ever since. Even though some pirate groups still include ASCII art in the "info file" of their warez releases, ASCII art is today mainly discussed and shared on the same social media platforms I criticized earlier. The ASCII art scene experienced a slight revival around 2013 and has continued to rise. In 2017, 41 art packs were released, which is on par with the numbers from 2005. This revival can be explained mainly by ASCII art archival efforts from people involved in the original community; the start of a facebook group for "ANSI and ASCII artists worldwide!", which has now accumulated around 880 people; and a general sentimental nostalgia amid old ASCII artists wanting to return to their teenage hobby. The ASCII community has not gained a lot of new artists, as the medium is heavily tied to its past, and there's no longer any easy entry point into it. ASCII art seems to be a decades-old art form with no relevance to new technologies or platforms.

While the days of mad dealers and kindred folk connected to each other in cyberspace on seemingly anarchic pirate BBSs, and the height of the ASCII art era are both long gone, the art itself lives on as a manifesto of its time. The lure of ASCII art might not be in the nostalgia of how it looks, but what it represents: the ideals of "cyberspace". It stands for a wistful longing for those pre-internet days when corporations hadn't yet taken control of our digital day-to-day and the community was still in control of organising itself.

ASCII art was born out of a specific need at a specific time, but even though ASCII art can be seen as a remnant of the past and a curiosity powered by zombie technology, it would be unfair to reduce the art form to obsolescence. Raquel Meyers uses Commodore 64 text-mode graphics for her artistic practice. To her, creating art using old technologies is not about nostalgia; it is, "not an aesthetic choice, not a pursuit of self-identity, not an ego trip, not an idle occupation to pass time", but, "a quest for freedom through knowledge, imagination and creativity." After looking at how ASCII art came to be, it is clear that it is important to understand the past in order to build the future, because, ultimately, ASCII art can represent possibilities for artists and designers outside of those examples driven by nostalgia. Instead of investigating how ASCII art used to operate within its community, perhaps our focus should shift to what ASCII art could represent today, and to the creation of artworks based on Meyers' quest that "builds imaginary on and off the grid, shaped in text characters raw and unadorned."^[8] Even though today’s ASCII community might be driven by nostalgia, the art form itself can inspire new thinking, "as knowledge of techniques and knowledge of a skilful or artful use”^[9].

This essay was originally written in 2018 at Sandberg Instituut, Amsterdam. Big thanks to Rana Ghavami for edits and suggestions.

Further reading

• Carlsson, Anders. “Beyond Encoding: A Critical Look at the Terminology of Text Graphics.” WiderScreen, June 15, 2017. http://widerscreen.fi/numerot/2017-1-2/beyond-encoding-a-critical-look-at-the-terminology-of-text-graphics/
• Albert, Gleb J. 2017. ”From Currency in the Warez Economy to Self-Sufficient Art Form: Text Mode Graphics and the ’Scene’”. WiderScreen 20 (1-2). http://widerscreen.fi/numerot/2017-1-2/from-currency-in-the-warez-economy-to-self-sufficient-art-form-text-mode-graphics-and-the-scene/
• Lotvonen, Heikki. “Amiga ASCII -taide.” Bachelor’s thesis, Aalto University, 2013.
• Mueller, Gavin. “Piracy as Labour Struggle.” tripleC: Communication, Capitalism & Critique14, no. 1 (2016): 333-45. http://www.triple-c.at/index.php/tripleC/article/view/737/860

Footnotes

Note from 2023:

This article was originally published in Versus #8 diskmagazine in 2018, and you need an Amiga or an emulator to read it.

I did some light formatting and added links and images to this text. I've also appended a 2023 update to the end of the article.

Finding ASCII art

I'm one of the very few people (or possibly the only one?) that have entered the Amiga ASCII scene in recent years. That's why Browallia asked me to write a short article of how I, a total outsider who has never even touched an Amiga, found my way into researching and making Amiga ASCII art.

I was born in 1989; too late to be old enough to experience the heyday of ASCII art. My teenage years on the Internet were spent on the early social media sites and elaborate ASCII imagery was never a big part of that. Nonetheless, I vividly remember admiring the ASCII artwork decorating NFO files that came with torrents, and I always wondered who had made them and especially how they were made. But without having any knowledge or contact with people who would know, I never really tried to find out.

Fast forward to spring 2015. I was studying graphic design at Aalto University and trying to figure the topic for my bachelor's thesis. Initially I was going to do it about utopian university, but ironically found the subject too difficult and depressing. I was desperately looking for a new subject that would be interesting and fun, while having something to do with graphic design.

Then one day I stumbled upon the website of Legowelt, an electronic music producer from the Hague (where I had also been as an exchange student a year earlier). He had made an e-zine called Order of the Shadow Wolf plain text e-zine that immediately mesmerized me with its wonderful glowing green ASCII illustrations in between short articles about obscure subjects against a black background and his description of the era before the Internet:

"Difficult to imagine now but doing this felt like the most exciting thing in the world, surrounded by a mystique of hacker romanticism and being a cyberpunk pioneer."

Graphic design of E-Zines

I was interested in this romantic, nostalgic feeling of some "forgotten" period of digital culture that I didn't even know existed. I found graphic design where I least expected it: that e-zine was practically a digital magazine with typography, illustrations, headlines and all kinds of nice small details but done in a way I had never considered before as "design". I had a subject for my thesis: What kind of design decisions had to be made when you couldn't use anything but plain text and the character set of ASCII? No formatting, bullets, underlining, bolding, italics or other typographic elements that graphic designers normally work with. How do you design a zine when everything is done by typing and the space bar?

After some research the answer to that was rather disappointing. Most e-zines I found (primarily on textfiles.com) were just long plain text files often without any typographic contrasts and no exciting "design" elements. I realized that it wouldn't be interesting enough for a thesis subject. What I found more interesting were the various ASCII images, BBS ads and logos scattered in the text files, so my subject changed once again: ASCII art.

Finding Amiga ASCII art

The first ASCII images I made with Sublime Text code editor using the basic coding font, painstakingly trying to recreate something similar (filled ASCII) I had seen on the torrent NFO files. However I wasn't a big fan of the clumsy aesthetics of 7-bit ASCII art and ANSI resembled too much of pixel graphics. It wasn't until I found an image of the FILE_ID.DIZ of a Break!Ascii logo (download the pack here) that I discovered what Amiga ASCII is.

I liked the way the lines connected to each other without leaving a gap and the extended character set of Topaz had nice details and symbols. Researching further, I found asciiarena.net (note from 2023: currently hosted at asciiarena.se altough it's frequently down. I've added a note at the end on how to view the Amiga ASCII archives nowadays ) and felt like I had found a hidden gem. It was such a cool website with thousands of Amiga ASCII collys with elaborate logos and illustrations (I miss that place. Can someone bring it back?).

I was fascinated with how much they were focused on type and logo design and how many different lettering styles were possible with just a handful of different typographic symbols. The logos were also more similar to graffiti, where the goal of typesetting wasn't to make the text legible, rather to make the characters as abstract as possible while still somewhat resembling the letters they were supposed to depict.

As a graphic designer, that was profoundly inspiring. The logos were all custom made, often with wonderful little details, ligatures, effects and styles; a quality that is often lacking in typical commercial logo and type design. The method of producing Amiga ASCII reminded me of modular type design, where each character were constructed with a set of smaller shapes to create a larger complete shape, but the character set of Amiga ASCII allowed for a more sophisticated result. As far as I know, such an ornate "modular design" system had never been extensively used in professional graphic design (or rather, there are no tools for that) (note again from 2023: elaborate modular design systems have existed in letterpress, but ASCII art has some unique characteristics and a huge volume of artworks done that surpass anything made previously), and that was hugely motivational for me when I decided to write my bachelor's thesis on Amiga ASCII art.

The graduation project consisted of two parts: thesis and production.

Writing my BA thesis

The thesis was a research into text art in general and then more specifically into Amiga ASCII art.

I tried to first define what text art is and then with that definition place Amiga ASCII into a continuum of text art history, roughly beginning in 300 BC with calligrams, and then re-emerging in different ways parallel with the various cultural and technological paradigms; the development of all the different printing and communication systems throughout the centuries, such as the invention of printing press, typewriter, RTTY and—of course—computers and digital technology.

With that information as background context, and some explanation of the general development of home computing and bulletin board systems, I examined how Amiga ASCII art came to be as a way to set different BBS boards apart visually and to enhance their graphic interfaces. Finally I looked at how Amiga ASCII developed into a mature artform, a subculture within a subculture, and what the community's cultural practices were; especially how the artworks were usually showcased in the form of "collys". My main conclusion is that Amiga ASCII can really be seen as a type of digital folk art or digital outsider art, as it only had significance to the members of the demoscene and Amiga ASCII art communities and cultures.

Writing the thesis was a difficult challenge, as there are few written research about Amiga ASCII, particularly from an artistic point of view. The most helpful existing visual and cultural research was Michael Hargadon's incredible thesis "Like City Lights, Receding: ANSi Artwork and the Digital Underground 1985-2000". Even though it only briefly mentioned Amiga ASCII art and concentrated on ANSI art, many parallels could still be drawn as the two different ASCII artforms have a lot in common especially in the way their respective communities operate. But mostly I had to gather bits of information from many different sources and combine them together. To make sense of it all I interviewed Michael Hischer (sk!n) and more extensively Antti Kiuru (h7), and got a lot of great first hand knowledge about everything relating to Amiga ASCII — how they personally approach drawing but also about the history of Amiga and the scene.

Making my first colly

For the production part I of course had to make Amiga ASCII art myself. It was an incredibly fun process. My main goal was to try many different ways to use the Topaz character set and experiment with different ideas and imagery. I created several different and small individual pieces, that I would later on combine into a sort of narrative colly. Creating logos and type was the hardest part for me (and still is), because there is already so many great typefaces that it was hard to create anything original. Instead, I tried to come up with shapes and ideas that I hadn't seen before when browsing the Amiga ASCII colly archives. I especially enjoyed making more illustrative figures, patterns and decorations as that didn't seem to be so common.

After I published my thesis and colly, I posted them on the "Ansi, Ascii Artists Worldwide!" Facebook group. This seemed to create some buzz in the community and Eric (hellbeard) invited me to the impure!ASCII 1940 art group, with whom I've been making new Amiga ASCII art ever since. My idea with Amiga ASCII has always been to create something outside of the Amiga ASCII "mainstream", to try to figure out ways Topaz hasn't been used before, to push the artform into some new directions. As I am a newcomer to the artform and culture, I do not have any sentimental nostalgia value for the medium. For me it's a curiosity, a hobby that I can't totally call my own, but also a source of inspiration for my academic and artistic practice.

Final note

Even though my thesis was only a simple and short bachelor's thesis and isn't sufficient as a real comprehensive paper, it's still the only one (that I know of) written on the subject. As such, I hope it will inspire some future researchers or current practitioners of Amiga ASCII; as it has inspired me to continue my own research into the tools and method of making text art and what the future possibilities of such an approach may be. I am now about to graduate from my master's studies in graphic design, on a topic that started from my interest in Amiga ASCII art and text art in general. I must admit that I wasn't as interested in the aesthetics of ASCII, but rather the tools and the method of producing it. As soon as I discovered Pablodraw back in 2015, I fantasized about a similar tool that could be used with any font. Therefore, I had to make one myself and that's what I am graduating with: a contemporary online grid based text art tool that works with any font and any glyph. Technically, it can also be used for making (or emulating) Amiga ASCII art, but the beauty of the tool shines when used with non typical ASCII art fonts, such as Viznut's extensive "Unscii" font. (note from 2023: GlyphDrawing.Club is the tool!)

Update from 2023

I figured I should leave a warning for anyone who might be reading this and is thinking of getting into ASCII art as a hobby or practice: I can wholeheartedly recommend ASCII art to anyone, but I don't recommend engaging with the "ANSI / ASCII scene".

You can largely avoid the scene if you:

• don't join the facebook group "Ansi, Ascii Artists, and BBS Sysops Worldwide!"
• don't publish or post anything at 16colo.rs
• don't join any of the "scene" related IRC or Discord channels and
• don't participate in any ASCII or ANSI competitions at demoparties

Unfortunately, many of the vocal and active members of the scene are making the whole community feel very unwelcoming and hostile. They don't want any newcomers, or change in general, and if you challenge that in any way, they will bully you until you quit. There is a lot of homo- and transphoba, sexism, misogynia, racism etc. Since 2015 I've seen plenty of people join the scene, and then leave soon after, because it's just not worth their time.

I persisted for some years, but also stopped participating because I don't want to deal with these people anymore. It takes a lot of energy and I rather spend my time in positive communities rather than in ones that end up being negative. It is very unfortunate as I met many amazing people and had great times collaborating with the members of Impure. I hope the scene can get its shit together at some point. Until then, I will continue making ASCII and ASCII-related projects, but outside of the "scene".

In my thesis, I study Amiga ASCII text art. Amiga ASCII is a form of text art where the composition of letter characters set in the Amiga computer's font forms a two-dimensional representation or image. The Amiga scene is a subculture of computer enthusiasts that was popular in the 1990s. At its core are the logos and other visual materials created for BBS systems and the competitive rivalry among artists who create text art over their image-making prowess.

I delve into the creation of Amiga ASCII art and use it as a method to develop my visual expression. I define text art as one style of visual art, which includes ASCII art and its sub-genres, and I briefly describe the history of text art and ASCII art and the subculture associated with it. In my thesis, I focus especially on Amiga ASCII text art and create a collection of images from my experiments with this image-making method.

Keywords: text art, computer, subculture, illustration, ASCII, Amiga.

Table of Contents

Introduction

Research section
… 2.1. Source materials and research data
… 2.2. About text art
… … 2.2.1. Definition of text art
… … 2.2.2. History of text art
… 2.3. The age of ASCII art
… … 2.3.1. History of home computers
… … 2.3.2. What is ASCII art?
… … 2.3.3. What is Amiga ASCII art?
… … 2.3.4. The golden age of Amiga ASCII
… … 2.3.5. ASCII art to decorate BBS boards
… … 2.3.6. What is a colly?

Production part
… 3.1. My starting point for creating ASCII art
… … 3.1.1. Finding the right method
… 3.2. Production process
… … 3.2.1. Description of creating Amiga ASCII images
… … 3.2.2. Making the colly
… … 3.2.3. Physical final product

Concluding remarks

Sources
… 5.1. Printed sources
… 5.2. Unprinted sources
… … 5.2.1 Internet sources
… … 5.2.2. Documentaries
… … 5.2.3. Interviews
… 5.3. Image sources

INTRODUCTION

Colon, hyphen, and parenthesis are typographic punctuation marks used in written language that serve as separators for various text structures. By combining these three symbols in sequence, you get :-). When you tilt this combination ninety degrees clockwise in your mind, it can be interpreted as a smiling face, an emoticon, with eyes, nose, and mouth. Originally, these symbols were created for the structures of written language, but in daily human communication, these symbols and their combinations have been given a new added meaning and purpose. Images created with letter characters enhance the expressiveness of text-based presentations, such as emails or text messages.

In text-based communication, the representation of images has not always been possible for technical reasons. To address this need, text art emerged, a technique of creating images where a picture or word is formed from drawn or printed symbols in a composition. An emoticon is a kind of simple image formed with letter characters. However, by combining various letter characters spread over several lines, it's possible to create much more nuanced images that can depict almost any subject. This image-making technique has been a part of the history of writing up to the present day. I will discuss this matter in more detail in section 2.2.2.

Text art made on a computer is usually called ASCII art. The name derives from the character standard developed in the 1960s. ASCII art flourished in the 1980s and 1990s, before widespread public access to the internet, when text-based BBS systems operating on telephone networks served as the primary places for thought and information exchange, much like the internet. The making of ASCII art waned as the internet displaced BBS systems with the advent of fast broadband connections around the year 2000. However, ASCII art has surged in recent years due to nostalgia, social media, and the archiving of ASCII art.

In my thesis, I delve into this image-making technique and use it as a method to develop my visual expression. In the research sections, I define text art as one genre of visual art, encompassing ASCII art and its sub-genres, and briefly describe the history of text art and ASCII art and the associated subculture. I focus especially on the Amiga-style ASCII text art in my thesis and create a collection of my experiments using this image-making method. I elaborate on the aforementioned concepts in section 2.3.

RESEARCH SECTION

2.1. SOURCE MATERIALS AND RESEARCH DATA

Historically, the typewriter as a medium of creative expression has largely been overlooked, perhaps because those who created typewriter art were primarily professional typists who demonstrated their skills mainly to peers in the same field. Many early typewriter artists were likely unaware of the historical background and significance of their art, leading to a lack of its widespread recognition and acceptance by critics. Those who were interested in the typewriter as a medium for text art were mainly intrigued by it from the perspective of concrete poetry, rather than viewing it from a visual art perspective. This has resulted in a lack of complete understanding of the entire field of text art. Only now, due to the archiving capabilities of the Internet and the exposure of text art, is a more comprehensive picture emerging.^[1]

This same trend seems to be occurring with ASCII text art, leading to a perceived lack of quality source material on text art or ASCII art. Two anthologies have been written on typewriter art: Alan Riddell's Typewriter Art (1975) and Barrie Tullett's Typewriter Art: A Modern Anthology (2014). Only one significant retrospective has been held on typewriter art (London and Edinburgh 1973, 1974)^[2]. Not a single extensive publication or study has been written on ASCII art, and only one small exhibition was held in Cologne in 2013 as part of an electronic art festival. The subject has been briefly touched upon in a few studies dealing with computer enthusiast subcultures, such as the 2011 study Like City Lights, Receding: ANSi Artwork and the Digital Underground, 1985-2000 by Canadian Michael Hargadon. Most studies focus on computer enthusiast subcultures and related phenomena mainly from a technical, sociological, or historical perspective.

For my research, I interviewed two individuals who are still actively involved in the Amiga ASCII scene. I interviewed Amiga ASCII pioneer, German Michael "Skin" Hischer, via email. Additionally, I interviewed Finnish Amiga ASCII artist Antti "h7" Kiuru. The interviews mainly focused on questions about the process of creating ASCII art, their style, sources of inspiration, and personal history. I also posed a few general questions in the Facebook group "Ansi, Ascii artists worldwide!" which includes a large portion of individuals involved in the subculture.

As written sources, I utilized several studies dealing with computer enthusiast subcultures and related phenomena, numerous internet sources, and Barrie Tullett's work on typewriter art, Typewriter Art: A Modern Anthology. From these pieces, I believe I was able to create a comprehensive yet source-critical understanding and description of the subject matter under investigation.

2.2. ABOUT TEXT ART

2.2.1. DEFINITION OF TEXT ART

While working on this thesis, there didn't seem to be a definition of text art available anywhere. This is probably due to the almost complete absence of both Finnish and English literature or research on text art. Just the fact that the English Wikipedia article for "text art"^[3] redirects to a vague and sparse article on ASCII art indicates the scarcity of research and that the history of text art has not been fully understood internationally. However, to address my research topic, I need to define text art in some way.

When I started to develop a definition of text art, the difference in the use of a letter character in written language and in text art seemed to be a defining factor. What is the significance of a letter in text art? What's the difference between a letter character in written language and in text art?

Text is a semantic unit. In text, the form isn't as important as the meaning given by the forms^[4]. Written text consists of graphemes, i.e., written characters. Grapheme refers to letters, that is, characters used in a phonetic writing system, and other writable characters such as numbers and punctuation marks^[5]. In written language, text and letters contain meanings; they are a tool for communication.

In the context of text art, a character is considered solely through its form. In text art, a letter is not symbolic and does not have semantic meaning, but the composition of letter characters creates an image, which in itself can symbolize something. The semantic meaning of the image arises from the form given by the composition of the letter characters, that is, what the image resembles, unlike in written language where combinations of letter characters, words, and sentences mean something, carry meaning. Thus, one can think that the word "ball" immediately brings to mind an object made of some material, while in the context of text art, a ball can be symbolized by, for example, the letter O, in which case just the shape of the letter can bring to mind an object made of material.

Text art can therefore be defined as follows: text art is a form of art in which a composition of letter characters forms a two-dimensional representation, that is, an image.

2.2.2. HISTORY OF TEXT ART

Before the invention of typewriters and computers, calligram was the most common form of text art. A calligram is a poem, phrase, or word in which the text or words are arranged so that they collectively form a picture. The picture formed in the calligram is usually visually related to the words or word used in it and expresses the theme of the poem. One of the first calligrams is Axe by Simmias of Rhodes, made in 325 BC, where the text forms an image of an axe (Figure 2). A Jewish tradition of micro-calligraphy also resembles calligrams, where small written Hebrew letters form geometric and abstract images^[6].

Arabic calligraphy can also be considered a form of text art. Drawing humans is seen in Islam as idol worship, so pictures were drawn using calligraphy, that is, text. In Islamic culture, calligraphy is considered the noblest form of visual art, as it translates the words of God as revealed in the Qur'an into a visible form. Qur'anic manuscripts have always been commissioned from the most skilled calligraphers to give the text an artistic appearance worthy of its value ^[7].

Movable type and printing press developed in the 1400s made duplicating knowledge fast and, above all, cheap. The printing technique made it possible to shape people's perceptions of themselves and the surrounding world. The great revolution of printing in Europe was the invention of movable type, which meant that the same type could be used over and over again to produce many different printed products. Movable types significantly accelerated page production compared to engraving each page separately on wood or metal plates, so movable types were also used to create typographic ornaments and pictures ^[8].

Just as the printing press once did, the typewriter revolutionized the world. By the end of the 1800s, it had established its position not only in the industrial and commercial sectors but also in the cultural and social fields. Typewriter created new professions and livelihoods and was also a crucial step towards women's emancipation. It also gave people the means to communicate freely without fear of censorship and enabled writers to write as quickly as they thought. The typewriter brought a modern way of directly presenting and disseminating thoughts^[9]. It also became a tool for making art.

One of the first surviving images made with a typewriter is a picture of a butterfly made by Flora Stacey, who worked as a secretary, in 1898^[10] (Figure 3). By re-entering the same paper at different angles and stacking letters, almost any shape could be created, and Stacey's picture is more reminiscent of pencil drawing than typical mosaic-like text art. On the other hand, a few years earlier, the publication Pitman’s Typewriter Manual (1893) better utilized the limitations and possibilities set by the typewriter and is more reminiscent of modern ASCII art than Stacey's butterfly (Figure 4).

However, text art made with a typewriter can be seen to have flourished mainly in the 50s–70s. Around the same time in the 1950s, concrete poetry was born in different parts of the world, where the typewriter was used as a tool to create visual poems with the typographic layout of words being crucial to the impression. In concrete poetry, seeing and reading play an equally significant role^[11]. Artists and poets who used this method were interested in how printed words can be interpreted through their presentation and design. They sought ways to create new meanings and conceptual levels for the text by visually composing it^[12].

At the same time, written messages were transmitted over radio links using teletype machines. Using a sound reminiscent of Morse code, the machine could remotely control another similar teletype machine, with messages printed on paper through a printer. What was written on paper at one end was automatically written on paper at the other end. To standardize the character graphics for teletypes, the 5-bit Baudot code was developed, which can be considered a precursor to the ASCII character system. Text art created with teletype machines was exchanged among other radio amateurs, and these works are very reminiscent of future ASCII art ^[13] (Figure 5).

The development of different forms of text art does not seem to be linear but appears to have occurred independently following each paradigm shift in information technology. They are fascinating examples of how technology has been used as a tool to create works far from what the technology developers could have imagined they would create. The pioneers of text art seem to have been primarily those who were not primarily artistically oriented but were interested in technology and its limitations.

The first step in the emergence of computer-made text art, called ASCII art, occurred with the change in Western consumption paradigm brought about by the microcomputer revolution in the late 1970s. How did this paradigm shift occur, and what followed? What steps led to the birth of ASCII art? I will discuss these issues in the next chapter.

2.3. THE AGE OF ASCII ART

2.3.1. A HISTORY OF HOME COMPUTERS

At its core, computers are intricate calculators, adept at computing mathematical functions swiftly and processing vast amounts of data. Until the late '70s, these calculations and data processing were performed on large mainframes – the first-generation computers situated in glass-walled computer rooms. These were primarily used as instruments of centralized power within hierarchical organizations to manage large and complex commercial-administrative systems. This gave birth to an industry where IBM played a dominant role. These mainframes were only accessible to entities with significant capital, such as the defense industry, large corporations, and universities. Their operation required expertise in both hardware and software^[14].

By the late '70s, foundational computer components, transistors, and microprocessors, had been miniaturized enough to allow for the creation of reasonably sized second-generation microcomputers. In essence, microcomputers did not differ from mainframes except in size, price, availability, and complexity^[15].

However, the technology revolution didn't stem merely from technological achievements, but from the evolution of factories that produced components. As these components were miniaturized, their production costs reduced, and manufacturing energy efficiency and volumes increased. This allowed for mass production of computers. Yet, by the mid-'70s, a typical microcomputer user needed skills like soldering components, constructing keyboards, interfacing devices, and programming both the system and applications. Computers transitioned from computer rooms to design offices and labs, inadvertently giving rise to the hacker culture. A new wave of enterprises emerged in the IT sector, leading innovations and developing consumer-friendly applications and devices^[16].

By the late '70s, new companies emerged that sold pre-assembled computers. Apple was one of these, with its Apple II in 1977 being the first massively successful mass-produced microcomputer. In a May 1977 article for Byte magazine, Apple's Steve Wozniak wrote,

“I think a personal computer should be small, reliable, convenient to use, and inexpensive”^[17].

No longer did computer users need to be IT experts or hobbyists, but could simply be the "ordinary consumer".

The third generation, or personal computers, in the 1980s, transitioned IT from the hands of engineers to a broader user base who began applying it for tasks like word processing and spreadsheet calculations. By the '80s, the market had been flooded by several small, medium, and large companies offering various solutions. By 1983, however, the market was predominantly dominated by systems from three computer manufacturers: Apple Computer's Apple II, Commodore International's Commodore 64 (and later Amiga), and IBM's PC. Each catered to slightly different consumer bases based on price and technical features. Apple computers were mostly sold to users wanting a mix of games and utility programs, Commodore dominated the gaming market because of its affordability and superior graphics and sound capabilities, and IBM rapidly secured a monopoly in the corporate IT world.

In the 1980s competition, IBM established the dominant standard for personal computers (IBM PC-compatible computers), but lost its exclusive rights to manufacture machines following its standard. By the end of the '80s, 80% of all sold microcomputers were either IBM-made or at least used its system. However, by the early '90s, the mantle had shifted to the Intel-Microsoft duo, whose actions reshaped the entire industry. Intel was responsible for processors, and Microsoft took care of the operating system^[18].

Still, Amigas were popular in the early '90s and became significant among computer enthusiasts. They were more prevalent in Europe than in America, which influenced the strong Amiga culture in Europe. For instance, according to a reader survey conducted by MikroBitti magazine, 49% of its Finnish readers owned an Amiga, while 27% owned a PC, at the turn of 1991–1992^[19].

However, Amiga's share of the home computer market declined sharply in subsequent years as PCs overtook them in terms of price-to-quality ratio. Commodore couldn't counteract IBM PC's and its clones' rise with their Amiga. Though initially ahead in terms of value, by 1992, it became challenging to produce cost-competitive technology against the ballooning PC industry^[20].

In May 1994, Commodore filed for voluntary bankruptcy. However, the unwavering loyalty of some Amiga users ensured that the Amiga hobby and scene continued, even if new devices were no longer sold. By the mid-'90s, PCs had become the standard home computer in Europe, with no serious challengers in sight.^[21] Gradually, computers became a household item in Western countries.

Brushes and parchment, the printing press, teletype, and typewriters each enriched text-based communication in their time. Similarly, the most crucial factor of the computer revolution was the democratization of information as the computer became a consumer product^[22]. In the following subsections, I will discuss the evolution of computer writing systems and the emergence of different forms of ASCII art with these devices and systems.

2.3.2. WHAT IS ASCII ART?

In the 1960s, to facilitate the transfer of text-form information across various systems and devices, the ASCII character set standard was developed (an acronym for American Standard Code for Information Interchange)^[23]. In information technology, a character set is an agreement defining how binary numbers represented as bit combinations should be interpreted as characters belonging to a writing system. A computer can correctly process only those characters included in its known character set. ASCII is a 7-bit character set, covering 128 (2⁷) character positions, and primarily encompasses the letters, numbers, punctuation, and special characters, as well as certain control codes, required for American English^[24].

Since computers typically use 8-bit bytes and ASCII is 7-bit, many computer manufacturers developed broader character sets where the spare bit was utilized. This doubled the number of characters from 128 to 256 (2⁸). In these character sets, the first 128 characters typically matched ASCII, but the remaining positions could be devoted, for example, to letters of other languages or characters reserved for table graphics. As a result, the extended character sets of different computer manufacturers could vary considerably^[25].

ASCII remained the most commonly used character set on the Internet until 2007 when it was overtaken by the UTF-8, based on the Unicode standard, comprising over 110,000 characters^[26].

Artwork created with the ASCII character set is referred to as ASCII art. However, the term "ASCII art" has become an umbrella term for all types of images formed from computer-assisted characters. This is somewhat misleading, as ASCII refers to the original 7-bit, 128-character position character set. Most ASCII art, however, is crafted using extended 8-bit or higher character sets. The most renowned forms of ASCII art are 7-bit ASCII art, ANSI art, Amiga ASCII, ATASCII, PETSCII, Shift_JIS, teletext, and Unicode art. Each employs a distinct character set and often a specific font to craft the images^[27].

Most ASCII art is crafted using a computer's text-based system (known as "textmode"), which consists of a grid built from identically sized cells. Each cell can contain one character. Characters employ a monospaced font, with each character occupying equal space, thus each row can contain an equal number of characters. The number of characters per row depends on the system and application in use. For instance, IBM PCs employed an 80x25 grid for displaying text, with a maximum of 25 rows, each having 80 cells. Current text processing predominantly supports variable-width fonts, which weren't viable in textmode. ASCII art made in textmode can thus be described as a kind of mosaic, where typographical symbols are precisely arranged on a grid to form an image^[28].

One of the earliest images reminiscent of ASCII art was created by Kenneth Knowlton and Leon Harmon, both of whom worked at Bell Labs. The image was a mosaic of a nude, comprised of symbols used in electronic circuit diagrams^[29]: (Figure 7).

"The nonscientific, some say artistic, aspects of computer graphics arose for me via a sophomoric prank. Ed David, two levels up, was away for while and the mice, one might say, played ever more freely. Leon Harmon stopped by to ask me for help with a brilliant idea: when Ed returns, one entire wall of his office will be covered with a huge picture made of small electronic symbols for transistors, resistors and such. But overall, they will form a somewhat-hard-to-see picture of, guess what, a nude! And so the renowned Harmon-Knowlton nude was conceived, coaxed into being, and duly hung on Ed's wall."^[30].

Even though this image was swiftly removed from the office wall and rapidly dismissed by Bell Labs' PR department, it leaked to the public, ending up on the pages of The New York Times and even on display at the Museum of Modern Art in New York in an exhibition titled The Machine as Seen at the End of the Mechanical Age. This prank turned into a sensation in a short time, and the creation of this symbol-based mosaic was a crucial step in the evolution of computer graphics and ASCII art^[31].

2.3.3. WHAT IS AMIGA ASCII ART?

ASCII art made with the Amiga computer's font and column settings is called Amiga ASCII.

The Amiga has its own 8-bit character set. The first 128 characters follow the ASCII standard, and the remaining 128 characters follow a supplemental Latin character set ISO/IEC 8859-1. It isn't particularly suited for drawing pictures and graphics, as it doesn't contain characters meant for drawing tables and graphics, unlike character sets of some other contemporary machines. Amiga's extended character set mainly contains some mathematical symbols and some characters of European languages, such as the letters ä, ö, and å used in Finnish.

What makes the Amiga particularly suitable for creating text art, however, is its default monospaced font "Topaz". Its letterforms and column settings allow for the creation of cohesive patterns. In Amiga, the line spacing and character spacing are very narrow, so certain characters "merge" if arranged correctly. For example, by typing an underscore followed immediately by a slash, it looks as if these two characters were one cohesive pattern and not two separate characters.

By combining these characters, it's possible to create pictures resembling sketches or outline drawings. This is a special feature of Amiga ASCII, distinguishing it from all other forms of ASCII art. Amiga ASCII is also called line-ASCII to differentiate it from filled-ASCII made on PCs.

Slashes and underscores are perhaps the most commonly used characters in Amiga ASCII art. These characters form the basis of many Amiga ASCII pictures. Two slashes placed one below the other form a cohesive slanting line, and two underscores in a row form a straight horizontal line. These characters can form an endless variety of shapes, which almost seamlessly connect to each other. Due to the cohesive line formed by the slash, many Amiga ASCII logos look italic or slanted.^[32]

Michael Hischer, whom I interviewed, describes his technique as:

"[The limited number of characters] has always been an opportunity and challenge for me to create something that others don't do or can't do. I never use more than ten characters when creating ASCII. An excessive number of characters would be a distraction and divert from the essentials." ^[33] (Figure 10)

Amiga ASCII is part of a broader phenomenon called the demoscene. The demoscene is a computer hobbyist subculture centered around its cultural artifacts, demos. Demos are real-time audiovisual presentations executed on a computer, made especially within the demo culture, or demoscene, that emerged around the mid-1980s.^[34] The Amiga scene, on the other hand, is a subculture of the demoscene, centered on logos and other visual materials made for BBS usage and the competitive skill of text artists.^[35]

Amiga ASCII art can be seen as a continuation of PETSCII art made on Commodore's earlier Commodore 64 computer. PETSCII refers to the character set of the Commodore 64, which was well-suited for text art. The technologically advanced Amiga, however, replaced the Commodore 64, and many PETSCII artists began to create text art on Amiga computers. However, the popularity of Amiga ASCII art is mainly based on the culture and social communities formed around BBS^[36]. For this reason, I will mainly focus on discussing Amiga ASCII during the BBS era, leaving out the similarities of PETSCII art to Amiga ASCII.

Nowdaays Amiga ASCII is mostly created on PC, Mac or Linux computers. The only defining factor for Amiga ASCII art today seems to be the method of creating the image using the Amiga font.

2.3.4. THE GOLDEN AGE OF AMIGA ASCII

A BBS (Bulletin Board System) refers to a computer connected to the landline network through a modem, to which its users, or BBS enthusiasts, connected with their own computer. The main focus of BBSs was primarily on various discussion areas and file sharing. Many BBSs formed tight-knit user communities and served as meeting places for various groups. BBSs can be thought of as precursors to many features familiar from today's Internet, such as social communities.^[37]

The origin of BBSs began when Ward Christensen and Randy Suess (US) developed the MODEM program in 1978 mainly for data exchange within their computer club. With it, two computers could communicate and exchange files. Later that year, Christensen and Suess developed the system known as the world's first BBS called CBBS (Computer Bulletin Board System)^[38].

Connections to the BBS were made using a modem connected to the landline network, using a character-based terminal program. Connecting cost the same as making a regular phone call. International connections were thus possible, though expensive. After calling the BBS, the user had to log into the system first. Most often, real names and sometimes also pseudonyms or handles were used in BBSs. In addition, during registration, users were often asked for name and address information and sometimes also for certain data communication settings.^[39]

BBSs were navigated using keyboard commands in various menus. There were several different menu levels, usually varying according to the software the BBS used. Typically, BBSs included discussion areas, file areas, private messages, bulletins, and in some systems, it was also possible to play text-based games or chat in real-time with other users and the BBS administrator. File exchange was a significant part of BBSs, as uploading files earned usage time in the BBS.^[40]

BBS activities remained for a long time within a small group interested in data communication and microcomputers. Gradually, as modem speeds increased towards the end of the 1980s, it began to spread to the awareness of larger user groups. What started primarily to facilitate mutual information exchange began to form a subculture. The age and user structure began to change, and at the same time, the ways BBSs were used diversified significantly. In the 90s, the subculture was mainly composed of young men aged 15-20. They shared an interest in computers and the possibilities they created^[41]. BBSs were significant communal forums for social activity. They served as meeting places for friend groups as well as hobbyist and subcultural groups^[42].

Due to the home computers on the market that were incompatible with each other, hobbyists were loosely divided into different user groups specific to each computer. It was possible to log into BBSs with any computer, but due to the different character set standards, they might not necessarily display or function correctly. As a result, Amiga and MS-DOS-based PCs developed slightly different user cultures, even if their basic vibe was the same^[43].

2.3.5. ASCII ART TO DECORATE BBS BOARDS

Data transfer via modem was very slow and therefore consisted mainly of text files. Terminal programs used to connect to the BBSs also operated under text-based operating systems. Due to their text-based nature, the BBS user interfaces were quite austere. There arose a need to embellish these interfaces and create images.

Amiga and PC-based BBSs started to be decorated with ASCII graphics. Most of the BBSs operated on PCs, which were not compatible with Amiga (Figure 12). Graphics on the PC were created using the extended character set and font of the original IBM PC, known as ANSI art.

ANSI art is a form of ASCII art. However, it significantly differs from other forms of ASCII art, as ANSI art mainly consists of rectangular raster bars and looks more like pixel graphics than actual text art. PC computers' ROM (read only memory) contained the character set and font specified on "code page 437". This character set includes the 128 characters of the ASCII standard and additionally a set of graphical elements specifically for drawing tables and graphics. However, ANSI images are primarily composed of five characters, whose different strength raster surfaces enable the creation of color fields and shading on an 80x25 grid. Using color was also possible through terminal control codes included in the ANSI X3.64 terminal control standard. The ANSI color palette consists of 16 colors and 8 background colors, which was later expanded to 16 colors and 16 background colors by reusing some bits for more colors. This allowed for significantly more imposing images than traditional ASCII graphics.^[44]

Note from 2023:

Because the tools for creating ANSI and Amiga ASCII are mostly the same, many contemporary Amiga ASCII pieces also use ANSI colours. However, if the Amiga ASCII is using iCE colors, the file wouldn't display correctly in many Amiga ASCII viewers and editors. For example the escape sequence "Esc[1m" turns on bold text on Amiga, but the same escape code turns the foreground text a bright light blue color using iCE colors.

On the other hand, AmigaOS has a wide range of supported colors and different ANSI escape sequences, which would theoretically allow one to display more colors than the PC ANSIs. Some escape sequence commands can be also used for all kinds of funny trickery, like moving the cursor and erasing parts of lines. This made it possible to create pixel art with text files, and has lead to a lot of confusion among the ASCII art community.

Even though Amiga ASCII could potentially be more colorful and diverse in form than the PC ANSI, for some reason most Amiga ASCII art in the archives is just plain text in monochrome.

Thanks to goto80 and by proxy sir garbagetruck for pointing this out.

ANSI graphics were originally used in crack intros^[45] for illegal software copies and in the logos of BBS login pages. Before long, ANSI artists formed groups and began publishing monthly packages containing ANSI art. Activities were typically organized, and intergroup competition became an essential factor in maintaining the intensity of the hobby.

A few comprehensive studies and other literature have been written on ANSI art and its related culture, so I will omit its in-depth discussion from this thesis.

Amiga ASCII was largely created for applications related to BBS boards. BBS administrators needed beautiful login pages and ASCII art to embellish various sections of the BBS to improve the user interface.

In the early 1990s, Amiga ASCII art groups and individuals began to release their materials as collies or logo collections. This convention can be seen as having come from the ANSI art side, where groups published their works in art packs. However, Amiga ASCII collies were individual text files containing all the material, while ANSI art packs were collections of separate files.

Today, BBS boards have no practical significance and exist mostly for nostalgic purposes. They can also be a status symbol for groups and a way to pass the time. However, various websites on the Internet have replaced the BBSs as the publication channel for collies^[46].

2.3.6. WHAT IS A COLLY?

Colly, or collection, is a text file containing a collection of Amiga ASCII artworks created by one or more artists. The primary purpose of collies is to showcase the latest works of an ASCII artist in one place.

The term "colly" originated from the Amiga ASCII group ART's 1992 released logo collection called Collection volume 1 ^[47], after which it became a common practice within the subculture. Collies were the primary publishing format for Amiga ASCII art and have remained so to this day.

Rarely was Amiga ASCII used for traditional, representational art. However, representational images might be used in collies as illustrations. The main content of collies was typographic logos. They were usually made to a maximum size of 80x25, as the terminal programs used to connect to BBS were this size. Logos were typically 7-12 letters long, depending on the width of the logo font. The letters of a logo were often adjusted according to the length of the word and its intended use. The same logo style could be applied to words of different lengths. Even four-letter logos could be stretched to 80 cells to suit its use in BBS. Often, ornaments or texturing were made around the logo to frame the logo itself^[48].

Some collies were collections of miscellaneous logos, advertisements, and other materials used in BBS made by the artist. However, many collies showcased the artist's newly developed typographic style to make logos. Collies could also be made in collaboration with another artist. Then both artists would create their own version of a particular word, and the person who commissioned the word could choose which one to use^[49]. Collies were often thousands of lines long.

Artists releasing collies competed with other artists for the best colly. An individual or group that made a beautiful colly gained respect and status among members of the subculture. Makers of high-quality ASCII art could also ascend within the group's internal hierarchy or receive invitations to generally more esteemed groups. As in other computer enthusiast subcultures, competition among groups and their members was a key factor in motivating groups to publish and maintain the quality of collections.

A colly traditionally consists of the following elements:

A. Advertisement for the group's own BBS
B. Title of the colly, creator's logo, and group logo
C. Table of contents (index)
D. Introduction / creator comments
E. The actual content of the collection, i.e., ASCII logos, BBS advertisements, and file_id.diz files
F. Credits
G. Greetings (greets)
H. Acknowledgements (respects)

A. Advertisement for the group's own BBS

Collies usually begin with either an advertisement for their own BBS or a title. The BBS advertisement promotes the group's own headquarters (HQ) BBS. The headquarters serve as the group's primary publication channel for new collies, the place where the group's productions arrive the fastest^[50].

In the ad, the name of the BBS is made as an ASCII image, and details about the BBS are listed around it. This information usually includes which groups it serves as the headquarters for, the names of the BBS administrators, technical details, software, and addresses used for connection. Only those with a functional BBS use a BBS advertisement. (Figure 13).

BBS advertisements were also made for BBSs other than the group's own. These ads could be spread on discussion areas reserved for ads in other BBSs. The more impressive the ad and the more famous the artist who made it, the more people it attracted to visit the advertised BBS^[51].

B. Title of the colly, creator's logo, and group logo

At the beginning of collies, there is usually a title. The title may include the name of the colly creator, the name of the group the creator belongs to, and the name of the collection. The title is important because it reflects the theme and style of the collection and gives a taste of what's to come. It serves as an introduction to the following sections. (Figure 15).

C. Table of contents (index)

The table of contents lists the ASCII images contained in the collection in numerical order. In the list, names are usually written in plain text. Tables of contents are used especially in long collies, which may contain hundreds of logos and other ASCII images made for various parties.

D. Introduction / creator comments

Collies often also contain a brief introduction, where the creator writes about the origin or theme of the collection, their own life, news, or other matters related to the subculture. This allows the creator to explain the background of their colly, express their thoughts related to drawing, or reinforce their position as an Amiga ASCII creator. (Figure 14).

E. The actual content of the collection, i.e., ASCII logos, BBS advertisements, and FILE_ID.DIZ files

The main content of collies consists of ASCII logos made for others, BBS advertisements, and file_id.diz text files. These usually come as requests from other members of the subculture. For example, a BBS administrator might ask an Amiga ASCII artist to create a login page logo for their BBS. Then the creator of the colly can use their newly developed style to create a logo for the BBS administrator to use. So, ASCII logos were often put to some use. ASCII logos could be requested by anyone, individuals, or groups.

FILE_ID.DIZ is an ASCII text file that contains a short description of the content of the archive file. Many BBSs allowed users to upload their own files for others to download. BBS administrators might require the person uploading a file to also provide a description of the content they are uploading. To standardize descriptions, archive files were supplemented with a FILE_ID.DIZ file to provide a clear description of the content to be downloaded. The text file was required to contain at least the program name, version number, and a description of the file to be downloaded. Traditionally, FILE_ID.DIZ was allowed to be 10 lines long, with each line containing a maximum of 45 characters^[52].

However, Amiga ASCII artists began to use this file for their own needs, often as an icon for the colly. In this case, FILE_ID.DIZ contains the name of the colly, the creator, and some release information. The purpose of the icon is to be as impressive as possible to attract the attention of others, as it serves as a preview for the actual colly.

Different logos are separated by a separator. The separator also structures the content and helps with navigation. The separator usually lists the logo number, which matches the table of contents, the name of the colly, the name of the logo, and/or the name of the person requesting the logo. Because logos are often difficult to read, the text of the logo in the separator is often written in plain text.

Amiga ASCII logos always have the artist's own abbreviation attached, indicating the creator and copyright. The worst violation is to steal someone else's style or logo and claim it as one's own. If caught, the punishment could be exclusion from the subculture^[53].

F. Credits

Credits provide the closing details for the colly. It lists the creator's name (or names) and possible guest appearances, i.e., if another Amiga ASCII artist participated in the creation of the colly. The credits often state the release date, file size, file name, font used, text editor or other technical details. Often the credits also mention what music the creator listened to while creating the colly.

G. Greetings

Greetings, or greets, list the creator's personal acquaintances.

H. Acknowledgments (respects)

In acknowledgments, or respects, Amiga ASCII artists who are admired and respected by the creator are listed, even if they are not personally known.

Greetings and acknowledgments were once important for increasing visibility. In listings called ASCII charts, Amiga ASCII artists were ranked by popularity using various metrics. Amiga ASCII artists could be publicly voted on, or the greetings and acknowledgments included in collies were counted together, measuring the artist's popularity. Those who received the most greetings and acknowledgments from other artists topped the list, in turn increasing their popularity and visibility of their collies. Rankings also took into account for whom other artists had made logos. This partly motivated designing logos for other ASCII artists^[54].

The largest archive site for Amiga ASCII collies, asciiarena.com^[55], lists about 4,000 collies from 780 different artists spanning the years 1992-2015. Most of them were released before the year 2000. While Amiga ASCII might be considered a niche subculture, the number of artworks and artists indicates a significant phenomenon.

PRODUCTION PART

3.1. MY STARTING POINT FOR CREATING ASCII ART

I didn't get to witness the golden days of BBSs and ASCII art or belong to the ASCII art-related subculture because the subculture had already waned by the time I started my computer hobbies in the early 2000s. However, I remember what the Internet was like in the late 90s and early 2000s. It was a magical and mysterious place for me, where every now and then, I'd encounter these strange images made up of mere characters. These could be seen in text-based info files of downloaded files, comments on discussion boards, or hidden in a website's source code. These images intrigued me, and at about ten years old, I too wanted to master this art of image-making: slowly, one letter at a time, I typed an image of a DJ playing records. The technique was challenging and time-consuming enough that I tried it only once.

In January 2014, I found a web-based hobby magazine on the internet, OrDeR Of ThE ShAdOw Wolf, a cyberzine, made by the Dutch electronic music-producing artist Danny "Legowelt" Wolfers. For a moment, the internet felt magical and mysterious again, as I read text laid out in green monospaced font on a black background, with titles and images made in ASCII.

Legowelt starts the cyberzine with these words:

"Welcome to the first issue of ORDER OF THE SHADOW WOLF, a cyberpunk e-zine in true original text format. This is how e-zines looked before the dawn of the internet in the 1980s and early 1990s. They were distributed via BBS's [...]. People would download these e-zines on their 300 baud modems and read them on their monochrome green screens late at night. Difficult to imagine now but doing this felt like the most exciting thing in the world, surrounded by a mystique of hacker romanticism and being a cyberpunk pioneer. It was a time when your mum and retarded jock cousin weren't on the internet, even more hardcore...you were probably the only person in your whole town or area logged into cyberspace!" ^[56]

I wanted to delve into this obscure subculture and the way of making images. It felt fascinating. I also don't believe I'm very skilled in illustrating, designing logos, or producing visual material in general. I wanted to enhance my creative expression. After trying to draw my first ASCII image, I found that making logos and images with the constraints set by ASCII is quite liberating. The limitation of the ASCII character set forces creativity and uses it as a strength for making images. The primitive nature of this medium felt like the right method to develop my expression.

I set the following goals for myself before embarking on the project:

"I intend to try various styles and techniques to draw logos with ASCII. Initially, at least, I will use the word "GRMMXI" as the text for my logos, which represents my friends/classmates/artistic community for whom, and to whom, I'm creating these logos. This will keep me motivated. Through experimentation, I aim to observe shapes, typography, logos, and textures in a new light, thereby evolving as a graphic designer. I also haven't done much logo design before, so I hope this approach brings new perspectives to logo design."

3.1.1. FINDING THE RIGHT METHOD

I work as a web designer, so I started working on my first experiments with the text editing tool I know best: a code editor. However, I soon realized that with the default font of the code editor, I couldn't produce results that met my expectations: the characters didn't mesh well together. I wanted to know how ASCII art is really made.

While getting acquainted with ASCII art, I wasn't yet aware of the existence of Amiga ASCII. From the site sixteen-colors.net^[57], which archives ASCII and ANSI art, I found the logo of the Break group (Figure 17). I had never seen ASCII graphics of this style before, where the lines connect almost seamlessly. I wanted to make my thesis using this technique and began to delve into the technical characteristics of this style.

In my search, I found the website asciiarena.com, which archives Amiga ASCII collies. It is the most comprehensive site archiving Amiga ASCII and now serves as the primary publishing channel for new Amiga ASCII works for many. The site is full of increasingly impressive Amiga ASCII collies, and browsing through the works of others served as a significant source of inspiration throughout the project. I decided that I wanted to publish my project on this site in its original colly format.

I found and installed the original Amiga fonts^[58] in TTF format on my computer. This allowed me to start creating Amiga ASCII images and delve deeper into the method of making ASCII images. I set my text editor's user settings to use the Amiga Topaz font, reduced the line height, and changed the colors to black and white. This allowed me to achieve the desired results.

3.2. PRODUCTION PROCESS

3.2.1. DESCRIPTION OF CREATING AMIGA ASCII IMAGES

Typing each character by hand required absolute focus. However, using the cut-paste technique, experimenting with new shapes and ideas was easy and smooth. This process enabled constant evaluation of the work. From the same logo, several different variations could be made.

However, creating logos began to feel challenging and rigid. Comparing my logos to those made by others, I felt that I was not succeeding in creating an original yet stylish logo type. I tried sketching ASCII logos in a drawing book, but that also felt frustrating since, for instance, curved shapes are tricky, if not impossible, to make with Amiga ASCII. It was better to draft directly in the text editor and let the restrictions set by the characters influence the formation of the shapes.

For this reason, I wanted to break free and create images and logos that deviated from Amiga ASCII conventions. I also realized that I didn't need to follow the footsteps of previous ASCII artists and therefore didn't set clear content guidelines. I only decided in advance that I would try different methods and see what felt right and most inspiring. Hence, the image themes don't follow a clear unified line; the result consists of different experiments.

I tried a more expressive form language by creating logos that consisted of sharp angles and straight lines combined with wiggly shapes using parenthesis. Using parentheses seemed promising since I hadn't seen many using them in their logos. I challenged myself and created a "slimy" logo that dripped downward using parentheses, which I found successful.

In one logo experiment, I added eyes and a mouth, making the letters look like fun characters. This inspired me to try creating human figures. With the special characters of the Amiga ASCII character set, I was able to create faces in different perspectives. The easiest facial features were the eyes, which I made using "hatted" variatons of a-, o-, and u-letters. However, making the mouth was challenging since very few Amiga ASCII characters are diagonally inclined. Drawing hands and feet also proved extremely difficult because of their round shapes.

However, this image theme felt funniest and most inspiring to me. I felt most creative when making characters. According to Michael Hischer, whom I interviewed, representational images weren't highly valued in the past, but they are now viewed positively^[59], which motivated me to continue drawing characters.

My enthusiasm for creating images experienced highs and lows. My initial goal was to draw at least one ASCII image per day, which I did in the early stages of the project. However, making logos felt challenging, and I became frustrated with my drawing. Satisfaction was hard to come by. Additionally, immersing myself in the topic and writing about it took a significant amount of energy. Writing the thesis was challenging from start to finish, as I realized early on that I had chosen a nearly unexplored topic. However, Amiga ASCII as a subject is extremely interesting, which helped me persevere in creating the thesis.

3.2.2. MAKING THE COLLY

In the end, I created over 50 different logo and character experiments. I thought the number was too small to produce a decent final product, but when making the colly, I realized it was still sufficient.

I refined the ASCII images I had made and constructed the colly using the PabloDraw program. PabloDraw^[60] is an ASCII/ANSI editor for modern operating systems. It is specifically designed for ASCII art creation and includes Amiga's original Topaz font and column settings. For the colly, I had no clear idea; instead, I brought my separate image experiments into the program and started building suitable combinations from them.

The pieces fell into place on their own. At the beginning of the colly, I created a dreamscape that continues in a comic-like manner with a person pondering the creation of a thesis, adding a meta-level to the colly. From within the dreamlike landscape, the title of the colly, "innocence," is revealed, which I chose as a name to describe, firstly, the childishly innocent starting point of my authorship as a new ASCII artist, but also proclaiming my innocence in creating an unconventional colly stemming from my background.

After this, the colly continues with various styles and experiments that vaguely intertwine. My original ASCII images laid the foundation for the colly, but I still had to do a lot of work adding backgrounds, decorations, and details.

I find the final result interesting, and I am satisfied with it. The colly turned out to be significantly illustrative, which deviates from the traditions of Amiga ASCII collies. However, I believe this is a positive aspect since the colly as a whole remains cohesive and intriguing.

Click here to view the colly as image

3.2.3. PHYSICAL FINAL PRODUCT

Collies are usually viewed on a computer screen, but I wanted to materialize my product into a physical form. This seemed like a challenging task, as collies are typically continuous, spanning several pages in length, making them difficult to sensibly present, for example, on the pages of a book.

I came up with the idea to print my Amiga ASCII images using a dot-matrix printer. It can print on continuous form paper, which modern printers cannot do. Continuous form paper is a continuous strip of paper perforated at regular intervals. Dot-matrix printers were common in the 80s and 90s before the advent of proper inkjet and laser printers. In a dot-matrix printer, graphics are printed as dots by striking pins against a black ribbon onto the paper. This was perfect for my purpose, as my images are black and white and would cover several vertical A4 pages in total. As the device was popular around the same time Amiga ASCII was most commonly produced, it also served as a fitting historical reference.

However, I don't own such a device, and according to a Facebook poll, none of my acquaintances did either. The device seemed to be outdated technology that no one had. But I didn't give up; I searched for "dot matrix printer" in the Fonecta search service. The search yielded only one result: the printer-manufacturing company, OKI Finland. I emailed them, asking if they knew where I could borrow a dot-matrix printer. Fortunately, and to my surprise, they had one to lend, which I borrowed for a month.

However, my luck changed when, upon testing the printer's features, I found out that it was not possible to print a completely continuous image. The printout of my production turned out to be over 5 meters long, and the printer left a margin of about a centimeter every 30 centimeters or so. This is due to the printer's drivers, which were not designed for long print runs, even if it would be theoretically possible. Nevertheless, I didn't let this discourage me, as the idea of the production still comes through despite this.

CONCLUDING REMARKS

The aim of the project was to explore Amiga ASCII culture, learn to observe forms, typography, and textures in a new way, enhance my creative expression, and gather insights for graphic design.

Amiga ASCII significantly resembles graphic design. It is used to embellish user interfaces, create logos for clients, and typographic design lies at its core. However, I don't feel that I've gained any practical benefit as a graphic designer from this project. The method of Amiga ASCII is unique, and it has no practical link to today's world. It's hard to instrumentalize. It operates under its own rules, in the margin, outside the mainstream. It is anti-capitalist, even anarchistic, because it is difficult to commercialize or display in art galleries. It can be described as digital folk art or tradition. It pales in expressive power compared to many other art methods. Yet, it's alluring, charming, and delightful because of its peculiar nature.

I don’t see that I have developed as a designer, but I feel I have gained immensely from the project. I am pleased to have been introduced to such an interesting topic. In my view, I have provided a comprehensive description of the subject. I feel proud to have learned a skill that many people I know had never even heard of, and in that respect, my goal was met: I developed my creative expression. However, I only scratched the surface and see a lot of potential in the method. I definitely intend to continue creating Amiga ASCII art. It would also be great if my project helped me become part of the Amiga ASCII community.

As Matt “mattmatthew” Yee states in a Blocktronics interview:

"The works done by new and old artists these days are probably the best the scene has ever seen, with a few exceptions. My peers have developed this method further than it has ever been developed before. This is an exciting time to draw." ^[61]

I look forward to following the development of Amiga ASCII art.

SOURCES

5.1. PRINTED SOURCES

• Bann, Stephen (1967): Concrete poetry. An international anthology, Lontoo: London Magazine editions.
• Coulmas, Florian (1999): The Blackwell Encyclopedia of Writing Systems. John Wiley & Sons Ltd.
• Halliday, M.A.K ja Hasan. R (1976): Cohesion in English. Longman.
• Jäntti, Yrjö (1940): Kirjapainotaidon historia. WSOY.
• MikroBitti-magazine 6–7/1992
• Tullett, Barrie (2014): Typewriter art: a modern anthology. Lontoo: Laurence King Publishing.

5.2. UNPRINTED SOURCES

5.2.1 INTERNET-SOURCES

• Amiga History Guide (2003): The Twists and Turns of the Amiga Saga. WWW-page. < http://www.amigahistory.co.uk/ahistory.html >
• ASA (1963): American Standard Code for Information Interchange. ASA X3.4–1963 < http://www.worldpowersystems.com/projects/codes/X3.4-1963/index.html > 10.4.2015.
• BYTE-magazine (5/1977): System description, The Apple-II. < https://archive.org/stream/byte-magazine-1977-05/1977_05_BYTE_02-05_Interfacing#page/n35/mode/2up > 10.4.2015.
• Carlsson, Anders & Miller, Bill (2012): Future Potentials for ASCII art. Goto80 WWW-page. < http://goto80.com/chipflip/06/ > 10.4.2015.
• Dubost, Karl (2008): UTF-8 Growth On The Web. W3C Blog. World Wide Web Consortium. < http://www.w3.org/blog/2008/05/utf8-web-growth/ > 10.4.2015.
• Elmansy, Rafiq (2014): Taking A Closer Look At Arabic Calligraphy. Smashing Magazine WWW-page. < http://www.smashingmagazine.com/2014/03/20/taking-a-closer-look-at-arabic-calligraphy/ >
• Hargadon, Michael (2011): Like City Lights, Receding: ANSi Artwork and the Digital Underground 1985-2000. Masters thesis, Concordia University. < http://spectrum.library.concordia.ca/7341/1/Hargadon_MA_S2011.pdf >. 10.4.2015.
• Hertzen, Gustav von (2007): Demokratian haaste. Gummerus. < https://gustavhertzen.files.wordpress.com/2011/01/demokratian-haaste-kirja.pdf > 10.4.2015.
• Hirvonen, Mikko (2010): BBS-harrastajat 1990-luvun tietoverkkokulttuurin murrosvaiheessa – näkökulmia Internetin kulttuuriseen omaksumiseen. Turku: Turun yliopisto. < http://users.utu.fi/petsaari/tutkimukset/gradu 12.04.2010.pdf > 10.4.2015.
• Holler, Richard (1994): FILEID.TXT v1.9. Textfiles WWW-page. < http://www.textfiles.com/computers/fileid.txt > 10.4.2015.
• Karaiste, Mikko (2008): Amigaskene, alakulttuuri tietokoneen puitteissa: kuvauksia alakulttuurin ja teknologioiden yhteenkietoutumisesta. Jyväskylä: Jyväskylän yliopisto. < https://jyx.jyu.fi/dspace/handle/123456789/38191 > 10.4.2015.
• Knowlton, Ken (2005): Mosaic Portraits: New Methods and Strategies. YLEM Journal, Jan/Feb 2005 25 No. 2 < http://computer-arts-society.com/uploads/page59.pdf > 10.4.2015.
• Korpela Jukka (2001): A tutorial on character code issues. IT and communication. WWW-page. < http://www.cs.tut.fi/~jkorpela/chars.html#more > 10.4.2015.
• Popova, Maria (2014): A Visual History of Typewriter Art from 1893 to Today. WWW-page. < http://www.brainpickings.org/2014/05/23/typewriter-art-laurence-king > 10.4.2015.
• Reunanen, Markku (2010): Computer Demos – What Makes Them Tick? Helsinki: Aalto University School of Science and Technology. < http://www.kameli.net/demoresearch2/reunanen-licthesis.pdf > 10.4.2015.
• Reunanen, Markku (2013): Neljän kilotavun taide. WiderScreen 2–3/2013. WWW-page. < http://widerscreen.fi/numerot/2013-2-3/neljan-kilotavun-taide/ > 10.4.2015.
• Victoria and Albert Museum: A History of Computer Art. WWW-page. < http://www.vam.ac.uk/content/articles/a/computer-art-history/ > 10.4.2015.
• Wikipedia: ASCII < http://en.wikipedia.org/wiki/ASCII > 10.4.2015.
• Wolfers, Danny (2014): ORDER OF THE SHADOW WOLF. E-ZiNe Issue #1 1/2014 < http://www.legowelt.org/shadowwolfissue1.html > 10.4.2015.
• Yee, Matt (2015): Interview with mattmatthew. Blocktronics blog. < http://blocktronics.tumblr.com/post/112450171273/anyone-already-familiar-with-blocktronics > 10.4.2015.

5.2.2. DOCUMENTARIES

• Scott, Jason (2005): BBS The.Documentary Part 1 - Baud. 9:00. < https://www.youtube.com/watch?v=JnSz-Hb9LQY > 10.4.2015.
• Scott, Jason (2005): BBS Documentary Interview Collection: John Sheetz. < https://archive.org/details/20030322-bbs-sheetz > 10.4.2015.

5.2.3. INTERVIEWS

• Kiuru, Antti (2015): Interviewed in person. Helsinki. 5.4.2015.
• Hischer, Michael (2015): Interviewed through email. 18.3.2015.

5.3. IMAGE SOURCES

• Figure 1. Lotvonen, Heikki (2015).
• Figure 2. Macpuerto (2013): Caligramas. Image from the WWW-page. < http://macpuerto.com/wp-content/uploads/2013/12/03_simmias_rodas.jpg > 10.4.2015.
• Figure 3. Tullett, Barrie (2014): Typewriter art: a modern anthology. London: Laurence King Publishing. Scanned 10.4.2015.
• Figure 4. Tullett, Barrie (2014): Typewriter art: a modern anthology. London: Laurence King Publishing. Scanned 10.4.2015.
• Figure 5. Scott, Jason (2005): Images from John Sheetz interview. Image from the WWW-page. < http://www.bbsdocumentary.com/photos/099sheetz/M/p1010032.jpg > 10.4.2015.
• Figure 6. Lotvonen, Heikki (2015).
• Figure 7. Knowlton, Ken (1966): Ken Knowlton Mosaics. Image from the WWW-page. < http://www.knowltonmosaics.com/pages/HKnewd.htm > 10.4.2015.
• Figure 8. Lotvonen, Heikki (2015).
• Figure 9. Lotvonen, Heikki (2015).
• Figure 10. Lotvonen, Heikki (2015).
• Figure 11. cwilson5603 (2008): Last Callers Screen. Image from Flickr. < https://www.flickr.com/photos/22767465@N05/2732637059/ > 10.4.2015.
• Figure 12. Lotvonen, Heikki (2015).
• Figure 13. Zeus (2014): zeitgeist|moving|on. Image from the WWW-page. < http://amiga.textmod.es/colly/se-zeit/ > 10.4.2015.
• Figure 14. Kiuru, Antti (2015): Jungle Fever. Image from the WWW-page. < http://amiga.textmod.es/colly/ds!-jufv/ > 10.4.2015.
• Figure 15. Kiuru, Antti (2015): Jungle Fever. Image from the WWW-page. < http://amiga.textmod.es/colly/ds!-jufv/ > 10.4.2015.
• Figure 16. Zeus (2014): zeitgeist|moving|on. Image from the WWW-page.< http://amiga.textmod.es/colly/se-zeit/ > 10.4.2015.
• Figure 17. Break_06 (2014): FILE_ID.DIZ. Image from the WWW-page. < http://sixteencolors.net/pack/break_06/FILE_ID.DIZ > 10.4.2015.
• Figure 18. Lotvonen, Heikki (2015).
• Figure 19. Lotvonen, Heikki (2015).
• Figure 20. Lotvonen, Heikki (2015).
• Figure 21. Lotvonen, Heikki (2015).
• Figure 22. Lotvonen, Heikki (2015).

FONT USED IN PRODUCTION

“ttf version of TopazPlus” by dMG/t!s^dS! is licensed under CC BY-NC-SA 3.0.0 < http://www.trueschool.se/html/t!s-af10.readme.html > 10.4.2015.

Footnotes