Optotypes? No, Optician Sans!

0. Introduction

If you ended up here, you probably heard about Optician Sans. I mean, it’s everywhere, from Fast Company to Gizmodo, introducing me to the experience of finding time to do e-mail and podcast interviews. I have even considered turning Behance notifications off, due to the constant phone buzzing (yes, I have now turned the vibration off for notifications – #smartFábio).

If this sounds snobberish, arrogant and ungrateful, it’s quite the contrary: I am flabbergast about how this came to be: all of this attention was completely unexpected to me.

Part storytelling, part making of, part as an outlet to process this phenomenon, I’m writing this so I can tell you what this typeface is and how it came to be in a degree of detail that I couldn’t do otherwise.

Alright, let’s do this!

1. The Backstory

1.1 Hello Reddit! Hello Simen!

After Optician Sans’ release into the wilderness that is the Internet, during a videocall to plan some stuff, I asked Simen Schikulski how he found me.

Simen is a gentle person, soft spoken and with dreamy eyes, that – once the conversation gets going – unveals his excitement and inner drive from his quiet demeanour. And he happens to work at ANTI Hamar, the Norwegian studio that commissioned me the production of Optician Sans – in fact, he was the person who started the typeface.

It was on Reddit: you offered me help to finish the typeface!, he told me. I had completely forgotten about it.

Simen’s post on /r/typography caught my eye for two reasons: first, I usually go around the subreddit to help people out; second, because it was about optotypes – at that time, I was researching about it myself to produce materials for my Masters’ students.

2. Optotypes

2.1 Optotypes?

Hold on, what’s an optotype? Right.

According to the Merriam-Webster entry on optotype, we have the following definition:

Optotype: figures or letters of different sizes used in testing the acuity of vision — usually used in plural.

Even if you are in no need of glasses — and unless you live in North Sentinel Island (how did you get an Internet connection over there, by the way?) — the chances are that you’ve had several close encounters with optotypes, most likely through a Snellen or LogMAR chart.

For a long time, looking at these at the optometrist and/or physician, I’d think something in the lines of oh, that’s horrible!, considering them poorly designed. This was, of course, a conclusion out of my own ignorance – but they still look ugly, though.

2.2 Visual Acuity, Not Legibility

In the midst of all these articles and interviews, I stumped into a widespread idea that was somewhat surprising to me – that optotypes are more legible. They’re not.

In fact, if optotypes were constructed to be highly legible, it would defeat its purpose: these are built to measure visual acuity, i.e., to test how capable your eyes are to distinguish between small details. As you can deduce, ambiguity is somewhat key and, as I stated before, ambiguity isn’t really legibility’s best friend.

But how is accuity measured? Why these charts?

Erik van Blokland has explained this way better than I could, but I’ll still try to summarize it:

If you have noticed at the optometrist, you look at the chart from a specific distance. And each optotype size corresponds to a different angle from your eyes’ lenses.

If that image projects itself onto your retina at different angles, the smaller the angle, the less photoreceptors are being used to see that figure.

For example, the 20/20 line corresponds to 5 arcminutes and we then know that around 10 photoreceptor cells are being used (in the fovea, where the highest concentration of cones is).

That is why optotypes (at least Schellen and Sloan) are designed in a 5×5 grid – each stroke corresponds roughly to 2 cells at 20/20.

3. Making Optician Sans

3.1 The Commission

As stated in §1, ANTI Hamar hired me to produce a bespoke typeface for one of their clients. The client is Optiker-K, a family-held Norwegian small business, providing optician and optometrist services since 1877.

So, for Optiker-K’s rebranding, Simen designed a first draft of the typeface, but something wasn’t quite right: at this stage, we stumbled upon eachother and he ended up hiring me.

3.2 The Brief

Initially, this was a calibration commission: to balance strokes, proportions, to correct node placements, to space it and hint it, to compile the typeface in a distribution-ready package.

In spite of this, what I got from the conversation with Simen was some sort of hey, can you make this work? proposal, so I started to look for inconsistencies – and ending up detouring from the brief.

You see, the Sloan letters weren’t built to work as a typeface: if you compare, say, the S with the C or the O, they seem stylistically unrelated. At some point, it struck me that we were dealing with glyphs from two different typefaces, almost randomly picked and joined together.

But our goal was to have a consistent look for the brand. Secretly (read: without asking), I redrew from scratch what Simen provided (in FontLab VI, as usual, since you’ve been asking), in two character sets: a more rounded, friendlier one (inspired by the O and C shapes); and a more blocky one (looking at the S).

Then, with a hint of fear, I pitched them to Simen, who cheerfully agreed straight away. *phew*

3.3 Logo-in-a-font

Apart from the two alternate character sets, Optician Sans offers an Easter Egg: while looking for a fast way to deploy Optiker-K’s logotype, we decided to include it inside the font itself; so whenever you type O-K or Optiker-K, the logotype automagically appears!

4. Hello Internet!

Free. Yes, for free.

The client, Optiker-K, decided to release the typeface for free. So you can send e-mails to them and to ANTI Hamar, filled with heart emoticons and unicorn hugs.

Upon release, well, the web went crazy, way beyond what we expected, especially for a font made to work in English and Norwegian only.

So thanks for the love, everyone! It feels really good to have made something that everyone is enjoying so much!

4.1 The Future – Present, actually.

With all this attention and cheering crowd, we decided to take some small steps forward:

• The typeface is available on GitHub – if you want to keep track and fork it to your own servings, please do!
• The License changed to SIL OFL to make this possible;
• We’re slowly expanding the font to support more languages!

5. Wrapping Up

I hope enjoyed knowing a bit more about this typeface. If you wish to know a bit more on ANTI’s side, check Simen’s article on Medium.

And, if you haven’t already, subscribe below to keep in touch! Cheers!

References and Further Reading:

1. Optician Sans microsite;
2. Completing the work of a typeface that was started decades ago, Simen Schikulski;
3. Testing The Limits of Human Vision, Verge Science;
4. Optics, Erik van Blokland;
5. Visual Acuity, Wikipedia;

Making Grafista

1. Concept

Grafista is (semi-)monospaced typeface that has two sets: a text typeface and a texture library.

The reason why I called it semi-monospaced is because these two sets have different widths: the text set’s width is half of the textures’ one, making it possible to combine both in the same text box.

The idea behind Grafista was to “challenge” the standard notion of what a typeface is for: basically, a typeface is a collection of box and forms in those implicit boxes: not necessarily something to compose text with.

With this, I’m not claiming that this is something new: throughout history, numerous punchcutters and type designers have included texture or tile sets in their typefaces, whether for borders, pictograms, ornaments or any other non-letter elements.

At the same time, the format of a font makes a texture bank easily accessible through a glyphs panel or a OpenType feature, spanning through a wide variety of software or applications.

2. Genesis

Grafista is a reincarnation of a failed incarnation called Maoos.

The idea behind Maoos was to create a typeface that had the primary focus of being a texture bank, a library of pre-made graphic tiles that one could use to create images, not necessarily text.

But the reason why Maoos never got to see the light of day was that something was wrong. Sure, the tile part was working: the idea behind it was tested and it was working. The text part didn’t.

The letterforms were nice-ish; I mean, they were congruent as a whole, but these two parts (textures and text) were two separate things, with no connection what so ever.

So, I’ve tried several approaches to Maoos, trying to blend the letterforms with the textures: several line width, multi-layering sets where textures only lived in the counters, alternative glyphs; it was always a mess and adding layers of complexity to it wasn’t helping – it soon became one of those typefaces in the drawer (or in a backup disk, to go with the times).

Some years passed (I started tinkering with Maoos in 2013), Maoos had many problems: the letterforms weren’t neutral, comparing with the textures, so both sets would live in different realms; proportional forms would make side-by-side use with the tiles dodgy and to be avoidable at all costs; multi-layering sets is a production headache for the end user, among other small bits.

So, I ended up trying to cram way too many things in a single typeface, without realizing that beef and deodorant in the same package wasn’t a sensible deal.

A couple of months ago, while working in a monospaced typeface (news on that to be announced), it hit me: if I could do something fairly neutral, sturdy and monospaced, it might work with the textures. And it did: Grafista was born.

3. A typeface with letters

Monospaced typefaces have a mechanical vibe to them. Even the typewriter ones, with all their nostalgia, still feel technical, due to the fixed width. They have an implicit and very obvious system that implies a mechanism, while most proportional typefaces try to fight the technical nature of the composing system in order to achieve reading comfort.

Sure, readability and legibility were considerations while drawing the roman, but they weren’t the main goal: the however you do it, it works motto was the main focus while developing Grafista; I wanted you to have the freedom of using it without the concerns of micro-adjusting your compositions.

On the formal side, the choice of borrowing traits from grotesque and coding typefaces were due to the simplicity of the tile elements: in Grafista, complexity comes from the add-up com combinations, not the tiles themselves. So, considering how simple the tiles are, as a single element, the letterforms should follow the same logic.

I wasn’t looking for a fit-for-everything text typeface, I wasn’t looking for solving a technical problem and I certainly wasn’t looking for nostalgia. However, I was certainly looking at the text part as something heavily graphic, where text and textures could be used at the same time, whether in single or multi-line compositions.

“A typeface is a beautiful collection of letters, not a collection of beautiful letters.” – Matthew Carter

Or, in this case, a beautiful collection of letters and forms.

4. Making tiles

Tiles should be, huh… tilable.

Maybe I’m biased in this: I’m Portuguese, a culture with a centuries-old obsession with tiles. Tiles are everywhere, in an impressive array of shapes, colors and applications. We’re probably as obsessed with tiles as we are with food: and our food is awesome.

In Grafista, every texture glyph is treated as a tile: you can seamlessly repeat each block vertically or horizontally. Or use it as some sort of pixel. Or pre-made graphic elements to play with. Or as a way to reach enlightenment, if that’s your sort of thing (e-mail me if it happens).

Still (and it sort of comes without saying), you can cannibalize the textures to your liking and treat them as pure graphical elements.

5. Wrapping Up

Grafista is now out! Grab your copy and contact me to show me what you’ve done with it!

I hope you’ve enjoyed knowing a bit more on how Grafista came to be! See you in the next article!

Making a Font: Maximal – Part III

Part I | Part II | Part III

Welcome back to this series about the production of Maximal. If you’re a newcomer, don’t forget to check Part I and Part II, so you know where you’re at; or better, what we’re talking about here.

This article is about programming. Since we’re dealing with such a massive amount of glyphs, developing/adapting some tools to make production easier is a big deal. Besides, the (pseudo-[we’ll get to that]) randomness of this typeface involves – you got it – programming.

1. Generating Glyphs

Let’s start with something not so code-y.

As planned, we need 30 glyphs per letter, apart from the main glyph. For organization and management sake, if the base glyph is E, for example, I want to call the variations E.ss01, E.ss02, E.ss03 and so on.

Why? Well, I use FontLab Studio, and it lets me batch generate glyphs. At the same time, it ignores what’s after the period and generates a component with the letter E, which is handy to start editing. So, in FontLab Studio, if I want to generate a whole bunch of glyphs, I need to input something like this:

E.ss01 E.ss02 E.ss03 E.ss04 ...

Writing down 30 of these, one by one, for hundreds of glyphs, is tiresome. So, I’ve made this little app, just for this project, that does just that. Feel free to use it for your own needs, since I’ve thought that you might just do that and made it in a way that you can choose your own prefixes.

I won’t go over the app’s programming, though, since it’s plain old HTML + Javascript (something very easy to find on Google for clarification) and you can check the source code on the spot.

2. Making Classes

Most of OpenType features work by substitution glyphs and/or groups of glyphs. For example, if you have a f+i ligature – and let’s say that that ligature has the name f_i – your code to display the ligature whenever you type fi would look like this:

sub f i by f_i;

Simple, right?

Now, as we’ve settled on Part II, we have 30 variations of each glyph, which leaves us with a bit more than 13.000 glyphs to manage. Can you imagine coding everything glyph by glyph? Not a very appealing idea, right?

Well, we have classes at our disposal. Basically, we can grab a bunch of glyphs and store them in a class, repeat that for every style set (while keeping the same order) and instead of substituting the glyphs, we substitute the class. For those staring and blinking: instead of coding 13.000 times, we’ll just make it 31. Bear with me.

In OpenType coding, a class is identified by the prefix @. So, let’s say we have two classes, class1 and class2. If we want to substitute all the glyphs stored in class1 by the glyphs in class2, it would something like this:

sub @class1 by @class2;

If it’s your first time tinkering with OpenType features (or not, anyway), have a look at Tal Leming‘s The OpenType Cookbook and bookmark it. Seriously: it’s that awesome (and did I mention free?).

2.1 So, What’s What?

So now that we know how classes work and the basics for writing OpenType substitution routines, lets go through the classes in our font. Here’s how I’m naming them:

ss00 => Our default glyphs
ss01 => Stylistic Set 01
ss02 => Stylistic Set 02
...

And so on. My main goal here is to draw your attention to ss00, which is our non-modified glyph set. This class will be the default one and no glyph substitution will be applied.

The reason for this is, well, people might want to use it without the pseudo-random craziness, as well as any other style. At the same time, you might want to change a glyph or two, without the program changing it back to some other glyph.

With this said, we have three features in our OpenType code:

1. Default: how the font behave out-of-the-box;
2. Stylistic Sets: the 30 different glyph sets;
3. Contextual Alternates: where the pseudo-random magic happens, with glitter and fairies.

I won’t dwell into the first two, since they are very simple and a lot of people around the interwebs have already documented it way better than I could. Again, I recommend Tal Leming’s OT Cookbook.

3. OpenType Random?

OpenType does have a rand feature, introduced by Adobe (S3), but it remains largely unsupported (yes, even by Adobe). XeTeX seems to support it, though, since it allows raw OpenType features.

The usual way type designers go around this, is by creating a pseudo-random glyph substitution routine that cycles throughout.

3.1 True Random vs. Pseudo-Random

So, why isn’t rand widely implemented? Adam Twardoch, in this Fontlab Forum thread, has some very insightful points:

• Each time you open a document (or every time it refreshes the viewport), the rand feature alters your text completely;
• If the alternate glyphs have different widths and/or metrics, the text length also changes (day 1 – 20 pages, day 2 – 19 pages);
• Manual adjustments, such as letter-spacing or line breaks, would have to be done every single time you open a document;

So, pseudo-random code, instead of pure randomness, grants control, it’s predictable and avoids headaches in processing power and editing. Sure, there might be situations where a full-throttle random implementation is desired but, hey – you can always code your own to tailor-suit your needs.

3.2 Pseudo-random Substitution

Pieter van Rosmalen, in this thread on Typophile, shares the code that will be our basis for this font. Here’s the code that we’ll be using as a starting point:

feature salt {
   lookup rotate {
      sub @ss00 @ss00' by @ss01;
      sub @ss01 @ss00' by @ss02;
      sub @ss02 @ss00' by @ss03;
      sub @ss03 @ss00' by @ss04;
      sub @ss04 @ss00' by @ss05;
   } rotate;
   lookup rotate;
} salt;

There are only 5 classes, instead of 30, because I want you to understand this: making this work with 30 or more (and we’ll get there), is simply a matter of extending this logic.

So, first of all, pay attention to the single-quote mark. In OpenType, this means change just this one. Let’s imagine this scenario: we want that everytime that we type EE, we want the last E to be substituted by the glyph E.ss01. The code would look something like this:

sub E E' by E.ss01;

Simple, right? Let’s move on.

3.3 Extending the Code

I did mention that our final code would be an extension of this. So, we want the following to happen and in this order:

1. Check the first pair and change the last glyph with another one;
2. Store the last glyph of the first pair and use it as the first of the second pair;
3. Change the last glyph of the second pair;
4. Do this throughout the algorithm.

This doesn’t seem random at all, right? Well, the trick here is to appear random: so if we have an algorithm that is complex and big enough, it will appear random.

So how will we make this algorithm easily? Automation, again, for the win: I wrote another HTML/Javascript program just to do this task. You can find it here.

And again, the source code is viewable, so use it however you want to.

So now, when we type something in, our font looks like this:

4. Wrapping Up

I hope you enjoyed this post! If you did, you can always share by using the buttons below. For more juice, scroll down and subscribe to the mailing list!

See you in Part IV! Cheers!

References:

1. Thomas Phinney on Pseudo-Random OT code – Adobe Forums;
2. Tal Leming’s The Open Type Cookbook;

Making a Font: Maximal – Part II

Part I | Part II | Part III

I hope you guys had a great Easter (if you’re culturally inclined for such practice – if not, I hope you had a great week).

So, here we are, back on track. In the previous post, we talked about some preparatory steps regarding the conceptualization of the font in hand. Today, we’re going to start analysing an initial prototype, so we can make some early choice of the development to come.

But before we dive into it, I want to thank you guys for such an overwhelming response to the first post. I was really shy to promote it, since I thought it was a very initial approach to this subject, and I thought it was best to leave a more intense promotion to later on, when there was more reading material.

I’m humbled that you guys found a preparatory post interesting enough to share it so much, so my deepest thank you for your attention! I owe my motivation to you and your kindness, so I have nothing to do but my best! Thank you all!

So, to avoid more sappiness from my behalf, let’s get to the point.

1. How many styles?

At this point, this is the most crucial decision to make. As we are going to see in §4, this factor determines how lengthy this process will be.

The only reason why I should be concerned with the time this will take to make is that I want to keep you interested. Since most of you guys are casual visitors (meaning not subscribers [but you can subscribe at the bottom of this page]), this attention can easily go into the void.

To avoid that, I have to consider time. Or you can simply scroll down and subscribe to the newsletter.

Let’s say that we don’t have to worry about time. In this scenario, if we consider the “repetition” model (read about it in the previous post, §3 and §5), a linear incrementation would be the best one, right? Well, sort of.

Yes, it would give you more manual control, but the point here is about random substitution. And the glyph width variation should be extreme enough, since this is not about subtlety, but boldness.

Still, a natural or organic progression, although extreme, is welcome. So, here’s the solution: the Fibonacci sequence. The sequence goes like this:

1, 1, 2, 3, 5, 8, 13, 21, 34, …

The logic here is that any number is the addition of the previous two. In our case, we can skip the 1’s, since that’s our base glyph. And since we want 5 variations of expansion/repetition to each side (and both), we’ll use the numbers from 2 to 13.

So, we have 1 (our base glyph), 2, 3, 5, 8 and 13. The variations look something like this:

Then, as you saw in the image that opens this section, the same happens to the other side of the glyph and then to both sides. And then we make the “expanded” variations, using the repetition as the base. We’ll talk about that in a tick, in §3.

So, with 5 variations to each side, as well as 5 for both, in two sets (“expanded” and “repetition”) we have 30 stylistic sets, apart from the default glyph. That means 31 variation per letter. *heavy breathing*

2. The Base Glyphs

I have only two characters drawn, at this stage: E and F. And their 30 variations.

Now I’m more concerned with prototyping it, or better, to get the tech stuff sorted out before the drawing process; that’s why you’re seeing the same letters over and over again.

As this series go through, expect the tech geekness to decrease (although the next post or two will be about OpenType programming and maybe some Python macro stuff) and the drawing aspects to be mentioned more and more.

But as formal characteristics, the E can tell a lot, in our case. It can tell us quite nicely how the serifs will work, as well as how these elements work with the expansion/repetition. Of course, I’m still in the dark about the curved and diagonal shapes (although they’re playing cheerfully in my head, but that doesn’t mean it will play out properly once drawn).

I’m hoping to draw some very classic, rational and somewhat bland capitals. I want the magic to occur with the variations, not with the base forms.

3. Expanding Processes

After we have the base glyph, the expansion is pretty simple.

Each glyph is divided in two components: one for the left repetition, another one for the right one. Have a look:

I’m sure you can tell where this is going now: the components are propagated, on top of the base shape, to left, right or both sides, and so we get the “repetition” styles:

For the “expanded” set, we take the corresponded “repetition” glyph and simply delete what’s not needed. Here’s an animation of the process:

Et voilá!

4. The Math Of Going Overboard

As I’ve mentioned in the previous article, this font will be Latin-only. So, how many glyphs will it have?

I could go for a basic Type 1 Western/Roman character map (256 glyphs), but that would leave some languages aside. So, after the usual checking of language support tables, I’ve decided to go for the OpenType Latin Pro encoding (433 glyphs). If you think, as I do, that this is an OK character table, let’s make some further calculations.

Let’s consider a basic character map (Type 1 Western/Roman): 256 glyphs. As we saw on §2, we have something like 30 stylistic sets. Added with the default glyph, we have 31 variations of the same letter. How many glyphs are necessary for this? Here you go:

256 × 31 = 7.936

7936 glyphs. Ouch. And what about the OpenType Latin Pro?

433 × 31 = 13.423

Holy s***. Well, this might take a while.

But giving it a second thought, this font is all-caps, and that means that half of the alphabet is a duplicate. So, instead of 433 glyphs to draw, we have 310:

310 × 31 = 9.610

OK, this looks more manageable. *sighs*

5. Wrapping Up

This is all for today! I hope you’ve enjoyed the article!

If you’re a newcomer, be sure to read the previous post of this series an, while we’re at it, check the rest of the blog for some more juice! Oh, and don’t forget to subscribe at the bottom of this page, as well as to share it, if you think it’s valuable!

Thanks for your attention! Cheers!

Making a Font: Maximal – Part I

Part I | Part II | Part III

0. Introduction

Today, while I was waking up, I came up with an idea on how to do something that I’ve been wanting to do for a while. But before I tell you what the idea was, let me contextualize you.

I’ve been wanting to cover, log or to make a some sort of journal of the development of a typeface, to share with you guys. Instead of a “that’s how you make this”, I was wondering about a “that’s how I’m doing this”.

It sounds quite simple, right? Just writing small posts about what you’re doing as you go. Seems tangible, not very time consuming and interesting.

And when I say for a while, I mean for months. So why haven’t I’ve done it yet? Well, there’s a lot of factors to the mix, so bare with me:

1. I’ve been working in huge projects. If I want to write about something that won’t bore you to death, super families is a no-go. And to talk to you about custom client work would be impossible until released, separating us (me and you) from interacting while something is being made.
2. It has to be simple enough. For comprehension sake (and, again, to fight reader’s boredom), the project has to be simple enough. The main goal here is to let you learn something and let us happily discuss it, so I don’t want to push you away with hyper-complexity.
3. It has to be complex enough. Am I paying attention to what I just wrote? The answer is yes. The web is flooded with articles on how to do typefaces, so I have to throw something worthwhile to the mix. Also, some tech-geekness can’t hurt.
4. It has to be relatively fast to produce. Because type design deals with a monstrous amount of repetition, so I don’t want to ask you to dedicate yourself to pay attention to the same thing, over and over again. And those huge projects need my attention too. *wink*

So, points 1 and 2 have been the major setbacks, which leads us to:

1. So, When I Woke Up…

I love those moments when we’ve been thinking about something in a long time and then, suddenly, it all makes sense. And our subconscious is kind enough to provide pictures along with the solution.

So, I jumped out of bed and doodled in a piece of paper, before I did anything else (and yes, even before I went to the bathroom). Oh, and with my glasses off.

I wanted to get the idea down before I gave it a chance to fade away. And, while I was having breakfast, I decided to do today’s Typecooking image with this idea, so I could test it out. The result is what you can see above.

The result is far from perfect (and it’s not supposed to, as I explained in the previous article), but it did motivate me to get further with this.

2. Concept

There are three (at least that I can think of right now) main influences to this typeface:

• Ondrej Jób’s Woodkit. I love how this one comes together, as a type system: Jób was brilliant in how he used disparity and historical references to make this typeface work;
• DSType’s Diversa and LettError’s Beowolf. I’ve been wanting to do OpenType pseudo-random glyph substitution for a while, and these two are brilliant examples on how to achieve this.

Worthy of mentioning, I also had the pleasure to see some unreleased work from the super-talented calligrapher Hugo Moura (Facebook, Behance) that also played a part on getting to this idea. Since I can’t provide a hyperlink, check his work for some other stuff.

Back on track: the idea is to make a typeface where it’s glyphs grow unevenly in the cartesian x axis, either by stretching or by element repetition, as shown above. And, as the cherry-on-top, the glyphs will randomly change, as you type! Bam!

3. Developing A System

It’s easy to go crazy with this. Not that one shouldn’t, but we surely need a roadmap.

Although a lot can change during the production, I find that the clearer the notion of what we’re doing, the better, since we don’t want to bump into a I’ll have to redo this all over again crisis. I had my fare share of them (and I’m glad I did) and I also don’t want to keep you waiting for a long time.

So let’s enumerate decisions through a question and answer scheme:

• Intended usage? Display. Again, we want this to be fast. Also, this kind of trippy-ness is not very text friendly.
• Gauges/Optical Sizes? 1. For now, since there’s not much of a need for gauges in display sizes.
• Weights? Single. Besides, the distortion here already acts as weight.
• Construction? Capitals. Although slightly weird, I want it to be fairly legible/readable, and lowercase letters would suffer a whole lot more that capitals.
• Where to grow? Sides, for now. Although I haven’t ruled out a middle expansion yet. But I do have the feeling that it isn’t as easy (read fast) as it might seem, specially in vertically symmetric shapes. Again, for now, expansion of the side stems, one at a time.
• Style? Didot / Bodoni. Vertical stress (or 0º axis) seems perfect for this kind of distortion and the serifs add elements to keep things more interesting.
• Stylistic Sets? Indeed / I’ll have to test it out. This typeface will rely heavily on stylistic sets, at least the one with the glyph substitution. The question how many?, however, will only be solved in the prototyping stage.
• Language Support? Latin. Greek and Cyrillic capitals’ construction would welcome this sort of distortion but, for time constraints, let’s stick to Latin.

4. Imagining Processes And Tools

What strikes me as the most obvious way to do this is to start by drawing the unadultered shapes, i.e., the classic capital forms. Since the stylistic variations are distortions of these forms, we need them first to distort, otherwise there is only void. And yes, I’m stating the obvious, again; but bare with me, this will make sense.

After these initial forms, I’ll step to the “repetition” set. Although the “expanded” set is actually easier to produce (heck, I could even just draw two of them and interpolate the rest), the “repetition” set has more constraints when it comes to expansion.

What I mean is that, in the “repetition” set, we can only iterate in specific steps: one bar, two bars, three bars and so on. Here’s an image to ilustrate the idea:

Once these are done, I’ll move on to the “expanded” set. And if I use the “repetition” set as a base, I can simply delete stuff or add stuff to get the effect I need. But the main reason is that I would maintain a width consistency between the two sets.

Although this coherence might seem like something odd in a typeface as crazy as this one, I still want all the sets to speak to each other in a similar language, so they should have common characteristics throughout.

Here’s a thing that I might have mislead you to a erroneous interpretation: when I say that I’ll go through these steps, I mean that I’ll go through them glyph by glyph, not character set per character set. Doing it the latter way would be very dumb of me, since I would be postponing testing and prototyping to later stages of development, what could lead to having to through a lot of work through the window.

So, I like to deal with problems early on. There, I said it.

4.1 Metrics & Kerning

This should be as complicated as if two one set, since the left and right sidebearings, as well as it’s outward shape, doesn’t change. Class kerning, on this one, is a way to go: and the number of stylistic variations of one letter is irrelevant, here.

4.2 Macros

Nothing fancy, here. In fact, right now, I think that I need only one that I already use: a rounding corner script that I modded from this one from Betatype. It’s not flawless, specially with curves, but it’s awesome: it can spare you from some 8 steps and you can tweak the curve tension programatically.

4.3 Encoding

This one will be a tough baby. The glyph map is going to grow lightning fast and it might be wise to keep things under control. Maybe this is the reason I need to update my Font Encoder tool (if any of you wants to help me out with this tool, please let me know!).

5. Wrapping Up

At this point, I believe that we have enough to get this started. And that’s material for our next article!

Thanks for your time and attention, and I hope this article has been insightful for you!

See you in the next article!

Typecooking: Why I Started Doing Daily Exercises

Edit: Since the release of this article, a couple of things changed: the project is now called Typerobics and it has a dedicated microsite!

If you’ve been paying attention to my Facebook or Twitter feeds (or even Behance, but not as much up-to-date), you’ve certainly noticed that I’ve been posting a custom lettered word (almost) daily.

And people have been asking why I started doing so, and this article is about just that.

0. Introduction

OK, first things first: before I tell you why, let me tell you how I ended up doing it.

This is a shameless copy of an idea. Not that it’s something new, since daily exercises are as old as art. But to be clear, Oscar Guerrero Cañizares, the super talented man behind Sumotype Foundry (profile here) has been doing it for a long time; and I’ve been checking his stuff for an equivalent while.

So, if you’re expect an incredibly interesting story, worthy of a novel, here you go: I asked him if I could copy the idea and he said yes.

This introductory story serves two purposes: first of all, check his work, since he’s a skilled type designer and a very nice guy, out of our interactions. Second, Oscar, thank you!

People have also been asking how to I pick the words and how do I get a briefing:

1. Word picking: I use this random word generator, and sometimes, if I get stuck, I cheat with this Scrabble solver. Since I try to keep every exercise down from 40 minutes (unless I’m trying out a style that I’m not comfortable with), so I end up cheating. There you go: I’m human.
2. Briefing: This wildly varies, but I can reduce this to two paths: either I use TypeCooker to randomly generate a briefing (hence the name) or I draw whatever I want to.

With this cleared out, let’s onto the whys, meaning, the reason of this article.

1. Improving Fast vs. Font Development Takes An Awful Long Time

For me, this is the main reason. Font developing is so time consuming (some times it takes years to develop a family [I’ve lost count of how many times I redesigned something, just to get it right]), that it makes the process of exploring letterforms incredibly slow. Sure, you have to make a lot of fonts to tackle and learn about font tech issues, but the drawing process (technically speaking) isn’t that complex at all: Bézier curves, metrics and kerning.

Understanding form and becoming dexterous with it, however, it’s a whole different league; and we only improve that by constantly drawing, specially with variety.

Font developing may stall you from improving your formal skills, since you get to focus on the same thing for ages. In these exercises it’s just a word, not a gazillion glyphs across a myriad of axis, and you’re adapting your brain to formal and spacing skills in a variety of different shapes.

And, when you go back to font development, you get blazing fast at the drawing part (which is most of it, really), since you’ve solved some routine problems while practising, as well as improved your drawing technique.

2. Developing The Inner Do-It-All

This comes in the sequence of the previous section. As type designer or letterer, you want to tame as many styles as you can: you never know what people will ask you, right? Besides, how amazing would it be to sit down and confidently draw anything that comes to mind? Well, that comes with practice.

I try to challenge myself in these exercises. Whether with a style that I’m pretty bad at or by using a stop-watch, for example.

In Portugal, we have an expression for this: derusting the joints. If you’re not used to use your legs, the get rusted. So when you start using them again, it’s hard; but, in time and perseverance, it gets easier and easier – by moving, you scrap the rust out of your joints. Metaphorically, you only develop a skill by doing it over and over again, but you need that initial push before it gets easy.

3. Cheat, cheat, cheat

Oh, the pleasure of cheating! Lazy people, rejoice!

Joking aside, cheating is actually very useful. While developing a font family, the perfectionism light is on all the time. And this puts you (well, at least me) in a mental state where you’re over-concerned about… everything. Apart from taking some of the pleasure away, this hyper-focus refrains you from thinking out of the box, and so, from actually finding a simpler solution to the problem.

And the repetition involved in a huge amount of glyphs contributes to this.

4. Sharing Dumbness Is A Good Way To Get Schooled

Of course, these quick drawings have flaws. And when you post what you’ve done, people will pinpoint those flaws. Scary? Nope. Great? You bet.

By sharing with others, people will guide you on where to look and, with luck, what to do. I like to think that whatever I’m having a problem with, someone has already solved it; so sharing and letting people see what you do, even if it’s just an exercise, you’re actually putting yourself available to learn and improve, by the help of others.

As you saw above (and if you checked the Youtube channel) I also did some process videos (more will come, keep an eye out!). Aside from the compliments (these are great, don’t get me wrong), the constructive critiques are actually the best part, even if people think that you’re being dumb.

Well, if they think so, they’re probably right. But this can be a good thing, since a lot of people who think you’re dumb try to prove that you’re being dumb, which means that they’ll explain a easier way to do the same thing.

5. The Survival Of The Fittest Approach

Everyday, I get a started font.

One of the most frequent questions about my work is how I get ideas for typefaces. Well, I start a lot of them and, eventually, I end up wanting to develop one of the doodles/sketches into a full family.

Let’s say that 95% (or more) of what I’ve started will never end up as a ready-to-ship typeface. At the same time, I’ll never end up without something to pursue. And if the desire to finish stuff is the source of longevity, man, I’m immortal.

6. It Builds Your Portfolio, The Fast Way

This one is a no-brainer. In a week, you get 5 to 7 pieces of work to show. In a month, 20 to 30 (or 31. Or 28. Damn you, February!). In a year, 260 to 365. Do I need to say more?

7. It Builds Your Audience

The algorithm that sticks Facebook pages’ posts onto subscribers walls is terrible. Well, it’s awesome for Facebook, since I imagine that it’s a splendid source of revenue, but for someone who wants to see his own stuff seen by others, it’s terrible. Unless you pay for exposure, most (and with most I mean 99% of the people) of the people will only see it if they visit your page.

Since I started doing this thing, there are people of consistently come every day to check it out. And don’t get me wrong: they’re not friends of mine on Facebook.

And these people who come everyday (or very often) are your biggest asset in word-of-mouth. Heck, they’re becoming experts about what you do! So, who better to talk about your work?

By the way: guys, you spoil me everyday, I’m so grateful for such dedication, you guys are my motivators! Thank you, from the heart!

Soppiness aside, giving people something they value on a regular basis is the core of building a following. And having a following that respects what you do does several things:

• Keeps you motivated: because you know people expect something from you, while positively reinforcing you with their attention;
• Provide feedback: which, as we discussed in §4, can be a way to learn and develop skills;
• Validates you in the market: a prospecting client can easily find if you have a following. So, having the support of your peers is even better, since other people are actually telling that you know what you’re doing.

8. Prospecting Clients Have A Better Idea Of Your Skills

Simply because you have more to show, more recognition from your peers, in a wide variety of styles and, due to practise, better quality. What client doesn’t want this?

This can even work as a Pantone chart for letterists and type designers, but instead of colors, you get styles. And, the best part, is that you don’t even have to make mockups so your client knows what you’re talking about: it’s already done.

Prospecting clients have an immediate array of styles available to pick from, even before he decides to say a word to you. Win-win.

9. Wrapping Up

As you might have noticed, I’ve became a huge advocate of daily exercises. And although I wrote this through the lens of my own experience, these reasons and practises are extensible to other areas beyond type design and/or lettering.

I hope that you had a good time reading this and, if so, feel free to share the articles in the buttons below!

See you next article!