New AFDKO Version Is Available!

The Adobe Type Team’s very own Read Roberts has been hard at work preparing a new version of AFDKO (Adobe Font Development Kit for OpenType), and posted the release earlier this month. It is Build 58732, dated September 4th, 2012, and is ready for public consumption. Be sure to read the detailed Release Notes for this new version. In particular, this release includes several important bug fixes for font developers who use AFDKO tools to build OpenType/TTF fonts, or fonts that include mark ‘GPOS’ lookups and/or the ‘GDEF’ table. In addition, the checkOutlines tool incorporates several important fixes for cases when it inadvertently reversed subpaths or removed the wrong subpath.

According to Read, this release marks the beginning of a period during which he hopes to make a number of additional bug fixes and enhancements to various AFDKO tools. If you are aware of any outstanding issues with any AFDKO tools, or have ideas to improve them, this is an excellent opportunity to let Read know, by posting comments to this article. The next release is likely to be within a few months.

In any case, if you are an avid user of AFDKO tools—or have considered using its powerful font-development tools in your production workflow—please be sure to download this latest release. It is useful to once again point out that our team uses these same tools on a daily basis, and are what I like to refer to as industrial-strength. And, as always, feedback is welcomed and encouraged.

Enjoy!

3 Responses

  1. Stefan Huber says:

    Finally! After 2 years of working with a manual patched MakeOTF.py a new release. I don’t know how it should have been possible to build ttf’s with the old version. Thanks to Read I already had a pre-release version. And despite http://blogs.adobe.com/typblography/2012/02/how-much-interest-in-afdko-tools-for-other-platforms.html its still in source. I hope Adobe will keep that FOSS strategy and move also AFDKO to GitHub. Git-Flow as a next step?

  2. Nathan says:

    I’m a novice type designer with an interest in pervasively-ligated script fonts in non-Latin alphabets (Quikscript, actually). I’m trying to replicate some of the methods used in OTFPOC and Pecita in my own font. Unfortunately, FontForge seems to support things that AFDKO doesn’t.

    In both Pecita and OTFPOC, the FontForge-generated UFOs look like:


    @connects_at_baseline_either_side_theoretically = [b c e g];
    @connects_at_baseline_just_on_the_left = [b.1x0 c.1x0 e.1x0 g.1x0];
    @connects_at_baseline_just_on_the_right = [b.0x1 c.0x1 e.0x1 g.0x1];
    @connects_at_baseline_on_both_sides = [b.1x1 c.1x1 e.1x1 g.1x1];

    # similarly for "at the x-height on both sides"

    # similarly for "at the baseline on the left side and at the x-height on the right"

    # similarly for "at the x-height on the left side and at the baseline on the right"

    # similarly for "only connects at the baseline on the right, if at all"

    lookup calt_pass_1 {
        sub @connects_at_baseline_either_side_theoretically'
            @connects_at_baseline_either_side_theoretically'
            by
            @connects_at_baseline_just_on_the_right
            @connects_at_baseline_just_on_the_left;
        # ...
    } calt_pass_1;

    lookup calt_pass_2 {
        sub @connects_at_baseline_just_on_the_right'
            @connects_at_baseline_just_on_the_left'
            by
            @connects_at_baseline_on_both_sides
            @connects_at_baseline_on_both_sides;
        # ...
    } calt_pass_2;

    feature calt {
    lookup calt_pass_1;
    lookup calt_pass_2;
    } calt;

    so if the input sequence is
    c     c     c     c
    it’ll get turned into
    c.0x1 c.1x0 c.0x1 c.1x0
    after calt_pass_1, and
    c.0x1 c.1x1 c.1x1 c.1x0
    after calt_pass_2 — or, in English, a string of four cs where the first one connects to the second one, the middle two connect to both the outer ones and each other, and the last one connects to the penultimate one, as on the OTFPOC page.

    However, AFDKO 2.5 doesn’t seem to support the sub a' b' by c d; syntax (which makes sense given its documentation). If makeotf supported this, it’d be extremely helpful — I haven’t yet found a way to do it, even if I’m generating the features file with a Python program. I’m guessing that this isn’t impossible, given that FontForge does it, but I’m not quite able to read and understand LookupType 6 well enough to figure out how. If FontForge can do it, it’s certainly possible, though, right?

    What might be the handiest for my purposes, is a way to go through a string of text, letter by letter, advancing the “current letter” index by only one letter each time, and performing substitutions not only on the current letter, but also on the backtrack and lookahead sequences as well. I’d use this to:

    change the glyph of the previous character so it connects to the current character (changing a “connects on the left” glyph to a “connects on both sides” glyph)
    change the glyph of the current character to something that can connect to the previous and/or next characters if possible
    change the glyph of the next character to something that can connect to the current glyph (or not)

    so for a version 1.0 of my font I’d have one character of lookahead, but for a version 2.0 of my font I’d probably go for two characters of lookahead so I can choose between a series of right-side-up glyphs or upside-down glyphs — whichever reduces the number of (virtual) pen-lifts.

    So given the use case I’ve outlined, does supporting multiple substitution seem useful to anyone else?

    1. Miguel Sousa says:

      OpenType allows you to do one-to-one substitutions (sub A by B;), many-to-one substitutions (sub A B by C;) and one-to-many substitutions (sub A by B C;). It doesn’t allow many-to-many substitutions because that’s ambiguos. If what you want is to do something like sub A B by C D; you need to break it into parts: you first replace A by C when A is followed by B, and then you replace B by D when B is preceded by C (which used to be A). The code will be something like this:

      sub A' B by C;
      sub C B' by D;

      This is the simplest example and things can get a lot more complicated. But the bottom line is, you should be able to accomplish what you want by using the available building blocks, i.e. 1-2-1, many-2-1, and 1-2-many substitutions.

Comments are closed.