Computational Explorations in Asemic Writing

This is a written (and expanded) version of the talk I gave, titled "Meaningless and Inhuman Gestures: Computational Explorations in Asemic Writing", in Ligatures 2025.

One subject that I’ve been chewing on for decades now, is the mechanics of writing: how a stroke is produced, how the tools and its manipulation change its modulation, how we give writing — and text — its configuration. And, surely, what this things and systems are for, thus how many ways do we have to do them.

When I was teaching at the Design and Visual Culture MA programme¹, the semester always started with a lecture on the History of Writing Technology, in order for the students to quickly realize that the way we write is also constrained by what we chose to write with, and that the shapes we’ve inherited went through the same choices.

In my type design practice, this is also constantly on my mind: what tools am I emulating when producing a stroke, a lettershape, a block of text? I find this thinking process useful for two reasons: digital design is an emulation environment, where we are translating physicality to something abstract; it is grounding to refer to some materiality instead of pulling something from the ether — if there is only ether, all I can get is ether.

In this context, this whole thinking process started to become isolated from the shapes we build with strokes. Strokes became a phenomena in itself, where the emulation is tri-fold: tool, stroke, shape.

1. A Semblance of Things

I remember, as a kid, of being fascinated by seing something written in a writing system that was foreign to me: it had this esoteric aura to it, some sort of information that was kept away from the uninitiated. Very spooky, very enthraling. Probably just a shopping list, but fascinating, nonetheless.

So bringing the idea of emulating strokes, why not emulate something with them that produces that feeling: utterly meaningless shapes, composed in a way that instill the belief that there is meaning. Even better, what if I let the computer decide these, so I can infinitely generate surprises for myself?

So, to start, I needed a way to produce strokes.

2. Generating Brush Squiggles

I first went for brush strokes, mostly because I want to make a proof-of-concept of an old contingency I have whenever I have a discussion about Gerrit Noordij’s The Stroke. Even though I keep reccomending it, I think that there is very common for people to make a particular disservice to it: Noordij was very well aware that there was much more to stroke production than just the translation/expansion categorization².

Nor translation, nor expansion are mutually exclusive — in fact, they happen at the sime time. Catich, in The Origin of the Serif, alludes to the effects of pressure in the use of a flat brush.

Moreover, the writing tool isn’t the only tool in stroke production: inking, gravity, abrasion and friction, surface texture, absorption — all contribute to the end result³.

So, where do we start? With a single bristle.

2.1 A Bristle Through a Path

First, a summary⁴:

A gesture transforms a tool in space. The path of intersection between the tool and the surface is the ductus. At any point where the tool intersects the surface, a mark is produced. The superimposition of all the marks in a ductus is the stroke.

OK, so we need a ductus to propagate marks on. Got it:

Then, we need a mark to propagate. Let’s go for a circle:

Now, this is still not very exciting. To add some spice, let’s imagine a real brush: if I move it slowly against the paper, more ink gets absorbed. If fast, not so much. So I can change the size of the mark progressively to emulate this. Let’s say that it is faster at the middle of each segment.

OK, better. Another thing that happens is that hairs are pushed outwards when pressure is applied to the brush, inwards when it is released. And we tend to apply less pressure in fast movements. Let’s try it:

Cool! Now, if we thin everything down, overall, and add more bristles, we get this:

2.2 A small problem, a small detour

Now we have to tackle another problem. Every single segment starts thick, goes thin at the middle, ends thick again⁵. This is a bit predictable, unnatural.

While snooping the interwebs for whomever had tried to do something like this, I stumbled upon Ahmad Moussa’s brilliant tutorial on using Hooke’s Law to simulate brush speed. It is a very elegant solution to this, and it’s worth for you to check it out.

In spite of it, I didn’t go for this solution: it is dependent on movement and I wanted to generate the squiggles, not draw them. Also, I didn’t want to be constrained to framerates for the in-between instances, I wanted something less fragmented.

So, I came up with a hack. If your memory on the de Casteljau’s algoritm is still fresh, you know that lerping points in a curve segment depends on the handle’s extension: when extended further, the larger (in distance) the steps are on that side of the curve.

Then we can make use of this as our proxy for speed: the larger the lerped segment is, the faster it is.

With all this set, we can now generate sequences of connected curve segments as if we were writing. Make a squiggle, store the last point and handle, continue to the right, and interrupt sometimes. It looks something like this:

3. Back to Matter

By the end of the pandemic, I built my first pen plotter. A terrible one, sure, but hey, I’m still proud of what I did without knowing much about what I was doing.

So, emulating physical writing so that it ends up going back to writing was amusing enough to try. You know why I didn’t I just squiggle by hand? Because.

Regardless, plotting brought another ideas to the table: these gestures now have to be programmed, so one might has well think about composition too. But what makes the semblance of text?

Realizing that we identify categories of text by they shape/composition — hierarchy, vertical and horizontal rhythm, justification and so on — gives us some pointers. A titled slim column of text makes us think of a newspaper text block; classical poetry categories, such as haikus or sonnets are immediately identified.

And sometimes, these semblances are practical — take greeked text, for example: made to save on processing, it reduces text to its apparent structure. Making boxes with horizontal lines while doodling a layout on paper is so common that we not even think about explaining what it represents when showing it to a colleague.

These structures too are worthy of experimenting with.

4. Wrapping Up

So here it is: a small window to the musings that go through my head while I’m playing. And after some years doing other things, it’s good to be back at the blog.

Oh, and if you’re messing around with plotters or computational typography, I’d love to see what you are building. Or just say hi!

Have a good one!

References:

• Noordzij, Gerrit, The Stroke: Theory of Writing. Hyphen Press.
• Catich, Edward M., The Origin of the Serif: Brush Writing and Roman Letters. The Catfish Press, 1968.
• De Casteljau’s algorithm, Wikipedia.

1. I was lecturing Typography and Editorial Composition at IADE / Universidade Europeia, in Lisbon. ↩︎
2. You can find it in a very brief reference to chiseling and its diagram. Also, Noordzij was very clear that the focus of The Stroke were only two tools: a pointed nib and a broad nib. ↩︎
3. We’re working on something at 0.itemzero, regarding an alternative way to think about stroke production in type design. Keep an eye there! ↩︎
4. If you’ve been following me for some time, you know how much I love these cryptic definitions. ↩︎
5. That’s what they s… — No, Fábio, no. ↩︎