How to Design and Construct a Functional Cursive Font

Final product image
What You'll Be Creating

Cursive type was once an oxymoron, but modern OpenType technology now lets us create true cursive fonts with letterforms that behave according to their context, just like true cursive lettering, to some degree. 
In this tutorial you will learn how to create a cursive design, translate it into valid bezier outlines and clean it up, package it into a font, and code the OpenType rules that program its cursive behavior.
This may seem like a strange question to ask, but more and more today designers overuse fonts. The word “font” literally means “cast source”, referring to the metal blocks that once made up a typeface. These blocks were made of incredibly hard metal, designed to survive hundreds of thousands of presses, or later on, to serve as molds repeatedly casting copies of its letters into softer metal slugs for letterpress printing.
With this there is an implication that fonts are meant for heavy, repetitive use. Type designers sink a great deal of work into a font to ensure that it functions as well as possible in any given setting. 
Thus, if you only need one decorative word, it does not make sense to design (or nowadays buy) an entire font. You are probably better off hand-lettering your word or phrase and importing it into your design. But if, perhaps, you need multiple different headings, or want to set a particularly long passage in that typeface, or want a design that can otherwise print whatever the heck you want it to, then a font is the way to go.
Type designs are often the result of happy accidents. Often I might casually letter something on paper that looks really good, and that will turn into inspiration for an entire typeface. For example, here were some headings I wrote for some physics/stat homework that I thought might make a nice typeface.

case closed

Word of advice: if you are trying to letter a sample, it’s often helpful to letter on grid paper so you can keep your letters—and scan crops—nice and straight.


These were written with a broad-nibbed calligraphy pen. You can buy some very inexpensive calligraphic fountain pens for less than $10 from manufacturers like Sheaffer.
You will have to scan them into images in order to vectorize the designs. If you don’t have a scanner (like me), you can simply take a picture from an orthogonal angle and use that. Both of the above scans were made with an iPhone camera. The image quality does not have to be great—you only need concern yourself with avoiding geometric distortion.
To create the font itself, you will need an font editing program. Several horrendously expensive options exist, but one great app, FontForge, is free and open source. We will be using FontForge in this tutorial. Make sure you set it to use only integer coordinates (File > Preferences > Editing > SnapToInt).
The first thing we have to do is import the scan into the FontForge drawing area. Do this by clicking into a glyph edit window, and going to File > Import.

Importing background image

Then, making sure you are in the Background layer, use the move and scale tools to position and size the reference image. For demonstration purposes, I will start with the letter ‘r’ in this sample, so center the ‘r’ in the middle of the glyph frame, right on the baseline.

positioning background image

We start by drawing the junction where the letter’s instroke begins.

drawing junction

Then we plant HV-curve points at all the minima and maxima of the letter’s contour. Using HV-curve points helps anchor into place important points along the letter contour, and also forestalls endless headaches with missing extrema points down the road. For now it’s fine if the path intersects itself.

tracing r contour
adding minimum point

Then copy the instroke points and shift them straight horizontally over to form the outstroke points. It is very important that the y-coordinates of the two sets of points remain the same.

Drawing the outstroke

Then finish outlining the glyph.

outlining r

Adjust the b├ęzier handles of the curve points to better match the contour of the glyph.

Fitting contour to reference

You can see a filled preview of the glyph in the main Font view.

r preview

Now we can tackle the next glyph, in this case, an ‘i’. Start by roping off the ‘r’ by setting its advance width on top of its outstroke edge.

setting advance width

We trace the glyph with the same techniques we used to do the ‘r’, taking care to make the junction between the ‘r’s outstroke and the ‘i’s instroke smooth.

tracing i

You will need to draw the outstroke of the ‘i’ at the correct height, so that it lines up the instrokes of all the other letters, so it can be enormously helpful to create Fontforge guidelines marking out the heights of the joins. Create guidelines by dragging down from the top ruler in the glyph window. Make sure the guidelines are rounded to integer coordinates.

setting guidelines

Then just draw the rest of the glyph.

drawing the i continued

This ‘i’ was drawn in the ‘r’ glyph space; we need to move it to its own glyph slot. Select the contour (and dot) by double clicking the paths, and cut and paste them into the ‘i’ glyph slot. Set the advance width by setting all sidebearings equal to 0 (Metrics > Set Both Bearings). Shift the background image if needed.

separating the r and i

You can still see the letters side by side by typing them in the wordlist box. This is extremely useful when making cursive fonts to make sure joins are smooth and line up.

wordlist feature

Here I am tracing the letter ‘l’ from the sample. It can be easier to copy an existing letter (in this case, a dotless ‘i’) and move the points to match the new letter, though everyone has their own way of hand tracing scans.

tracing the l

The HV-bounding-box-points system sometimes breaks down, as it can be impossible to trace certain curves using just HV points.

poorly fitted spline

In this case, it may be necessary to insert additional curve points along the spline.

extra curve points

Hand lettering is rarely perfect, but fonts do have to be (one of the disadvantages of using fonts). That means that in order to avoid problematic combinations, the letters, especially their instrokes and outstrokes, have to be somewhat standardized. In the case of the ‘l’, that means lowering the tail so that it sits on the baseline.

standardizing l

Here is a tracing of the letter ‘c’. As you can see, I made a few changes from the written version to make it play well with other letters. The Metrics Window can be very useful to test strings of letters.

Metrics Window preview

Your lettering sample will probably not contain every letter in the alphabet. In fact, you can sometimes get better results deriving letters from letters you’ve already drawn. For example, a script ‘a’ is very similar to a ‘ci’.

Making the a

I created the aforementioned ‘a’ just by squishing together a ‘c’ and an ‘i’ in the sample.

compressing a

Each letter you create will beget more letters. The ‘a’ for example gives rise to the ‘d’.

Making the d from the a

The ‘d’ is not the only letter that comes from ‘a’. You can also conceivably derive the ‘q’, ‘u’, ‘i’ (if you started with an ‘a’ instead of an ‘i’), ‘n’, ‘m’, ‘p’, ‘h’, and several more from ‘a’. There are countless ways you can derive an alphabet starting with a few sample letters. One way is shown below, starting with an ‘s’, ‘a’, ‘c’, ‘e’, ‘l’, ‘o’, and ‘r’.

One possible derivation tree

Here is an example of a font I made with all 26 letters.

26 letters

At this point, the font contains a full alphabet, but barely works as a font, since the letters only work together at the most basic level. The next part of this tutorial will focus on creating necessary alternates and programming the font to link up the letters in a pleasing cursive script.
Your letters ‘b’, ‘o’, ‘v’, and ‘w’ will almost certainly have outstrokes that terminate higher up than the other letters. Do your best to standardize these four letters just as you did with the normal letters.

high letters

If one of those four letters occurs, the letter after it will not link up because its instroke will be lower than the previous letter’s outstroke. We need to create a set of alternate glyphs with high instrokes that can link up with the ‘b’, ‘o’, ‘v’, and ‘w’. Do this by first adding 26 glyph slots to your font, in Encoding > Add Encoding Slots.

adding encoding slots

The new slots will enter as blanks, and you will need to sort them by going toElement > Other Info > Mass Glyph Rename.

naming glyphs

Give them a suffix of ‘high’, and map them to the alphabet block starting with ‘a’.

naming glyphs continued

This creates a block of slots named ‘a.high’, ‘b.high’, ‘c.high’, etc. Copy and paste a copy of the lowercase alphabet into this block.

filling slots

Give the ‘a.high’ glyph an instroke that would connect with the ‘b’, ‘o’, ‘v’, and ‘w’.

modified a glyph

This produces an appropriate alternate ‘a’ to be used after a ‘b’, ‘o’, ‘v’, or ‘w’, but it does nothing unless the font knows when to use it. To tell the font to substitute the ‘a.high’, we have to create a font lookup (Element > Font Info > Lookups > Add Lookup). Make it a Single Substitution lookup, but don’t set any features to it. Without a feature set, this lookup will serve as a list of paired glyphs for other lookups to use.

creating lookup

Then add a subtable to the lookup. Use the Default Using Suffix button to automatically populate the list with pairings based on the glyph names. If the button doesn’t work, save your font, close out Fontforge, reopen it, and try again.

creating a lookup subtable

Add another lookup, this one a Contextual Chaining Substitution lookup. Assign the calt feature to it, which “activates” the lookup in the font when it is used to type text.

creating calt table

Add a subtable, and in it, create two classes—one with ‘b’, ‘o’, ‘v’, ‘w’, and high forms, and the other with all other letters not in the first class. 
At the beginning of each list, insert ‘void’ or ‘void2’, because for some reason, Fontforge will only read starting from the second glyph in each class. For the matching rule, type the name of your first class, a pipe, the name of the second class, and the “highlinks” lookup in @<> form (you can use the Add Lookup menu).
What’s going on here? The Chaining Substitution lookup goes along through each letter you type and looks to see if it’s a member of Class 1 (‘b’ and friends). If it’s followed by a member of Class 2 (all other letters), it will look in the highlinkslookup, and replace that glyph with the associated alternate glyph listed inhighlinks. In this way, [b][a] becomes [b][a.high] when typed.

creating calt rules

Because classes have to be disjoint, this fails if you have more than one ‘b’ or company in a row. We account for this by creating a second subtable, with one class containing the ‘b’, ‘o’, ‘v’, ‘w’, and their high forms. The matching rule will have the same class twice, and the second has highlinks lookup applied. This subtable will look for ‘b’s followed by other ‘b’s (or other letters in that class) and perform the same substitutions.

creating backup calt rules

You should have two subtables in the calt lookup now.

two calt rules

Once you ‘OK’ out of the Font Information panel, you should be able to see the lookup in action in the Metrics Window.

testing the font

With the Metrics Window as a visual aid, convert the rest of the letters in the high block to having high instrokes.

designing high-instroke letters

The high joins should connect smoothly in the Metrics Window.

testing the font

At this point, the font has technically become a true cursive, since the font will automatically ligate any letter combination you type. But it still has some way to go to make it look better.
High up on the list of problems to smooth out is the link between x-height letters and ascending letters like ‘h’, ‘k’, and ‘t’. As you can see, the joins can look a little awkward.

lumpy joins

We have to fix this by creating another alternate set of letters, to be substituted in when they occur before an ascending letter. Name these like the high glyphs, except give them the suffix .steep.

alternate steep glyphs

Create another unfeatured lookup, with a subtable filled with pairings of regular and steep glyphs.

creating steep lookup and subtable

You will also need to create alternate versions of the ‘h’, ‘k’, and ‘t’ glyphs, to link up with the steep glyphs (having steep instrokes). It is probably easiest to add three glyph slots and name them h.insteepk.insteep, and t.insteep through theElement > Glyph Info window. You might also want to make another three copies of these glyphs for instances when more than one ‘h’ occurs in a row, though it seems this is currently nonfunctional.

steep h k and t

Of course, give them their own subtable.

h k and t subtable

Next, we go into the calt lookup and add a third subtable to it to set up our chaining rules. In one class, put the ‘h’, ‘k’, and ‘t’, and in the other put the rest of the alphabet, except for the ‘h’, ‘k’, and ‘t’, because classes must be disjoint; and the ‘b’, ‘o’, ‘v’, and ‘w’, which, as high letters, cannot have steep outstrokes. 
The second class (regular letters) goes first, and gets the steeplinks lookup applied to it. The first class gets the insteeplinks lookup applied to it. This means that if the font produces a combination like [a][h], the [a] will get replaced with [a.steep], as specified in the steeplinks subtable, and the [h] gets replaced with [h.insteep], according to the insteeplinks subtable. This produces the matched pair [a.steep][h.insteep].

steep link rules

Then we go in and actually modify the alternate glyphs to have steep links. It will be useful to create a third set of guidelines here. You can skip the ‘h’, ‘k’, and ‘t’, and the ‘b’, ‘o’, ‘v’, and ‘w’, since they can’t provide steep links under our current programming.

designing steep glyphs

As before, the Metrics Window helps you see how the font functions, and helps you design smooth links.

designing steep link glyphs continued

This should produce smooth linkages in most cases. It will fail if there are multiple ascending letters in a row—in theory you can create a fourth subtable in calt to substitute substituted ascending letters themselves, although for whatever reason this doesn’t work. The font will fall back to the old, less smooth, but still connected linkage. 
It will also fail in combinations like ‘bat’, with a high letter combined with a steep letter—again, in theory, you can program a subtable that would replace high letters with alternates that are both high and steep, but again, in my experience this does not work. 
The best you can do, however, is to make sure the steep linkage subtable is listedbelow the high links subtables when listed in calt; this fallback mechanism makes sure that the first two subtables can perform their more important functions over the third should a conflict arise.

testing the font

One more important problem can be fixed—clashing pairs like ‘ti’ and ‘th’.

clashing ti and th

The easiest way to fix this is to create ligatures—custom replacements for these problematic letter pairs. I created six ligatures—a ‘ti’ ligature and a ‘th’ ligature, plus high and steep variants (remember to add them to the lookup lists).


Ligatures need to be programmed into a font with a Ligature Substitution lookup, which you should add to your font’s lookup list. Flag it dlig (discretionary ligature). Since calt is more important than the dlig lookup, make sure calt is listed first in the lookup list to give it priority if there’s a conflict.

ligature lookup

Ligature substitution is simpler than contextual substitution—you just create a subtable within it to enumerate the ligatures and the letter pairs they replace. Because dlig takes effect after calt has done its thing, the source glyphs should be the ones substituted by calt.

ligature rules

You should be able to see the ligatures in action in the Metrics Window.

testing ligatures

This covers the basics of how to create a cursive font. A complete font will contain a great deal many other glyphs, including accents, symbols, capitals, and others. Some of these glyphs will need to be integrated into the link programming by adding their names to the various lookup subtables.

glyph table

A word of warning for when you go to export your font as an actual font file (.ttf, .otf) through File > Generate Fonts. Little of the programming we added to the font will be saved in the exported font file unless you check the OpenType box in theOptions window. There are a few other housekeeping things you should run before exporting your typeface that are standard in digital type:
  1. Remove all overlaps (select all glyphs with Control-AElement > Overlap > Remove Overlap).
  2. Round all coordinates to integers (select all glyphs, Element > Round > To Int).
  3. Make outer contours run clockwise (select all glyphs, Element > Correct Direction).

saving a font

You now know how to design truly cursive type, type that simply works when you use it in an app. Such a font is not always necessary—hand lettering mustn’t be forgotten! But it is certainly a useful and fun thing to have around, and the possibilities with OpenType programming are endless. Happy font-making!

using the font in Inkscape

The font used as an example in the second half of this tutorial is In Screaming Color, a cursive font I designed which can be found on


Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation.


Copyright @ 2013 KrobKnea.

Designed by Next Learn | My partner