Font variables
Font variables are named font settings you save once and reuse across your app. Instead of setting the same font family on every element and/or style, you reference the variable, keeping your typography consistent everywhere it's used.

When you update a font variable, every element that uses it updates too. This makes it much easier to iterate on your app's typography, especially as your app grows.
What font variables are for
Most apps rely on a small set of text styles that appear over and over: headings, body text, captions, buttons, and links. Without variables, each of those styles ends up scattered across your app, hardcoded on individual elements. Updating one style means finding and updating every element that uses it.
Font variables replace that pattern with a single, named reference. Once a font is saved as a variable, it becomes part of your design system, available to any element or style that needs it.
Creating a font variable
Name and describe the font
The name and description you give a font variable have a big impact on how easy it is to work with, especially as your app grows and other people collaborate with you.
Naming variables
The name is how you'll reference the font in the editor, so it should make the variable easy to identify at a glance.
Name by role, not appearance. Brand heading is more useful than Inter, because the name still makes sense if you change the font later. Naming by appearance breaks down as soon as your typography evolves.
Group related variables with a prefix. Prefixes like Heading, Body, and Caption help related fonts sort together and make the picker easier to scan. For example: Heading primary, Heading secondary, Body primary.
Match your team's naming conventions. If you're working with others, agree on a naming pattern early. Consistency is more valuable than any specific naming choice.
Writing descriptions
Descriptions aren't required, but they're useful for anyone (including future you) trying to understand what the variable is meant for.
Explain the intent, not the font. A description like Used for primary page headings is more helpful than Inter. The intent is what stays consistent even if the font changes.
Note where it should be used. If a variable has a specific purpose, spell it out. For example: Section titles inside cards and modals or Metadata like timestamps and author names.
Note where it shouldn't be used. If two variables are similar, describing when to pick one over the other prevents mix-ups. For example: Use for standalone captions; body text should use Body default.
Keep it short. A sentence or two is usually enough. Descriptions are meant to give quick clarity, not full documentation.
Using font variables
Font variables are available anywhere you work with typography in the editor. In the property editor, wherever you'd normally set a font family, you can pick a variable instead. The picker shows your saved variables alongside the standard font options, making it easy to apply the right one.

Font variables can be used in:
Element properties, such as text elements, buttons, inputs, and any other element that displays text.
Styles, so an entire component's typography is built from your variables. Using variables inside styles is what ties the whole system together.
Conditional properties, letting you change an element's font based on a rule while still referencing your saved set.
Since font variables only set the font family, other typography settings like size, weight, and style are configured separately on the element or style. This gives you the flexibility to use the same font family in different sizes and weights across your app while still keeping the underlying family consistent.
Updating a font variable
This is what makes font variables so powerful. Instead of tracking down every place a font is used, you can change it in one place and see the change propagate everywhere.
Searching for components using a specific font variable
Find usages is useful when you want to review the impact of a change before making it, clean up unused variables, or trace inconsistencies in your design. It's especially helpful in larger apps, where the same variable can be referenced in many places across pages, reusable elements, and workflows.

FAQ: Font variables
Last updated
Was this helpful?