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 II
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!