You will find spent the past several years working (alongside a bunch of super talented people) on the font family called Recursive Sans & Mono, and it just released officially on Google Fonts!
Wanna give it a try super fast? Here’s the embed program code to use the full Recursive variable typeface family from Google Fonts (but you will get a lot more flexibility & overall performance if you read further! )
< link href=”https://fonts.googleapis.com/css2?family=Recursive:slnt,wght,CASL,CRSV,[email protected], 300.. one thousand, 0.. 1, 0.. 1, zero.. 1& display=swap” rel=”stylesheet”>
Recursive is perfect for code, websites, apps, and more.

Recursive Mono has both Linear plus Casual styles for different “voices” in program code, along with cursive italics if you want all of them — plus a wider weight variety for monospaced display typography.

Recursive Sans is proportional, but as opposed to most proportional fonts, letters conserve the same width across styles for further flexibility in UI interactions plus layout.

I started Recursive like a thesis project for a type style masters program at KABK TypeMedia, and when I launched my kind foundry, Arrow Type, I was consequently commissioned by Google Fonts to complete and release Recursive as an open-source, OFL font.
You can see Recursive and find out more about it what it can do with recursive. design.
Recursive is made to be considered a flexible type family for each websites and code, where the main purpose is to give programmers and designers some fun & useful type to play with, merging fresh aesthetics with the latest within font tech.
First, a necessary description: variable fonts are font documents that fit a range of styles within one file, usually in a way that enables the font user to select a method from a fluid range of styles. These types of stylistic ranges are called variable axes, and can be parameters, like typeface weight, font width, optical dimension, font slant, or more creative matters. In the case of Recursive, you can control the particular “Monospacedness” (from Mono to Sans) and “Casualness” (between a normal, geradlinig style and a brushy, casual style). Each type family may have one or more from the own axes and, like numerous features of type, variable axes are usually another design consideration for typeface designers.
You may have seen that Search engines Fonts has started adding adjustable fonts to its vast selection. You may have read about some of the awesome matters variable fonts can do. But , you might not realize that many of the variable fonts visiting Google Fonts (including Recursive) possess a lot more stylistic range than you will get from the default Google Fonts front.
Because Google Fonts has a large range of users — many of them new to internet development — it is understandable that will they’re keeping things simple simply by only showing the “weight” axis for variable fonts. But , just for fonts like Recursive, this simplification actually leaves out a bunch of choices. On the Recursive page, Google Fonts shows visitors eight styles, plus1 axis. However , Recursive actually offers 64 preset styles (also known as named instances), and a total associated with five variable axes you can change (which account for a slew associated with more potential custom styles).
Recursive can be divided into what I think about as one of four “subfamilies. ” The particular part shown by Google Fonts is the simplest, proportional (sans-serif) edition. The four Recursive subfamilies every have a range of weights, plus Italics, and can be categorized as:
Sans Linear: A proportional, “normal”-looking sans-serif font. This is what gets shown within the Google Fonts website. Sans Informal: A proportional “brush casual” fontMono Linear: A monospace “normal” fontMono Casual: A monospace “brush casual” fontThis is probably better to visualize in order to describe in words. Here are 2 tables (one for Sans, another for Mono) showing the sixty four named instances:
But again, the main Search engines Fonts interface only provides entry to eight of those styles, plus the Bodyweight axis:
Recursive has 64 pre-specified styles — and many more using when using custom axis settings — but Google Fonts only shows eight of the preset styles, and just the Bodyweight axis of the five available variable axes. Very few variable fonts today have more than the usual Weight axis, so this is an easy to understand UX choice in some sense. Nevertheless, I hope they add a little more versatility in the future. As a font designer & type fan, seeing the current weight-only approach feels more like an synthetic flattening than true simplification — sort of like if Google Maps would be to “simplify” maps by excluding each road that wasn’t a freeway.
Luckily, you can still access the entire potential of variable fonts managed by Google Fonts: meet the Search engines Fonts CSS API, version second . Let’s take a look at how you can use this to obtain more out of Recursive.
But first, it is useful to know a few things about how adjustable fonts work.
How variable fonts work, and why it issues
If you’ve ever worked with photos on the internet then you know that you should never serve the 9, 000-pixel JPEG file every time a smaller version will do. Usually, you are able to shrink a photo down using compression setting to save bandwidth when users down load it.
There are similar considerations regarding font files. You can often slow up the size of a font dramatically simply by subsetting the characters included in this (a bit like cropping -pixels to just leave the area you need). You can further compress the document by converting it into a WOFF2 file (which is a bit like managing a raster image file though a good optimizer tool like imageOptim). Suppliers that host fonts, like Search engines Fonts, will often do these things to suit your needs automatically.
Now, think of a video document. If you only need to show the first ten seconds of a 60-second video, you can trim the last 50 seconds to get a much small video file.
Adjustable fonts are a bit like videos: they have one or more ranges of information (variable axes), and those can often either become trimmed down or “pinned” to some certain location, which helps to decrease file size.
Of course , variable fonts are usually nothing like video files. Fonts record every letter shape in vectors, (similar to SVGs store shape information). Variable fonts have multiple “source locations” which are like keyframes within an animation. To go between styles, the particular control points that make up letters are usually mathematically interpolated between their different resource locations (also called deltas). The font may have many sets associated with deltas (at least one for each variable axis, but sometimes more). To trim a variable typeface, then, you must trim out unnecessary deltas.
As a specific example, the particular Casual axis in Recursive requires letterforms from “Linear” to “Casual” by interpolating vector manage points between two extremes: generally, a normal drawing and a brushy sketching. The ampersand glyph animation beneath shows the mechanics in action: manage points draw rounded corners from one extreme and shift in order to squared corners on the other finish.
Generally, each added axis increases the number of drawings that must exist to create a variable font work. Sometimes the amount is more or less – Recursive’s Weight axis requires 3 areas (tripling the number of drawings), while the Cursive axis doesn’t require additional locations at all, but actually simply activates different alternate glyphs that will already exist at each location. However the general math is: if you just use opt into fewer axes of a variable font, you will generally get a smaller file.
When using the Search engines Fonts API, you are actually choosing into each axis. This way, rather than starting with a big file and whittling it down, you get to pick and choose the particular parts you want.
Variable axis labels
If you’re going to use the Google Fonts API, you first need to know about font axes abbreviations so you can use them yourself.
Adjustable font axes have abbreviations by means of four-letter “tags. ” These are lowercase for industry-standard axes and uppercase for axes invented by person type designers (also called “custom” or “private” axes).
There are presently five standard axes a typeface can include:
wght – Weight, to manage lightness and boldnesswdth – Thickness, to control overall letter widthopsz – Optical Size, to control adjustments to develop for better readability at numerous sizesital – Italic, generally to change between separate upright/italic designsslnt – Slant, generally to control upright-to-slanted styles with intermediate values availableCustom axes can be almost anything. Recursive includes 3 of them — Monospace (MONO), Informal (CASL), and Cursive (CRSV) — plus two standard axes, wght and slnt.
Google Fonts API basics
When you configure a typeface embed from the Google Fonts user interface, it gives you a bit of HTML or even CSS which includes a URL, and this eventually calls in a CSS document which includes one or more @font-face rules. This includes things such as font names as well as links to font files on Google servers.
This URL is actually a way of phoning the Google Fonts API, and it has a lot more power than you might recognize. It has a few basic parts:
The primary URL, specifying the API (https://fonts.googleapis.com/css2)Details about the fonts you are requesting in a single or more family parametersA font-display house setting in a display parameterAs the, let’s say we want the regular bodyweight of Recursive (in the Sans Linear subfamily). Here’s the WEB LINK we would use with our CSS @import:
@import url(‘https://fonts.googleapis.com/css2?family=Recursive&display=swap’);
Or we can hyperlink it up in the < head> in our HTML:
< link href=”https://fonts.googleapis.com/css2?family=Recursive&display=swap” rel=”stylesheet”>
Once that’s in place, we can begin applying the font in CSS:
body
  font-family: ‘Recursive’, sans-serif;

There is a default worth for each axis:
MONO 0 (Sans/proportional)CASL 0 (Linear/normal)wght 400 (Regular)slnt zero (upright)CRSV 0 (Roman/non-cursive lowercase)Choose your own adventure: styles or axes
The particular Google Fonts API gives you 2 different ways to request portions of adjustable fonts:
Listing axes and the particular non-default values you want from themListing axes and the ranges you want through themGetting specific font styles
Typeface styles are requested by adding guidelines to the Google Fonts URL. To help keep the defaults on all axes but use get a Casual design, you could make the query Recursive:[email protected] (this will serve Recursive Sans Casual Regular). To make that will Recursive Mono Casual Regular, stipulate two axes before the @ and their respective values (but keep in mind, custom axes have uppercase tags):
https://fonts.googleapis.com/css2?family=Recursive:CASL,[email protected], 1& display=swap
In order to request both Regular and Vibrant, you would simply update the family contact to Recursive:[email protected]; 700, including the wght axis and particular values on it:
https://fonts.googleapis.com/css2?family=Recursive:[email protected]; 700& display=swap
A very helpful thing regarding Google Fonts is that you can demand a bunch of individual styles from the API, and wherever possible, it will actually assist variable fonts that cover all those requested styles, rather than separate typeface files for each style. This is correct even when you are requesting specific areas, rather than variable axis ranges — if they can serve a smaller typeface file for your API request, these people probably will.
As variable fonts could be trimmed more flexibility and effectively in the future, the files served pertaining to given API requests will likely obtain smarter over time. So , for manufacturing sites, it may be best to request precisely the styles you need.
Where it will get interesting, however , is that you can also demand variable axes. That allows you to keep a lot of design flexibility without transforming your font requests every time you wish to use a new style.
Getting a complete variable font with the Google Fonts API
The Google Fonts API seeks to make fonts smaller with users opt into only the designs and axes they want. But , to have the full benefits of variable fonts (more design flexibility in fewer files), you should use one or more axes. So , rather than requesting single styles with Recursive:[email protected]; 700, you can instead ask for that full range with Recursive:[email protected] (changing from the; to.. to point a range), or even extending fully Recursive weight range with Recursive:[email protected] (which adds hardly any file size, but a whole lot of extra style oomph).
You can add additional axes simply by listing them alphabetically (with lowercase standard axes first, then uppercase custom axes) before the @, after that specifying their values or runs after that in the same order. For example, to add the MONO axis as well as the wght axis, you could use Recursive: wght,[email protected], 0.. 1 as the typeface query.
Or, to get the full adjustable font, you could use the following URL:
https://fonts.googleapis.com/css2?family=Recursive:slnt,wght,CASL,CRSV,[email protected], 300.. 1000, 0.. one, 0.. 1, 0.. 1& display=swap
Of course , you still need to put that will into an HTML link, such as this:
< link href=”https://fonts.googleapis.com/css2?family=Recursive:slnt,wght,CASL,CRSV,[email protected], three hundred.. 1000, 0.. 1, 0.. one, 0.. 1& display=swap” rel=”stylesheet”>
Modifying it further to balance versatility and filesize
While it can be appealing to use every single axis of a adjustable font, it’s worth remembering that every additional axis adds to the overall data files ize. So , if you really do not expect to use an axis, it makes sense in order to leave it off. You can always include it later.
Let’s say you would like Recursive’s Mono Casual styles within a range of weights,. You could use Recursive: wght, CASL,[email protected], 1, 1 such as this:
< link href=”https://fonts.googleapis.com/css2?family=Recursive:CASL,MONO,[email protected], one, 300.. 1000& display=swap” rel=”stylesheet”>
You are able to, of course , add multiple font households to an API call with extra family parameters. Just be sure that the fonts are alphabetized by family title.
< link href=”https://fonts.googleapis.com/css2?family=Inter:slnt,[email protected], a hundred.. 900? family=Recursive: CASL, MONO,[email protected], 1, 300.. 1000& display=swap” rel=”stylesheet”>
Using variable fonts
The standard axes can all be controlled along with existing CSS properties. For instance, in case you have a variable font with a bodyweight range, you can specify a specific bodyweight with font-weight: 425;. A specific Slant can be requested with font-style: oblique 9deg;. All axes can be managed with font-variation-settings. So , if you want a Mono Casual very-heavy style of Recursive (assuming you have called the full family since shown above), you could use the following CSS:
body
 font-weight: 950;
 font-variation-settings: ‘MONO’ 1, ‘CASL’ 1;

Something good to learn: font-variation-settings is much nicer to use together with CSS custom properties.
Another helpful thing to know is that, while you must be able to activate slant with font-style: italic; or font-style: oblique Xdeg;, internet browser support for this is inconsistent (at least at the time of this writing), therefore it is useful to utilize font-variation-settings for the Slant axis, as well.
You can read more details about designing with variable fonts at VariableFonts. io and in the wonderful collection of CSS-Tricks articles on adjustable fonts.
Nerdy notes on the functionality of variable fonts
If you would be to using all 64 preset types of Recursive as separate WOFF2 documents (with their full, non-subset personality set), it would be total of about six. 4 MB. By contrast, you could have very much stylistic range (and everything within between) at just 537 KB. Naturally , that is a slightly absurd comparison — you would almost never actually use sixty four styles on a single web page, especially not really with their full character sets (and if you do, you should use subsets and unicode-range).
A better comparison is Recursive along with one axis range versus designs within that axis range. Inside my testing, a Recursive WOFF2 document that’s subset to the “Google Fonts Latin Basic” character set (including only characters to cover English plus western European languages), including the full 300–1000 Weight range (and all other axes “pinned” to their default values) is definitely 60 KB. Meanwhile, a single design with the same subset is twenty five KB. So , if you use just 3 weights of Recursive, you can save regarding 15 KB by using the variable typeface instead of individual files.
The full adjustable font as a subset WOFF2 lighting in at 281 KB that is kind of a lot for a font, although not so much if you compare it towards the weight of a big JPEG picture. So , if you assume that individual designs are about 25 KB, if you are planning to use more than 11 styles, you’d be better with better off using the variable font.
This sort of math is mostly an academic workout for two big reasons:
Variable fonts aren’t just about file size. The a lot bigger advantage is that they allow you to simply design, picking the exact font dumbbells (or other styles) that you want. Is really a font looking a little too light? Increase the font-weight a bit, say through 400 to 425! More importantly (as explained earlier), if you request adjustable font styles or axes through Google Fonts, they take care of the particular heavy lifting for you, sending what ever fonts they deem the most performant plus useful based on your API ask for and the browsers visitors access your blog from. So , you don’t need to go downloading fonts that the Search engines Fonts API returns to compare their particular file sizes. Still, it’s really worth understanding the general tradeoffs so you can greatest decide when to opt to the variable axes and when to restrict yourself to a couple of styles.
What’s following?
Fire up CodePen and give the API a try! For CodePen, you will probably wish to use the CSS @import syntax, such as this in the CSS panel:
@import url(‘https://fonts.googleapis.com/css2?family=Recursive:CASL,CRSV, MONO, slnt,[email protected], 0.. one, 0.. 1, -15.. 0, three hundred.. 1000& display=swap’);
It is apparently preferable to use the HTML link syntax to prevent blocking parallel downloads of various other resources. In CodePen, you’d break open the Pen settings, choose HTML, then drop the < link> in the HTML head configurations.
Or, hey, you can just shell my CodePen and experiment right now there:
Take an API configuration step-around
If you are want to skip the difficulty of figuring out exact API phone calls and looking to opt into adjustable axes of Recursive and create semi-advanced API calls, I have gather a simple configuration tool on the Recursive minisite (click the “Get Recursive” button). This allows you to quickly choose pinned styles or variable varies that you want to use, and even gives quotes for the resulting file size. But , this particular only exposes some of the API’s features, and you can get more specific if you want. It is my attempt to get people utilizing the most stylistic range in the littlest files, taking into account the current limitations associated with variable font instancing.
Use Recursive for code
Also, Recursive is in fact designed first as a font to make use of for code. You can use it upon CodePen via your account settings. Even better, you can download and use the most recent Recursive release from GitHub and place it up in any code editor.
Discover more fonts!
The Google Fonts API doc helpfully includes a (partial) list of variable fonts along with information on their available axis ranges. Several of my favorites with axes beyond simply Weight are Crimson Pro (ital, wght), Work Sans (ital, wght), Encode Sans (wdth, wght), plus Inter (slnt, wght). You can also filtration system Google Fonts to show only adjustable fonts, though most of these results have got only a Weight axis (still great and useful, but don’t require custom URL configuration).
Some more incredible variable fonts are coming to Search engines Fonts. Some that I am specifically looking forward to are:
Fraunces: “A screen, “Old Style” soft-serif typeface influenced by the mannerisms of early twentieth century typefaces such as Windsor, Memorabilia, and the Cooper Series”Roboto Flex: Such as Roboto, but withan extensive runs of Weight, Width, and Optic SizeCrispy: A creative, angular, super-flexible adjustable display fontScience Gothic: A squarish sans “based closely on Financial institution Gothic, a typeface from the earlier 1930s—but a lowercase, design axes, and language coverage have been added”And yes, you can absolutely download plus self-host these fonts if you want to make use of them on projects today. But stay tuned for more to Google Fonts for more awesomely-flexible typefaces to come!
Of course , the world of kind is much bigger than open-source fonts. There is a bunch of incredible type foundries focusing on exciting, boundary-pushing fonts, and many of these are also exploring new & fascinating territory in variable fonts. Several tend to take other approaches to license, but for the right project, a good typeface can be an extremely good value (I’m certainly biased, but for a simple argument, simply look at how much typography strengthens manufacturers like Apple, Stripe, Google, IBM, Figma, Slack, and so many more). If you want to feast your eyes upon more possibilities and you don’t know these names, definitely check out DJR, OHno, Grilli, XYZ, Dinamo, Typotheque, Underware, Bold Monday, and the a lot of very-fun WIP projects on Long term Fonts. (I’ve left out a bunch of additional amazing foundries, but each of these has been doing stuff I particularly love, which isn’t a directory of kind foundries. )
Finally, some shameless plugs for myself: if you would like to support me and our work beyond Recursive, please think about checking out my WIP versatile sans-serif Name Sans, signing up for my (very) infrequent newsletter, and giving us a follow on Instagram.