Name: Recursive
Designer: Stephen Nixon
Foundry: Arrow Type
Release Date: Beta version is available to download now via Github. Google Fonts version available soon.

Backstory: While finishing up his Master’s at The Hague in The Netherlands in KABK’s TypeMedia program, Stephen Nixon became fixated on variable fonts, the flexible, shape-shifting font files that make responsive websites and interfaces possible. Nixon was less interested in the technical aspect of variable fonts, which enable an array of styles to be available in a single font file. Rather, he wanted to explore what a variable font could achieve stylistically. “I wanted to see what else I could do with that single file and how else a font might provide additional typographic range to a designer or a web developer,” he says. 

A simple variable font might let designers choose between a handful of weights. Maybe it would give options for adjusting letter width. Recursive is what Nixon calls a five-axis variable font, which means people can customize five separate visual features including weight, mono spacing, slant, italics, and “casual,” which determines if the font looks more like a brushstroke or if it’s more traditionally structured. 

The remit was ambitious, and it took Nixon two years and a commission from Google Fonts to finish the project after he graduated. Nixon views Recursive as a cousin of the all-in-one font super family, which historically have been made to address many of the same challenges Recursive is trying to solve for. Typefaces like IBM Plex or Apple’s San Francisco are made up of similar but different font subfamilies that allow the styles to mixed and matched and applied in a variety of situations. Recursive does the same, only it does so with a single font file. “It allows designers to make really rich typography, but also have a little bit of safety knowing that they’re not trying to pair things that are wildly incompatible or different,” he says. “I wanted to take the concept of a super family and put it into a single variable font to make it one step easier for users.”

Recursive by Arrow Type

What are its defining characteristics?
Nixon was inspired by a style of sign painting known as single-stroke casual. He was attracted to the versatile artistry for the medium, which was often used on hand-painted signs. “All of the letters are made with single strokes with usually a flat or sometimes a round brush,” he says. “The amount of control a good sign painter will have allows them to get a huge variety of shapes from the same brush and with the same materials. I wanted to capture some of that flexibility into a single typeface.” Most casual brushstroke fonts are bubbly and a little goofy. They’re often slanted and maybe cursive. “A lot of that is simplified and straightened out in Recursive’s casual styles,” Nixon says. Recursive’s linear styles have the DNA of fonts used for reading on screen—straightened sides, large ink traps, and mono linear strokes. In some ways, it’s many fonts in one. “I’m interested in typography that’s rich and varied and maybe looks like multiple fonts,” he says.


Why’s it called Recursive?
Nixon looked to computer programming for naming the typeface. “Recursion is a technique where a function or a piece of code uses its output as an input and fires itself again,” he explains. “It’s not so different from, say, a Russian nesting doll—each time you open up the doll, there’s another one inside that’s a slightly smaller version. For Recursive, I had this goal from the outset of making it a font focused on code. As I was working on recursive, I was constantly using the beta versions of the font in code editors and terminals. Testing it in-context helped me find opportunities to improve its usability, spacing, and legibility. I was coding as a way to further develop the family. And so it was a recursive process.” There also happens to be a simpler explanation: “It’s a font that is loosely based on handwriting, so in a general sense it can be called cursive, but it’s not a connected script—it’s sort of a reinterpretation.”

How will I use it?
The beauty of a flexible font like Recursive is that it fits many use cases. Nixon says he’s interested in how something like Recursive can help create more intuitive and dynamic digital user interfaces through typography; but he imagines it will come in handy for anyone looking to build visually exciting but nimble websites and apps that don’t have as much of a performance drag. It’s also a font made for coding. “Its Casual styles are perfect for terminals, relaxed coding, and presenting snippets of code, while its Linear styles are refined and made more serious for complex code and longer-form focus,” Nixon explains. “There are also code ligatures for folks who like them, which may not matter much for designers, but is a really nice usability enhancement for some developers.”

What do I pair it with?
Recursive goes best with other versions of itself, naturally.