On Logotype Calibration

0. Introduction

So, yeah, I’m a type designer. And there are numerous situations where I end up stating that “I make fonts”, so that people can have an idea about what I do for a living.

But drawing letters and packing them into working fonts is just a slice of it: I very often find myself fixing other peoples designs. And while it might seem obvious that I would be fixing other people’s typefaces (it has happened on ocasion, though, but when other type designers ask me to help them it gets closer to a mentorship than me doing the designing work), I end up doing logotype calibrations.

1. Logotype Calibration?

Isn’t it just redesign?

“Just”. As if redesigning isn’t a lot of work. But then again, what is logotype calibration, anyway?

Imagine this situation: you’re working in a branding project and, as such, you end up with a logotype. But something’s off — the form is wonky, it doesn’t work with the typefaces you use, it doesn’t survive small sizes and so on — this is where I usually come in.

If you want to check out the process, here’s a video where I go through most of the process of calibrating a logotype (size-specific calibrations were discarded here):

Note: Thanks to Both Bou for agreeing on letting me use his work for the video!

2. When Do I Need My Logotype Calibrated?

Always.

— Yeah, alright, Fábio, nice self-promotion move. [sarcasm]
— Thanks. [sarcasm]

But seriously, always. Or better, there’s only one situation when you don’t need your logotype calibrated: when you don’t have one.

And this doesn’t mean you need to hire someone to do that gig for you: with practise, knowledge and time, anyone can make an impeccable job.

Still, let’s suppose that you’re hiring someone to do that for you. When should you call them on board? There are two optimal situations that makes this smooth sailing:

1. Your logo is done, but could be better and you don’t know how nor why;
2. You need to fine-tune it to several applications (sizes, media and such).

3. Not My Logo

I’m a strong believer that, in this type of gig, I have to respect the designer/studio’s work and take it as not being my own. Any alteration has to be done within reason and not by whim:

• I’m looking at the visually applied results of a brand strategy, not at the brand strategy itself;
• The designer/studio has it own pipeline and process and I shouldn’t interfere with that (a small detail change can hijack and stall the whole branding project);
• It’s a calibration job, not a logotype design job.

Although I take some liberties, the need to respect what was given to me is always in the back of my mind. I don’t want to be creative about it, someone already has done that.

The thing is that someone is trusting me their months-long work to make it better. Someone has put a lot of care into this, probably has time and budget constraints and this is, most likely, a tiny (but very central) fragment of a much larger project.

4. Fine-tunning Form

Form is the singlemost important element in Design.

We need to adapt forms to whatever use and perceptual situation we decide to. So, though it seems like I’m stating the obvious, the whole process of calibration is form correction and/or optimization.

Since examples work great, here’s a mini case study: the Swedish studio Identity Works! hired me to correct a logotype for Hotel At Six, in Stockholm — which led to a custom typeface, but that’s a story for some other time —, where the first step was to correct the form and composition in general, fixing curve smoothness, intersections, spacing, stroke width and some other minor details. Have a look:

As you can see from the image above, they sent me a pretty well developed logotype that pretty close to what it should be.

Still, there was a back-and-forth discussion with the project’s Art Director (props to Nuno Coelho, he was always so nice and dilligent), testing versions of small details, a lot of time spent looking through a magnifying lens and a completely non-eco-friendly waste of paper.

So, the first step was to strive for a harmonious shape, with the concern of making it to visually flow smoothly. The most obvious detail is the t‘s bottom-most part, that was too shy in the original. But, for example, the S was too lumpy, out of being too geometric:

The greater amount of time in the development of this project was to get the inktraps just right. Gladly, this was a size-specific design and I could test the final media with satisfactory accuracy, so the stroke widths, intersections and curves were tweaked until I couldn’t make it better. The result was this assymetrical beauty:

Working with such thin lines, on the threshold of being ignored by the rasterizer, is a challenge. It’s, in fact, a crash-course on microtweaking, where 1/1000 nudges make a difference. Stroke modulation (yes, it has modulation) has to be perfect, since any difference in tension surfaces immediatly. Visual mass is so little that is unforgiving — which means this project was really fun for me.

5. Applications

In a branding strategy, a logotype can appear in a wide array of media and sizes, through a wide array of processes. Digital and print are vague terms that encapsulate formats, rasterizers, printing methods, papers, software, screens and so on. The list is endless.

To predeterminate as much of these as possible and to deliver context-specific solutions is key to making logotype calibrations. And there will always be variation, always.

Trying to achieve perfect consistency in applications is to aspire to make order out of chaos. Still, this is the goal.

And, in spite of all the technical constraints and real-world entropy — and with the notion that flawlessness is a myth —, any approximation is welcome.

A logotype is a set of graphic pieces, each one of them context-specific.

6. Conclusion

I hope you’ve enjoyed this article! If so, please share it with your folks!

You can also subscribe to the newsletter below, if you want to keep track with what is going on.

And if you’re wondering about talking to me about it, you can always say hi!

Until next time!

The Art Of Eyeballing – Part V: Stroke (Modulation: Introduction)

Part I: Introduction | Part II: Learning To See | Part III: Overshooting | Part IV: The Stroke (Optics)

0. Introduction

Welcome back!

I’ve been rewriting this article for ages now, so I’m glad to finally share this with you!

Today we’re going through a subject that it’s apparently simple, but the degree of complexity and abstraction can escalate pretty quickly, so I’ll be dividing this article in four sections: Introduction, Translation, Expansion and Scatter.

So this first part deals with the basic concepts that we need to understand this matter thoroughly; some structural, some a bit more abstract.

Scared? Great: it means that this will be easier than what you’re thinking. Let’s get this started!

1. Modulation

So, what the heck is modulation? Let me try to give one of my famously cryptic definitions:

In type, modulation is the register of a given tool on a given surface, through a given gesture, or the emulation of this.

Dude, you should write poetry. Yeah, I know.

In the human-friendly version, when you draw a letter with – let’s say – a ball-point pen, you make a certain gesture with your hand that, on a piece of paper, makes the pen release ink and produce a certain shape. Obvious stuff.

Now, let’s say you use a pointed brush instead of a pen. Depending on the pressure, angle and surface (imagine doing this on wood, for example), even if you make the exact same gesture, the shape produced will be different: there will be thicks and thins, rough edges and so on.

Or, if you’re drawing in a digital environment, you’ll be emulating this result.

So, modulation is the way a tool creates variation in a stroke, whether analogue (via calligraphy) or emulated (via lettering or type design). Or the variation of the stroke itself.

2. Gesture and Ductus

I guess I don’t have to explain what gesture is, since it’s not a matter of type-specific jargon. But when you do a gesture, it follows a path. To this path, we call it ductus.

The ductus is the skeleton of a letter. Although an abstraction, think of it as the path from where the stroke expands, or as the path of a writing tool.

Some definitions will tell you that you can get to the ductus by a reduction of the stroke towards the middle of the letter, but this is an imprecision: this might work in the case of translation (as you’ll see later on), but in most situations, especially when it comes to drawing glyphs by outlining them, the modulation around the ductus is assymetric.

3. Velocity, Pressure, Angle and Rotation

Especially in the translation model, angle is commonly treated as being fixed. This means that the writing tool (i.e. broad-nib pen) will be held at a certain angle and this won’t change while it propagates through the ductus. Still, every calligrapher knows that “rule” is just for comprehension sake; in fact, the angle can change a lot, even with a broad-nib pen.

How the angle of the tool changes in the gesture is vital to understand velocity and rotation: rotation is the variation of the tool’s angle, while velocity is the speed of which this rotation happens.

As you can see above, these factors have a huge impact on the shape of the stroke.

Finally, let’s consider pressure. Though we can almost ignore pressure in the case of translation and/or pushy people, it plays a big deal in the expansion and scatter models.

This item on our list will be explored further in the series (pretty much as any of the others), but here’s a simple explanation: the force exerted by the writing tool against the surface may influence the stroke. Take a pointed brush or nib, for example: as further pressure is applied, the stroke expands accordingly.

4.  Some considerations

Before we move on, there’s a couple of things that I’d like you to keep in mind.

First of all, if you’re still a bit confused, things will become more obvious in the next articles, where you’ll see these concepts in action. So pat yourself on the back and plow through.

Second, you don’t have to become and expert calligrapher in order to produce good lettering or type designs. In fact, you don’t have to do calligraphy at all, although it wouldn’t hurt. The goal here is to understand where letterforms come from and to know how writing tools work, so you can analyse form in a more knowledgeable way, developing your sensibility.

Third, purely emulating these concepts and processes won’t produce satisfactory end results. There’s a lot more to do on top of this, such as optical corrections, curve quality, formal consistency and such. Still, knowing this will, for sure, aid you in achieving better end results.

Fourth, read Gerrit Noordzij‘s The Stroke. Really, get it and read it: it’s a fascinating read.

5. Wrapping up

I hope you’ve enjoyed this article, since you’re at the doorstep of some very interesting stuff: we’re going to put these concepts to work in the next few articles, so subscribe below to get notified and see you in the next chapters!

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!

On Legibility – In Typography And Type Design

If you’re following me on Facebook, you probably know that I’ve recently asked for suggestions on what should I write about. Michał Jarociński suggested that I should do something about legibility, wayfinding and signage.

Curiously enough, not so long ago, I’ve started a thread on Typophile (and a discussion on Reddit’s Typography board) about the function/use of serifs, and, to my surprise, it escalated very quickly to a derby between serif and sans-serif type and which one was the most legible: but I’ll get back to you on this, in a bit.

But this led me to Kevin Larson, Microsoft’s researcher on reading, who was kind enough to exchange some e-mails with me, happily providing me some papers on the matter.

So, since you now know the path leading here, I hope provide you with some insightful knowledge about legibility — or what makes type more legible —, in order to help you improve your type designs (if you’re a type designer or letterer) or to help you refine your typeface selection process (if you’re a graphic designer).

And cabbages. Low in fat.

Without further ado, here’s the juice:

1. Letter, Word, Paragraph

First of all, it should be a no-brainer that, when we talk about rapid-letter recognition, there are multiple levels of the letters’ context (or, let’s say, relationship between other letters) that have an effect on how we recognize letter-forms.

So, as you might have wondered, a single letter should be recognized faster than one within a word. And its position in the word affects it’s recognition. And leading has an effect on this too.

Edit: Hrant Papazian has already provided some insights in my first article about Bézier Curves, and he did it again.

In spite of the previous statement, reading is a way more complex event than simple letter-by-letter construction. The bouma model suggests that we read through clusters of letters and only go through the letter-by-letter process in case of uncertainty.

I sympathize with this idea because it’s more economic, brain processing wise. To keep it simple, while reading, factors like grammar, word expectancy, word form and so on, are not to be excluded when we think about the reading experience.

*edit end* 

Keep also in mind that, by definition, legibility is not the same as readability, although, in practical terms, they are particular focus lenses of the same thing. We’ll talk primarily about legibility (the formal properties of a glyph that improve their instant recognition), but it would be a major fault not to mention readability issues (such as spacing, texture and so on).

Edit: This kind of research is still on its infancy, so keep in mind that these suggestions are a mix of what has been researched, empirical experience and my own opinions on the matter.

At the same time, the parallel-letterwise model that you can find in the third reference is still disputed, and very brightly, by Papazian, in Typo13.

*edit end* 

But how to improve this? Well, I’d like to talk about something else, first.

2. Familiarity

I have a memory of when I started tying my shoes, without an adult to help me out: I remember being the the kindergarten’s corridor, puzzled, trying to figure out how to do a neat bow and how the laces could make such form. It took me a while, I guess. I remember it as being a challenging task, since I was alone (yes, you could be alone in kindergarten, in the 80’s [well, at least here in Portugal]), and I was trying my best. I don’t even know if I’ve managed to do it properly, I just remember that I did something with it and that it filled me with proud.

Today, I don’t even remember when I tied my sneakers.

It’s part of our cognitive process to forget that we know how to do something: we end up just doing it without thinking. That’s why we can talk and write, for example, without a colossal effort to construct meaning, spelling, grammar and so on.

And the same applies to reading, i.e., recognizing letters. The more we are exposed to a certain typeface and the more we interact with it, the easier it is to rapidly recognize it.

I know this sounds like I’m stating the obvious, but consider the implications that this has on any study about legibility. Imagine gender differences on this matter. Cultural differences.

So, we should be very careful to engage extrapolations on legibility and readability, because this factor alone can sabotage our conclusions, so address this article (and others) with a critical mind.

Edit: Kevin Larson directed my attention to an issue regarding familiarity: even though we read best with typefaces we know best, we’ll do just fine at reading well-designed brand new typefaces. *edit end* 

But before you go and use Helvetica on everything from now on, please read along. *wink*

3. Spacing & Kerning

As was implied in §1, the amount of white space around to a letter influences it’s legibility, thus having an impact on readability.

But what effect? Well, if the tracking is too tight, letters will clutter and we might mistaken two or more character for another one; if too loose, we might have a hard time figuring out if a character is in a word or not.

Here, have a look:

As you can see in this example, in the first row, it wouldn’t be odd to mistaken the c and the l as being a d. And even by knowing that it’s the same word, probably you slowed down while reading the last line.

Spacing should be set to produce an even rhythm throughout the texture; altering this rhythm produces a reading experience similar to a ride in a car that has a choked engine, prone to hiccups.

3.1 Size-specific Spacing

Loosening the tracking slightly is not always a bad thing to do. In fact, in order to improve legibility and readability, it’s a good practice to open the tracking as you go down or/and if you’re working with very small resolutions.

Here’s a quick test to see how legibility survives deterioration: Gaussian Blur + Threshold.

As you can see in the image, the top-right word is spaced to loosely for such a big size; but its reduction (bottom-right) keeps a better quality of letter-recognition.

As for tight tracking in big sizes (you were wondering about it, weren’t you?), it’s sort of a different case. Is not as damaging, of course, since there’s more room for outlining the letter with the eyes, but it’s not actually an improvement; just more tolerable.

Still, since big type takes more room, it’s tempting to reduce the tracking: it’s OK, but don’t go wild with it; you’ll know some more tricks to go around this as you read along. And cabbages.

4. x-height And Vertical Proportions

It’s a widespread idea that a big x-height improves legibility/readability, but I have to say that this idea is an over-simplification. Not wrong, but a distortion by simplification, nonetheless.

Imagine that you’re designing a newspaper. Or a typeface family for a newspaper, same story. While it’s desirable to have a large x-height in the text typeface, it’s kind of irrelevant to do the same for the headline cut, right?

Now imagine that a newspaper contacts you to tweak their typeface. They want to keep the same char count, the same number of lines, but they feel that their text typeface is too small. Increasing the x-height seems logical.

But here’s the drill: the ascenders and the descenders, in proportion, as well as the caps, will shorten, considering that you want to keep your line-gap free from clutter. And you should be careful with this because…

4.1 Ascender And Descender Retraction Takes A Toll

… on cabbages. Er… I mean, on legibility and readability.

Consider the following animation:

As the x-height increases, the Futura-like d slowly starts to resemble a single-story lowercase a, increasing the probability of mixing those two.

And be aware that, since we scan words from their top, we leave the bottom of the words to a more peripheral part of our focus; this means that the descenders should be slightly longer than the ascenders.

Or, as Kevin Larson, via e-mail, has told me:

“We found in our studies of Sitka that a large x-height came with a trade-off; While the large size helped the neutral height letters, it hurt the ascending and descending letters.”

Note: let me remind you that this is not an absolute truth – in §6 we’ll cover another aspect that can compensate this retraction: it’s always a compromise of multiple factors. 

5. Counters

Open those counters!

This is actually one of the beefs I have with Helvetica, so you can imagine my surprise when Apple chose it as it’s UI font. But my jaw dropped when Apple stated the following:

In OS X Yosemite, fonts have been refined systemwide to be more legible and consistent across the Mac experience.

More legible? Seems like I missed a breakthrough research paper that contradicts centuries of type production. *long live sarcasm!*

But lets give the benefit of the doubt and round our quick Gaussian Blur + Threshold test, and pair Helvetica with another UI font: Microsoft’s Segoe UI (because it’s Apple’s main competitor and has a bigger counter aperture).

Here’s Helvetica:

And here’s Segoe UI:

If you’re still not convinced, step away from you computer and squint your eyes, shake your head, look away and back for a glimpse, decrease your monitor’s brightness, print it in a bad inkjet printer at a very small size and see which one performs better.

So, for low road mortality and low carbon-emission sake, keep Helvetica out of roadsigns. And cellphones – because no matter how stupid it is to text and drive, people will keep on doing it. Or get hit by a car while crossing a street without looking away from their cellphone, who knows.

Cabbages don’t cross the road staring at their cellphone.

6. Character Variation

This is one of the most important aspects of type design, regarding legibility.

While this is somewhat self-explanatory, here’s the rule of thumb:

The more distinct the glyphs are, the better.

It’s harder to tell twins apart, even though they have differences. So, as you can see in the images in §5, it’s easy to mistaken characters if they’re formally too similar.

Edit: Although obvious, this has an effect on the word level: glyph variation also increases variation in the word form, reducing ambiguity. *edit end*

But try not to build a Frankenfont: changing letterforms too radically, style-wise, creates confusion, slowing fast-recognition big time. And in the same idea, be sensitive about the amount of elements added to letterforms, since it might produce cluttering.

6.1 Serif versus Sans-serif

Remember, in the introduction, where I mentioned the discussions about serif’s functions on Typophile and Reddit that ended up in a derby between serif and sans-serif type? Well, now we have enough information to discuss this properly.

So, the answer to the question Which one is more readable, serif of sans-serif type?, the answer is No.

Following the motto there are no bad answers, only bad questions, this question is one of the bad ones. Serifs don’t automatically make type more legible (although they can help with character variation) and sans-serif simplicity is not always a plus.

It’s always a contextual matter and we have no empirical evidence that suggest the superiority of one of the styles.

So, why are sans-serifs almost universally used in signage and serifs in books? The answer is: available space and clichés.

Don’t get me wrong: clichés are a good thing, in this subject. If we’re aiming for legibility/readability, not clashing with people’s expectations is a good thing: we don’t want people crashing in the highway because a sign is set in Sabon, neither we want to read a romantic novel set in Comic Sans (although better than in Helvetica). *now I’m imagining the interwebs going rage on me!*

As for available space, serifs take more space than sans-serifs. Simple. And we want street signs to have big type on it, so we can read them from afar; in the same logic, in small type and longer lines of text, sans-serif create a kind of moiré effect in the texture, which is undesirable, since it requires effort.

Edit: And type size and word amount! I’m sorry for leaving this one out (props to Hrant Papazian, again)!

While we’re driving, it’s logical that a special focus on letter-by-letter recognition is paramount. Type is huge, and only one or two words are set per line, so it’s fast enough to decipher form and meaning.

But while reading a book, where there are a lot of words in a texture and type is set in a much shorter viewing arc, the bouma model fits best.

So serifs, in large chunks of text, have several advantages over sans: letters are “fused” together, the word shape has variety, white-space vs. rythym has diversity, and so on.

But I might be wrong.

*edit end* 

7. Width

This is another size-specific subject, under the condition of legibility improvement; I mean, if we set aside aesthetic considerations, some width adjustments can help with legibility.

Lets say that every time that you need to move your head (while looking at large type) or move it forward (in the case of tiny type), glyph width can help. With this said, we can conclude that small type is more welcoming of wide glyphs, while big type is more welcoming to condensed ones; although the case where the latter most benefits is when really, really large type is used and at a very short viewing arc.

And this leads us to…

8. Weight & Contrast

As you might have guessed by now, finer details don’t survive deterioration.

And if you think that this is a technological problem, such as pixel density or printer resolution, think again.

Imagine the following scenario: you have three different size circles and you want them to have the same stroke width, like this:

If I asked you to scale the circles to the same size, would they have the same stroke width? Of course not.

With a font, the exact opposite happens: if you have three circles with the same stroke width and scale them to different sizes, what happens?

If you think that I’m stating the obvious, man, I’m with you. But as simple as this might seem, it’s a good reminder of the kind of compensation necessary for different type sizes and a good starting point for size-specific designs.

In fact, I usually start a typeface by printing a bunch of circles and squares with different stroke widths at different point sizes, just to see how thin can it bear. And I do it again once I start adapting it to smaller and bigger sizes.

So, as a rule of thumb:

The smaller you get, the lesser should the contrast be.

But this doesn’t mean that you shouldn’t pay attention to the thicker parts of your strokes; in fact, you should thicken them even a bit further.

It’s like having a stroke around your design: comparing the thicks and thins, the thinner parts will thicken more in proportion than the thicks.

To illustrate this idea, remember the image that opened this section? Here’s how it looks if we scale the type to the same size:

9. Conclusion

I hope that you’ve enjoyed the article and the cabbages!

I’d like to thank Michał Jarociński, for the suggestion, Kevin Larson and Hrant Papazian for the helping hand and you, for your attention!

So, if you found this helpful, please be so kind share the article with your friends or go shopping for some fonts, so I can keep writing these!

And don’t forget to check the Further Reading and References section, below: there’s more awesome stuff there!

Cheers to you!

Further Reading and References

• The Aesthetics of Reading – Larson, Kevin & Picard, Rosalin (PDF)
• Size-specific Adjustments to Type Designs – Ahrens, Tim & Mugikura, Shoko
• The Science of Word Recognition – Larson, Kevin
• The Development of the Signage Typeface Wayfinding Sans Pro – Herrmann, Ralph

The Art Of Eyeballing – Part IV: The Stroke (Optics)

Index

Introduction | Learning To See | Overshooting | The Stroke: Optics

This is the first article of three, in our series, to talk about the stroke.

We briefly introduced the idea (in the previous article) that the stroke width has an effect on perception and, for this reason, should be adjusted. So, this article is just about that: optical adjustments to stroke.

May I state it right now: this is not rocket science and the more elaborated considerations about stroke (such as modulation, for example) will be covered in the next articles. For now, we want to approach a very simple case – a monoline construction – and try to achieve balance.

And without further ado (and because I’m starting to feel way to serious while writing this), let’s skip to the good part.

1. Horizontal vs. Vertical

Let’s get right to it: in the image above, which are the thickest strokes? Vertical or horizontal? Take your time. Horizontal, right?

If you thought “they’re equal”, you’re right. But do they seem equal? To me, they don’t. And to most people, they also don’t.

But for many years, I simply trusted the computer. And, as always, the computer was right, so who was I to judge mathematical perfection? Well, this is about perceptual balance, not the first. Again, trust your eyes.

And here’s a correction (with horizontal strokes being about 1% thinner than the vertical ones):

But why does this happen? In honesty, I don’t really know, although I have some theories about it:

1. We have two eyes, distributed horizontally, making our area of eyesight wider than taller; and this might add relevance to vertically distributed elements;
2. In type, we have millennia of broadnib and flat brush writing, usually with 30 to 40º angle from an horizontal position, making horizontal strokes wider than vertical ones. But again, this could be due to a perception/optical/neurological phenomena.

If you’re wondering about how this works in typefaces, have a look here:

2. Orthogonal vs. Diagonal

Consider the following example:

Again, all the 3 lines have exactly the same stroke width. We already talked about how to compensate the horizontal line, so let’s just do that:

If it wasn’t obvious in the first image, now it is: the diagonal line also looks heavier than the orthogonal ones.

So, for comprehension’s sake, let’s give the diagonal line the same stroke width has the (already compensated) horizontal line:

… which makes the diagonal line too thin.

Before we get into the solution, I’d like you to consider a couple of things:

• This example is not random, i.e., I’ve picked a 45º angle to the diagonal line for a reason that you’re about to find out;
• We can only apply this to monoline fonts, although this is just a starting point (the next articles will cover more cases and correspondent corrections).

So, if neither of the horizontal nor the vertical strokes’ width is applicable to the 45º diagonal (which, again, is half-way rotated between the orthogonal axis), what happens if we pick the exact in-between stroke width? Here you go:

Does it look alright? *wink*

And now, you might be asking about other angles. If we apply the same width stroke to any diagonal, we get this:

If you compare the first two lines, the second looks too thin; and if you compare the last two, the former looks too thick.

So here we can start to acknowledge that the thickness of a diagonal line should vary according to it’s angle, and that it’s a progression between the horizontal and vertical widths.

Here’s a linear progression of angles and widths:

2.1 Tackling Slants and Widths

If you’re anything like me, by now you’re doing some stressful mental schemes on how to calculate the exact width of a diagonal, depending on the horizontal and vertical strokes’ widths.

So, in order to save you some stressful times, here’s a quick and dirty way to do it:

1. Draw an ellipse that has the same width as the vertical stroke and the same height as the horizontal stroke;
2. Adjust the strokes to be tangents to this ellipse.

Two steps method. This is what I call workflow optimization! Here’s a visual representation of the method:

And, to implement a tradition, here are these principles applied to type:

3. Straight vs. Curve

And we’re coming closer to an end.

Let’s start with the following image, where all the strokes are exactly the same (and the O is already overshot):

And now, let’s make the corrections that we already know about (horizontal and vertical, in this case):

Same kind of question: do the straight and curved strokes feel equal? You might want to take a step back it see the images from afar.

The H seems to pop out more that the O. And, as I mentioned, the O is already overshot, so it’s not a case of overshooting. Or is it?

Well, curves seem thinner that straight lines for the same reason we have to overshoot them: a lot of white space is created and positive mass is decreased, so we have to compensate for that.

But the thing to retain here is that curves seem thinner than straight lines and the amount of compensation needed isn’t as extreme as the one we do in the verticle / horizontal cases, so it’s closer to an overshooting compensation.

Let’s correct our example:

4. How Much?

If you’ve noticed, I wasn’t blunt about how much to compensate; in fact, I only gave one example in §1.

I could provide rules-of-thumb that would be percentage ranges of compensation, but I feel that this is a trap.

First (and again), I advise you not to make calculations; providing you such rules (on how much to compensate) would oblige you to make these calculations and I want you to design as freely as you can.

So take what you’ve learned today and trust you’re eye. If it looks awkward, well, it’s awkward. Teach yourself to pay attention to the forms, counterforms and whitespace. Inspect the curve/line segments on by one and compare them to the whole form. And to the whole group of forms.

Even if we dabble in maths and geometry, here, keep in mind that these are means to an end, not the end itself.

I hope you’ve enjoyed this article, see you in the next one! Cheers!

References:

• The Stroke – Noordzij, Gerrit (Hyphen Press, 2005);
• Size-specific adjustments to type designs – Ahrens, Tim / Mugikura, Shoko (Just Another Foundry);
• Make Your Fonts Suck Less – Phinney, Thomas (video)

The Art of Eyeballing – Part III: Overshooting

Index

Introduction | Learning To See | Overshooting | The Stroke: Optics

You probably heard about overshooting, specially if you came from a visual arts background. If you haven’t, welcome! And if you have, well, it doesn’t hurt to refresh our knowledge and explore what we know in a more in-depth way.

1. Definition

So, what’s overshooting?

If you search the web for a definition (as I just did), you’ll end up reading about economics theory or mechanical engineering jargon. Is this somehow related or interesting to this topic? Not really, but amusing, nonetheless.

Overshooting, in visual arts, is the optical correction of forms in relation to other graphic elements, more specifically to their construction rectangle, in order to achieve perceptual balance. Still amusing, right?

Let’s check the About.com definition of overshooting:

The main parts of letters generally fall between the baseline and x-height or cap height. The overshoot is where rounded portions of a letter (such as O or n) extend slightly above or below those lines. This slight overshoot creates an optical illusion that the letters are the same relative size as non-rounded (flat) letters like L or H.

Apart from the casual humor, I wrote that almost unintelligible definition because this second one is incomplete:

1. It doesn’t contemplate shapes with straight lines that need optical compensation (A and V, for example);
2. Has no consideration for horizontal overshooting.

 1.1 A Matter Of Perceptual Mass

So, what is this all about?

Well, as we discussed on chapter 2, the way we perceive things around us isn’t accurate (for biological and cultural reasons), let alone mathematically perfect.

Using the classical example, consider this image:

Now, do the circle and triangle feel to you that they have the same weight has the squares? Truth is, they’re all the same height, they just have a different area, or more precisely, a different visual mass.

But then again, area and visual mass are not the same thing. If they had the same area, they would look like this:

2. Perception versus Geometry

Of course, there’s more to this. As we could see above (and discussed in the previous chapter), being mathematically precise doesn’t provide visual or perceptual balance.

So, lets approach the problems of the previous image and correct them.

2.1 Alignment

As you can  guess, all the elements are aligned to their center. But if we try to come um to a base and top line, we would get something like this:

And, if we’re trying to achieve a stable composition, this doesn’t seem to be working out very well, right?

Lets then take the square as our standard element and extend the lines from it. We’ll get something like this:

The most evident problem here is the triangle’s bottom. Oh, sorry, the bottom-most part. *blushes*

So, apart from the platonic discussion about the sexyness of triangles, our seems to be falling down from the baseline, for two reasons:

1. It creates a huge amount of mass below the baseline;
2. Since the triangle’s base (or bottom, now I can’t get this off my head!) is perfectly horizontal, it’s pretty much stable, as a form; hence, the need for compensation below it’s baseline is nonexistent.

OK, now lets align the triangle to the baseline:

The base (I’m avoiding the word bottom, now. Or maybe not.) just got better. But what about the top? Too much stuff protruding there, right? As we saw in the first image, reducing the square to align the square just doesn’t work. And neither aligning it just to the baseline.

Lets try to scale it down a bit, while keeping the bottom (there we go again) aligned to the square:

Ah!, relief!

Still, the circle seems odd. The reason for this is the same: too much mass protruding above and below. Scaling it a bit down, aligned to the square’s center, we’ll get this as result:

Success! And here’s the composition without the guidelines:

2.2 Whitespace

Apart from being a really cool (or incredibly lame) name for a classic rock type designer’s band, every time you affect a form, you affect the white space around it: there is a constant play between positive and negative form and achieving balance of form requires attention to both, as New Age as this can sound. Or Confucian.

So, if we consider the vertical extremes of a form for optical compensation, we should do the same the horizontal ones.

Usually, horizontal compensation is neglected when we talk about overshooting, because it’s a matter of metrics. But since we are talking about perceptual (or optic, although the latter is not a very precise term, as we could see in chapter 2) compensation and this is not exclusive to type design, but rather generalistic, visually speaking, we should talk about this.

Consider the following image:

The circle and the triangle are compensated according to §2.1 and equal space is maintained between each element. The reason why squares are paired is to have a reference of spacing, since we saw that the square has no need for optical compensation. Here’s an image with the spacing margins:

Due to the triangle and circle’s irregular form (or better, non-square form), a big amount of white space is created, making these seem separated further apart from the squares, in comparison to the space between a pair of squares.

Again, we’re not aiming for mathematical calculations of space, but visual balance. With this said, if we were to calculate the white space area and make it equal, the circle and the triangle would overlap its neighbour square.

Instead, we’ll reduce the side spacing in the same proportions as we did vertically:

And here’s the same composition, without the guides and spacing blocks:

2.3 Some considerations

1. I haven’t told you how much you should compensate, with the exception of the previous example. I did so because there isn’t an exact answer: we could talk about ranges, but these are form-dependent;
2. If we’re designing free-form elements, as most glyphs are, the notion of exact calculations seems like a complete waste of time. It’s easier to test and decide than to write a complex software just to make that kind of decision for you and, most likely, with an unappealing result;
3. The reason why I was able to tell you to compensate the same horizontally that was made vertically is because these forms are symmetrical horizontally, and, in the case of the circle, symmetrical in both axis. And to tell you the truth, the compensation in the triangle’s horizontal spacing is slightly bigger than vertically (meaning the spacing was further reduced), to keep a nice flowing rhythm.

4. Counter-forms

As stated in § 2.2, there’s an ever-going dialogue between positive and negative forms; and I say form instead of outline because we should also consider negative forms inside positive ones, because this also has an effect in optical compensation.

Here’s an example:

Here are some observations regarding the previous image:

• Proportionally, when we apply a stroke inside our forms, the amount of white space reduction, proportionally, is bigger in the circle than in the square;
• A thick stroke makes the circle look smaller than the square, for the reason above;
• A thin stroke goes above the top alignment, making the circle look bigger than before;
• The stroke has also an effect on horizontal spacing and should be compensated accordingly.

The conclusion here is that we should increase the amount of compensation as we increase the stroke, paying attention to balancing the counters. In fact, when we have counter forms, they overpower the form’s outline and their equilibrium becomes more significant than the solid form itself.

5. Conclusion

So here we covered the basics of overshooting, opening a door to the world of optical calibration.

Thanks for reading the article and I hope you’ve enjoyed it. If you believe that it can be useful to others, please share it!

See you in the next article!

References & Further Reading:

• Type Mechanics: 001 – Frere-Jones, Tobias

10 Tips On Kerning And Metrics

This is a brief collection of quick tips on kerning and metrics, as the title may have suggested, that I find valuable.

Although this is intended for Type Design, this article should be valuable for DTP software kerning or Logo Design. Or anything that has to do with letters.

And if you’re wondering what’s the font in the image above, here it is.

All set? Let’s go!

1. Proper Spacing Means Less Kerning

This should be a no-brainer. If your font looks good overall, you’ll have to kern less.

So, try to keep your metrics as consistent as you can, well overshot and only go for kerning when you feel that there’s no other way to space it better. I usually space the letters as I am drawing them, to see if I have a good flow and I might solve some spacing problems in the letter form itself.

2. Classes

Use kerning classes. There.

In case you are wondering why, it’s just way easier to grab a bunch of glyphs of the same group (for example a and all it’s diacritic marks), assigning them to the same kerning class and then kerning them than doing it pair-by-pair. Even if you have to deal with some collisions, it’s a lot less work.

3. Kern First, Ligatures Afterwards

As much as kerning is tedious and I love to push it to the end of the production, it’s not a bad idea to do the ligatures after you’ve already kerned at least the alphabet: in that way, you avoid having to correct bad spacing to your ligatures, saving you some time and some eyeballing doubts.

4. Mirroring

Mirror, mirror, mirror. Horizontal and vertically. At the same time and with just one axis mirrored.

The goal here is to step yourself away from text as more as you can, and trying to see “pure” forms. It lets you approach the design as an abstract composition, making it easier to balance your spacing.

And this is not just for kerning and spacing: it helps you to get a good flow in your design and it’s easier to perceive not-so-obvious design flaws.

Also, I’ve recently found that I can read fluently upside down or when the text is mirrored: it’s like having a super-power!

5. Straight Neighbours, Round Neighbours

Before going for text-string kerning (I use Just Another Foundy‘s Test Text Generator, by the way), I start doing kerning with straight and round neighbours (and/or a mix of both) in both sides of the pair I’m working on.

For example, if I’m kerning A/V, I’ll have something like HHAVHH OOAVOO HOHAVHOH. And I just noticed that the font I’m using here is not properly kerned. See? It works.

6. Pay Attention To The Space Width

This one is often neglected.

Most of the times, if you space your sidebearings right while your drawing, usually you don’t have to kern the space glyph at all. So, you have three options:

1. Set your space width and do your metrics accordingly;
2. Do your metrics and set the space width accordingly;
3. Ping-pong between the two.

In my opinion, go for option number 3.

Metrics and kerning deal with the space between letters – and that includes the space between words.

7. Blur your eyes

This one is related to §4, the goal is the same than in mirroring.

8. Keep Rhythm Consistent

While kerning, try to keep equal perceived space between the letters. Not mathematical.

All letterforms are different (I like to state the obvious), no there’s no equal solution to every single pair. Even if we think that we shouldn’t kern n/h, I believe that we should check it out anyways. In this example, the top right curve of the n can be creating too much white space, for instance. And it only takes a second.

9. Don’t Forget The Left Side, Jedi

One common thing to forget is to pair lowercase on the left with the uppercase on the right.

While this should be going without saying, when you’re kerning hundreds or thousands of pairs, you can easily forget this. Your end user might want to use your font to write something like YoU’rE sO fLuFfY and you’ve might have just lost a client for not having those pairs kerned. Or saved the world. Who knows!

Anyway, lowercase/uppercase pairs are not uncommon at all, specially in logo design. So keep this one in your to-do list.

10. Trust The Eye

Well, this is the most valuable advice on type and graphic design. It’s very usual to be insecure and trying to find some über-rational process, way or calculus to make you feel that your choices are the best, but hey: type is for the eye, not for the computer.

If what you see feels good, then it’s good. If it doesn’t, then it’s not. It’s that simple. You’ve looked at type your whole life, even before you could read, so just assume that your subconscious is a very well trained machine for eyeballing these things. And the more you try, the better you become at it.

And trust me about this: I’m a optimization geek. I spend a lot of time trying to perfect the way I do things (as you might have noticed while reading my article on Bézier curves) and the better it looks, the less I’m concerned with geometry or space rationalization.

11. Final Thoughts

I wrote this because kerning is one of the things type savvy people complain the most about, but I think it’s not that hard. And yes, after some hours doing it, I also complain about it.

But it doesn’t take as much as you’d might believe it does, time-wise or knowledge-wise.

I hope this has been valuable for you, somehow!

And feel free to drop me a word! Cheers!

Bézier Curves and Type Design: A Tutorial

[2026/09/14]: This article became the most popular I've ever written. Since it was written a long time ago, I decided to rework it: polishing the wording to facilitate comprehension, fixing dead links and typos, and adding interactivity. Still, it remains faithful to the original — a lot of people discussed it and helped me flesh it out into what it became, and I want it to continue reflecting that process. Enjoy!

Whenever I am asked to assess the quality of a typeface or logotype, or when someone asks me for help with their typefaces, one of the most common problems I find is bad Bézier curve design.

And every single time this happens, it’s not people’s fault. It is a fatalism of existence: if people knew better, they’d do better. Surprisingly, it seems that a lot of people have trouble wrapping their heads around this: students struggle with it, fellow lecturers despair.

And then there’s that heart-stabbing situation when someone drops by and says “Hey, I just finished this font, can you have a look and see if something’s missing?” and I feel obliged to say, with grief, “You have to redesign it all over: it’s poorly designed, Bézier-wise”.

So, in order to save some people from this hassle, read along.

1. Problems

First of all, we should understand that each piece of desktop publishing software is going to compile the font files in its own way. Moreover, each one of them is going to convert the curves through its unique algorithm, sometimes unleashing hell.

Flash IDE [now Adobe Animate], for example, is notorious for wrecking curves. It does so based on the size of your vector artwork in order to keep the file as small as possible. If fonts are not embedded, the same happens.

Some programs, like 3D applications, simply break the curve into several facets. So even if you are doing something in Illustrator to use in 3DS Max, for example, read on; it might save you some trouble.

2. Reasons

Usually, all of this revolves around how PostScript and TrueType deal with outlines: TrueType uses quadratic Bézier curves, and PostScript uses cubic Bézier curves.

I know, I know, geek stuff. Here’s the simple explanation:

• A quadratic Bézier curve (read TrueType) has 3 points: an insertion point, a control point, and an end point.
• A cubic Bézier curve (read PostScript) has four: an insertion point, an end point, and two control points [also referred to as handles].

And for the visual type of person, here’s an image:

So, if we were to draw a circle in both curve equations, they would be drawn the following way:

Let’s count the number of points needed for each circle:

• Quadratic: 8 anchor points + 8 control points = 16 points;
• Cubic: 4 anchor points + 8 control points = 12 points.

Counting points might seem unpractical and silly, but it can tell you a couple of things right away:

• The most obvious is about file size: fewer points, fewer point coordinates, mean a smaller file size. Cubic curves win in this matter;
• Two control points per node allow more freedom while drawing, since it gives more control on the curve itself. Quadratic curves force the user to add more anchor nodes¹ (since the addition of every angle per curve can’t be bigger than 180º), adding difficulty to the process of drawing a clean curve.

If this is so, it seems that cubic curves win over quadratic ones; so why aren’t quadratic curves obsolete?

3. Digging deeper

But how are Bézier curves calculated? Let’s start with quadratic curves.

3.1 Quadratic Curve rasterization

We have our three points: two anchors (in and out) and one control point. Let’s call the anchors A1 and A2, and call the control point C. Next, let’s connect A1 to C and C to A2 with straight lines, as shown below:

Now, we’ll add two points: one that travels from A1 to C and another that travels from C to A2, and they’ll take exactly the same time to make their trip. And for the sake of this exercise, we’ll also add a straight line that connects the two traveling points (shown in black, below):

Again, let’s add a new point, one that travels between the two black points, taking the same time to travel from one point to another (shown below in white). If we track its path while traveling, voilà, we have our quadratic curve rasterized:

OK, so now you know how a computer renders a Bézier curve:

• It’s not actually a curve, but several iterations of straight line segments, smaller than pixels, that create the illusion of a curve. It’s what a 3D application does while smoothing a mesh — it breaks it exponentially, until the mesh seems smooth, when, in truth, it is just a bunch of tiny, tiny planes.
• The same applies when you zoom in or out, or when your printer’s rasterizer prepares a document to print: it rasters the curve to the intended resolution.
• This is why older vector drawing applications would break fonts’ curves in bigger or smaller iterations, depending on the size that one would convert them to outlines — the raster algorithm would iterate depending on the size needed, because processing power and file size were limited;
• Still, applications have their own rasterization algorithms, and this is still needed. InDesign, for example, deals with huge amounts of text (meaning lots and lots of points and curves), so it provides different levels of rasterization resolution, so it doesn’t get sluggish. Sub-pixel rendering, on the other hand, might do three or four different rasterizations and combine them, or nudge one in different ways. Simply put, ClearType would kill your 386 machine.

3.2 Cubic Curve rasterization

So, what about cubic curves? Is the rasterization done the same way?

Well, yes, sort of. It just adds another level of our “traveling points”. Have a look:

See what they did there? Right, a moving quadratic curve inside a cubic one!² Here’s some deductions on cubic curve rasterization:

• We’ve noted that cubic curves reduce the file size by 1/8, but the demands on processing power triple.
• While a ceiling of 180º is possible with quadratic curves, we can go up to 360º with cubic ones.

3.3 Going back and forth

The addition of multi-order intermediate points can go down to infinity, and it’s possible to break cubic curves into quadratic with minimal loss in quality. The other way around, well… it gets tricky.

Quadratic curves are always conic sections, while Bézier curves that have more than one level are a result of curve funkiness, meaning, a collage of cone sections’ sections.

So if we were to write an algorithm to convert cubic curves to quadratic, we would have no problem: we would just check for cone sections that would fit on that curve.

But if we were to write one to convert quadratic to cubic, the best the program could do is an approximation of the original outline, usually keeping the anchor points it already had, but adding one more control point per anchor. So, file size wise, not a good idea; processing power wise, even worse.

Edit: As it was stated over at Hacker News by simias and jacobolus, and kindly explained by nanofortnight, the above statements are wrong — in fact, the truth is the very opposite.

If we were to convert a quadratic curve to cubic, it would be the exact same curve, as nanofortnight demonstrated. But, as jacobolus pointed out, due to the integer structure of font compiling, this conversion might not be exact.

And when we go to convert cubic curves to quadratic, it’s not as easy-peasy as I stated above. For further reading on this, check this out.

Is this a problem, then? Well, these conversion issues are the reason why DTP software and printers favour PostScript, i.e., cubic Bézier curves. If the drawing was provided in quadratic curves, the software could easily convert them to cubic; if it was already in cubic, it would simply keep it that way.

So, while designing type, you opt either for TrueType or PostScript. And, while this makes me favour PostScript, if you start with one, stick with it.

But why do type design applications offer cubic curves only or have them as default, as a drawing method? Well, as debated, conversion from TrueType to PostScript is optimal and the other way around is not. And the third reason comes next.

4. File Size

We already know that you can draw the same thing with cubic curves using fewer points, but there are also some other things that we can take into consideration, regarding file size.

4.1 Always work with integers

FontLab [Studio³], for example, doesn’t even let you use decimal coordinate data, and no sane developer will build a vector drawing application that would allow point data to infinity. Since we still need a worldwide network of computers just to find some more pi digits, no one gets to treat themselves to perfect circles.

But then again, if your eye can’t tell the difference and, in fact, you still have to cheat the circle to make it look like a circle (when you adjust forms optically), using decimal numbers on type design is just some sort of geek stubbornness.

And there’s the workflow issue: ask any professional type designer if they use Illustrator — or another vector drawing application that uses decimal numbers by default — and you’ll find that very few say yes; and even those who do still have to adjust their drawings in a font editor.

It’s way easier to nudge with the keyboard arrows than to use a text box to input integer values. On the other hand, a lot algorithms used for font handling in DTP software simply round the points to integers, so they can handle them with less storage and processing resources.

Edit: And, as Pomax kindly pointed out, the OpenType specs only allow for integer point coordinates anyway.

But the big issue here is file size: if you have a file with integers and 4 points, it will be smaller than a file with two decimal figures and 2 points. Make some thousands of points and the difference in file size balloons, as well as processing requirements.

5. Always work with cubic curves

Cubic curves win, for all the reasons mentioned above: easier to draw with [there are more reasons for this, keep reading], better conversion to quadratic than the other way around, smaller file size. You know the drill.

But it is also worthy of note that this is why cubic is the safe default when we start drawing fonts — conversion to quadratic is lossless, so your outlines are always reproducible by other tools and designers.

6. Keep anchor points at extrema – and handles straight

This is a big one. Most of the time, the most common problem I see is that the anchor points are haphazardly positioned, spread all over the place. This results in jagged lines, poor rasterization, bigger file sizes (who hasn’t tried to fix something by adding more, right?), increased difficulty in drawing, and the list goes on.

If you want to draw a smooth curve, having the anchor points at the horizontal and vertical extrema and keeping the handles vertical or horizontal is enough. It gives you better control over the curve path and less stuff to adjust: it keeps most of your curve segments under 90º and transitions predictable.

Edit: And, although implied above, is good to mention: do not invert the path direction with your handles (thanks to Pedro Amado for pointing that out). Here’s what I mean:

Keep in mind that we’re talking about what should be in your final output. Although I recommend keeping your placements tidy and as close as possible to what it should be, inverting the direction like in the image above can be a way to draft quickly⁴.

Edit: 7. Explicit Inflection Points

Hrant Papazian made me notice, on Twitter, that I’ve missed a point (pun intended!). The example above, on the right, lacks an explicit inflection point.

“What the hell is that?”, you may ask. Well, in an ideal scenario, all points should alternate between vertical and horizontal handle position. Why? Because we want to keep each curve segment without inflection points, in order to have an optimal conversion from cubic to quadratic.

“OK, lovely, but you haven’t explained what an inflection point is”. True. Here it is: the inflection point is where the curve changes direction. So, if you’re walking from left to right and start leaning to the left, the place where you start doing so is your path’s inflection point⁵. Simple.

So, in the example in §6, the curve changes paths between the two horizontal handles, creating an inflection point. How to avoid it? Well, make it explicit; i.e., add an anchor point in that location. This way, the curve is split into one-direction-only segments:

For more  information on inflection points, have a read here.

Edit: Also worthy of note, pay attention to how the handles retract at every step of the way. Even if you thought “Yeah, of course it does” — kudos to you, tap yourself in the back on my behalf — the bounding box for coordinate control also got smaller. This makes our life easier while editing: we get a better view to what we’re doing.

8. Final considerations

I know this was lengthy and somewhat technical, but I believe it’s important to know why instead of just how. Computers have limitations – and will always have – so it’s important to make the best of it; and for that, knowledge is key.

I hope you had as much fun reading this as I had making this article. Thanks for your time!

References:

• Bézier Curve, Wikipedia
• PostScript, TrueType and OpenType: Curves and Outlines
• So What’s the Big Deal with Horizontal & Vertical Bezier Handles Anyway?, The AGSC [Wayback Machine]
• Inflection Points of a Cubic Bézier, Caffeine Owl [Wayback Machine]
• Bezier Curves and Picasso, Jeremy Kun

1. Anchor node is a general term for insertion and end points of a curve segment. Since the curve always goes through these, they “anchor” the curve to it. ↩︎
2. This algorithm for drawing/splitting curves is de Casteljau’s algorithm. ↩︎
3. FontLab has supported floating point coordinates since version VI. But it still compiles to integers. Just a relic of how long ago this was written. ↩︎
4. Let me also state that whenever I do this, I add the extrema points right away: there’s not much control in drawing such a huge angle and inversion with just two points, especially when it comes to curve tension. ↩︎
5. I encourage you to go back to §3.2, where you have the interactive cubic curve animation. Drag points around so that you have a curve and countercurve and pay attention to the gray line — you can see exactly when the curve “flips” direction. ↩︎