Bernd: Hi, I'm Bernd Volmer.
I'm a type designer and font engineer and I work in the intersection of design and tech.
I write and draw letters and I develop these into fonts.
Fonts are pieces of software that contain Bézier outlines
and today I want you to look at fonts from my perspective.
So this is how I see fonts most of the time.
After writing or sketching comes digitization where we work with cubic Bézier curves.
Define spacing, kerning and open type features.
This is what you see when I'm done with my work and the font is actually being used.
This will be a bit of a nerd talk and we will get into different design
spaces but before we get into it I want to mention Nina Bender who co
-created the visual identity and the style guide for this conference.
She's the graphic designer behind the shirts, behind the
banners, the entrance bands, the badges and the designer
behind so many beautiful graphics you see at the conference.
Audience: *applause*
Bernd: I will talk about variable fonts but first I want to give credit where credit is due.
Peter Karow's work kind of laid the foundation for modern font
families and all other technology that followed as he introduced
interpolation in font software in Ikarus, in URW's Ikarus.
Adobe was the first to introduce interpolation to font users in the early 90s.
I discovered multiple master fonts during my studies around
2008 and I couldn't believe that this technology died.
I was studying graphic design and I was blown away by the
possibility to fine-tune width and weight as a font user.
I was made aware of Apple's TrueType GX technology
when OpenType variable fonts were already discussed.
The problem, I think, with Adobe multiple master fonts and
with Apple's TrueType GX fonts was gatekeeping because they
didn't share the format and they didn't open source the format.
Ikarus, multiple master and TrueType GX all use different
technology and even outline types under the hood.
But all formats have one thing in common.
They all built on the foundation that Ikarus laid in
the 70s and 80s for font digitization and interpolation.
Can you believe that we had multiple master fonts in the 90s?
So the sliders we now know from variable fonts we
already had in the 90s but with different technology.
Typographers and graphic designers could adjust
weight and width and contrast to their needs.
Adobe used cubic Bézier outlines in their OTFs for that technology,
while Apple used quadratic outlines in their TrueType fonts.
There were designers like Erik van Blokland, Just van Rossum and Tom
Rickner, to name a few, that early on saw the potential of technologies like
TrueType GX and designed and developed fonts that were ahead of its time.
Fast forward 22 years later and we got the introduction of
variable fonts as part of the OpenType specification 1.8 in 2016.
So what changed? I think designers nowadays are more tech savvy than in the 90s.
The OpenType spec 1.8 is a standard, shared and supported by all
major industry partners and supported in design apps and browsers.
So no more gatekeeping.
Back in the old days TrueType GX fonts were hacky and most of the fonts
were experiments that were never meant to be used by regular designers.
There has always been a fascination for experimental fonts like Beowulf,
FF Trixie, but I think the main difference between the early technologies from
the 90s and the variable fonts of today is that it seems that designers are
more ready for the technology now and they actually want to use this technology.
A lot of the terminology when we talk about fonts originated from metal typesetting.
Light, regular and bold are style names from that era.
As font users, we are still used to weight and
width names that originated from metal typesetting.
But what if the font family is bigger than that? What if we have multiple widths?
What if we have multiple weights?
Microsoft supplies a lot of documentation and font specification.
Part of the OpenType specification are the OS/2 weight classes
that correspond to suggested weight descriptions by Microsoft.
Like with any specification, it's good knowing it and following it when in doubt.
But as creatives, it doesn't always work without challenging the spec.
Font engineers are still limited to a maximum of 31 characters for
the font full name, which consists of family name plus style name and
is limited to 27 characters for postscript names, which consists of
the family plus style names minus the spaces, but plus one hyphen.
Looking at these weight descriptions, I would recommend avoiding extra, semi
and all that in your names, because it just makes them unnecessary long.
And it also doesn't sound decisive.
So for this particular font family Kario, I just used
short style names, no extra, no semi in the style name.
Looking at the width classes that the old OS/2 table suggests us, we have plenty of options.
But again, unnecessary long names like ultra or extra condensed.
Also, Microsoft really wants me to limit the amount of
condensed width to four, which I think is not enough for Kario.
So we have a XXXCondensed, and XXCondensed, and XCondensed, a
Condensed and Narrow, which are all narrower than the normal width.
And they don't fit in the spec. So I had to shift everything.
And I wanted to use these short names, so I didn't have to
shorten them further for the postscript names and the full names.
To understand what I was just talking about, and to give you a real world example,
if we had an ultra condensed extra light, the ultra
condensed extra light italic or the ultra condensed
extra light small, MS Office wouldn't be able to
differentiate these because it still has the 32
character length restrictions for font full names,
even in 2025. But let's get back to the overview of
styles. We end up with a seven by seven design
space, which has actually seen the addition of one
more width at 38% for the library release of Kario,
so that the jump at the bottom from the super narrow
30% to the 50% above it doesn't feel that big anymore.
And the idea behind this design space was simple.
You should never have to search for the perfectly
fitting width anymore, because the variable font
should basically cover any width, any weight in
between. And before September 2016, this font family
would have been saved in separate files, resulting
in a total of 112 files for this font family.
So, what happened in September 2016? The OpenType spec
1.8 introduced variable fonts as an industry standard,
a format that combines a font family into one file.
The motivation behind this was to reduce file size,
and therefore reduce bandwidth on the web. Preceding
the launch of the OpenType spec was a talk by
Behdad Esfahbod at TYPO Labs in Berlin in the same
year, where he talked about the advantages of the
variable font format. So, all the single font files
add up to a lot of data and slow down internet
performance. So, this would result in more than
three megabytes for the whole family. So, the promise
was simple. You could combine the whole font family in
one font file and save bandwidth. Little did we know
what this would trigger. By the way, what you see
here is a traditional width and weight, the other way
around, width and weight, two-dimensional design
space. What I mean by design space, so when designing
a typeface, you start somewhere. So, this is like
a lightweight with some contrast, a serif typeface.
And in the multiple master setup, which Adobe introduced and we are still working with as
designers, you would add, like if you want a weight
axis, you add the other extreme and you get the
interpolation in between. And the name multiple master,
it's quite simple to explain it. Every time you add
an axis, the amount of masters and the amount of
work multiplies, it's exponential. And to show you
what I mean with these lines, I show this little
interpolating e. So, everything in between basically
interpolates. And again, if we… So now we have in the
bottom a high contrast serif, in the top a low contrast
serif and in the back, a sans serif with even lower
contrast. And there's not even italics. So, if we add
italics, it's again multiplying. But we can set up
a design space in different ways. Coming back to
our design space diagram, this is a rather simple two
-dimensional design space. Just two axes. Weight on one
axis and serif style on the other. In order for it
to work as a variable font, we are doing something
that is not that simple. Every outline of every serif
style needs to be point compatible so that we can
interpolate between weights and styles. What I mean
by that is we need to have the same starting point,
the same outline direction, the same outline type,
the same amount of on and off curve points in all
masters. This way we can interpolate between
different serif styles. And again, none of them,
none of this would work if the outlines weren't point compatible. So, this already shows the
limitation of the variable font format. We can't
expect anything, any working interpolation between
incompatible outlines. On the next slide, there
will be a lot of text, but I don't want you to read,
please. I want you to walk on my shoes and just
look at the shapes. There's a sans, a serif, a slab
serif, a bracketed serif, a tuscan, and a calligraphic
style, all built into one variable font. You can see
a changing serif style and weight from top to bottom.
And all this follows the same basic principle that the
previous described technologies were also relying on.
Every glyph needs to be point compatible in order for it
to interpolate. The font is called Seraphs and it
is kind of like the Swiss army knife and combines
multiple features and styles into one font family.
This makes Seraphs great for prototyping and testing
different aesthetics. If you need a logo, Seraphs
is a great starting point for different styles,
but Seraphs shares the fate of the Swiss army knife.
It is great at being versatile, but most people will
probably use a screwdriver for tightening a screw
rather than using the Swiss army knife. Another
thing I learned when I released this was complex
systems don't tend to explain themselves. If Ikea
furniture told me one thing, it's good to have
good documentation. It makes life so much easier.
The initial version of Seraphs released in 2019. I
launched it together with a microsite that showed
the variable font in use, but there wasn't much
explanation or documentation. So later on I added a
PDF that would explain the family structure, the
access locations, the open type features and everything
that's in the variable font. So it makes life easier for
the users. Like I figured they can't look into my head.
But let's get back to design space diagrams. This
variable font is an exploration into the arbitrary
axis model. So unlike the multiple master model,
this doesn't add exponential amounts of masters every
time I added an axis. So it seems like the perfect
design space for lazy people. You can add an axis,
but you don't have to multiply the masters and do
exponential amounts of work. Sounds great. I'm in.
Spoiler alert for the curious but lazy type designers
listening. There's a lot of unpredictable and
unpleasant interpolation happening. And like in this interpolation, I'm trying to show the
interpolations that still look reasonable. So there's
a bigger chance that users will make ugly designs
or unpredictable designs with this particular variable font using the arbitrary axis model.
But design spaces can be simple. Well, simple -ish. This is a one-dimensional design space.
So there's two extremes and there's some intermediates in between.
So the tricky part is not the design space, but the
outline structure, which needs to be compatible.
Of course, the E on the left could be much simpler
in outline structure, but it needs to be compatible
with the E on the right. So it needs to have all
these extra points. And when looking for a name for
that font, well, it's dripping. So I called it Drippy.
And yet the explanation is simple. Because it drips,
I didn't see any other typeface that was doing that.
So I made one. The animation is also very simple.
Audience: *applause*
Bernd: The animation is also very simple. It's just going from one
extreme to the other. Just every glyph gets a bit of a delay.
So it doesn't start dripping at the same time. We saw this design space diagram earlier.
It is the design space of Palast, a variable font family with weight and optical size axis.
What I mean by optical size is that. So on the left, we
see Poster, which is intended for use in big size. And on
the right, we see Text, which is intended for use in
small size. So we actually want the highlighted ones
to be used. What's changing is the contrast, the
thick and thin contrast is being increased for bigger
sizes. The spacing is being tighter for bigger
sizes. So in small sizes, the thins are more robust,
so it doesn't break away. And the spacing is more generous, so it's easier to read.
This is how these adjustments look in detail.
It should be interpolating. Now. Right.
So this is like, the optical sizes came from metal
type setting. And now it interpolates because
we've got variable fonts. But just because it came
from metal type setting and from serif text typefaces
doesn't mean that we can't use it for something completely different.
So what do we have here? A one dimensional design space. But that's not the point. And also,
these aren't point compatible. The outline structure is completely different.
So how is it supposed to interpolate? Well, it doesn't.
Turns out we can also have breakpoints along one axis,
where the design and the outline structure changes.
And for this example, I added stroke weight changes
along the optical size axis, in short OPSZ, and breakpoints.
You might be wondering why I used OPSZ for that.
The answer is simple. OPSZ is active by default in
most browsers. So if you use a font size relative
to your view width, and you scale the browser window,
the font changes as well. These changes could be
subtle. They could be used for something like it was
intended for, like small subtle text adjustments. But it
could also be used for display type, for making
the design more detailed, adding more lines to the
design or reducing the amount of lines when it's
getting smaller. And the cool thing is it works in
the browser out of the box. You don't need to write
any code for that. So you just need a font with an OPSZ
axis for it to work. The next design space shows the
setup of the TypoLabs font that was used as a key
element of a visual identity for a font technology
conference. The design space is rather traditional.
The width, probably not, it's also like really condensed. And what might also be interesting
is the release date of this. Why? Because this
was probably the first identity to use a variable
font. When we worked on the identity, there was no
browser support for variable fonts. And the major
design apps also did not support variable fonts
yet. So we had an SVG animation on the website. And
instead of having a fallback, we had a fall forward.
Because Chrome and Safari already had developer
versions and beta versions that were supporting
variable fonts. So as soon as the next version
of Chrome and Safari was released, this actually
supported variable fonts. And you wouldn't just
get a static SVG animation, but an editable text
animation. I think the advantage of this is very simple.
It's searchable text. It's editable text. And it's way more flexible than an SVG animation.
Right. For the SVG animations, we used Erik van Blokland's responsive lettering example. And
because the apps didn't support it, we were using Drawbot to create all the visuals.
The interesting thing about this was because there
was no examples, so we were just trying to come up
with solutions and doing things. So the rules were
quite simple, just going from a black condensed to
a ultra condensed lighter weight. And because the rules
weren't actually there, so we were just playing with it.
And defining the rules along the way. So we were
exploring, like, how else could we interpolate
between the different states. So for this, we divided the canvas
into fifths, I think. And one fifth was always highlighted.
There's a whole lot more to this identity, but I will spare you the details.
Some font families require a different design space set up.
This is a monospace with a weight axis, but it also
has a proportion, it also has proportional styles,
and you can interpolate between monospace and proportional and between light and bold.
But what's interesting about this font family is that
there's more than one font family in that family.
So is it really a font family? We discussed a lot
about this and ended up calling it a patchwork family,
because it has these different members that
somehow relate and belong together, but also not.
The proportional styles are duplex or uni-width, which
means that they share the same width in all weights.
So the bold and the light, they all have the same width.
So you can layer them on top without the text reflowing.
So for this example, it's a book by Catalogtree where they
layered the different weights of the font in different colors.
What's interesting about Marjoree is that it's not just a text font family.
There's the other part of the Marjoree font family, which are pattern-based variable fonts.
This one in particular is based on one out of 14
documented pentagonal tilings that tile the plane.
Four of these were created by amateur mathematician Marjorie Rice,
whose work inspired the design and the name of this font family.
So we went with type 9 monohedral pentagonal tiling, where all four lengths,
but one, like four out of five sides share the same length.
And to give you a real-world example, I'm showing some code here.
I'm not a coder, but I dare to. This is scary now.
It's just HTML and CSS, so there's no magic happening here.
And the interesting bit here that I want you to focus on is that part.
So that's basically the animation that we will see.
So we're basically defining keyframes.
We are going from, I can't read the numbers, I think weight 700 invert 0,
to weight 300 invert 0, to weight 300 invert 100, to weight 700 invert 100.
So going along all extremes. And what this looks being applied in an animation is this.
So it goes through all the masters and interpolates in between.
And because it's a pattern font, it looks a bit fancier than the usual text font.
And the cool thing is it's editable text.
It would be searchable on the web and you can edit it to whatever you want.
And this font was created by Catalog^tree and
they went one step further with the animations.
So this is still the same font. They just layered the same thing on top of each other
with different moments in time. So you would see different colors being more dominant
or less dominant depending on where you are in the interpolation.
This will be the last design space diagram that I will show.
So let's look at what we got here. A weight, a width and an optical size axis.
But there's something special about the weight axis because of the way it functions.
It's like a grade axis. We had this earlier. But what
does it exactly mean? I didn't explain it earlier.
So the weight axis, it doesn't change width. So it's uniwidth.
So the bold and the light, they all share the same width.
But why would this be interesting? For buttons,
for example, you can hover over the button and go
from regular to bold and the text doesn't reflow.
It doesn't get wider. It doesn't jump or anything.
It just gets bolder and you can animate. I built
a microsite where I explained all the features
and the design DNA of Kario, which is also the
typeface that has been used for this conference.
It shows the different widths and you can control
width, font size and line height at the same time
or just width to control with the slider. The buttons,
when you hover over it, it shows the uniwidth feature.
You hover over it, but the text doesn't reflow. It doesn't get wider or narrower.
There's a section that shows all the styles. So it
goes from the Xtended styles to the XXXCondensed styles
through all the weights. And the text is editable. So if
you want to try a specific style, you can type something.
And it shows you on the bottom which style you are
looking at and where you are in the design space on the
weight and width axis. This is another way of looking
at the width and weight. So you get all the width
and weights. It's controlled by mouse position, but you
can also click on a specific spot in the design space
and it copies the CSS for you. This explains the optical
size feature in Kario. So there's tighter spacing,
shorter ascenders, shorter descenders for like
super compact setting in big sizes. And there's more
generous spacing with larger ascenders and descenders for text settings in small sizes.
And it basically explains everything that went into the design of the typeface.
Right. I thought that was the next slide.
Right. So that font is called Kario and it's
recently released. I didn't communicate about it yet,
so that's probably the first time I'm communicating
about this. It's recently released through my
independent font foundry ShowMeFonts. There's some
hacky things that went into developing it. For
example, if you type the lowercase Eszett next to
capital letters, you get automatic replacement for
the capital Eszett, which I don't know why other fonts aren't doing that. But…
Audience: *applause*
Bernd: …we don't have a, like if we,
if we use shift Eszett, we get a different character. So there's no key on our keyboard,
so we need these little hacks to make things work.
Like, I'm really curious how this audience will
react to this, because if I talk about fonts,
I usually talk with designers. I think now I'm
in a room with so much technological knowledge.
So I'm really curious how you will use variable
fonts. You could connect variable font axes to
real-time data, or you define the rules. I'm really curious how it will be used.
And to give you a super cool real-world example from
Nina, when she was designing the entrance bands,
she used the width axis to make everything fit. So
like the space is always the same, but the words
have different lengths. So to make it fit, she used
the fitting width, so it fit the space perfectly.
Right. I think that's it. Sorry.
Herald: Yes, thank you very much for this excellent talk.
So we have time for Q&A. Are there questions from
the internet? And if you have questions, please line
up at the microphones. Okay. Microphone number one.
Audience: Yes. This reminds me very much of Hermann Zapf's Hz
program. Did this turn up during your research? Is there
kind of a relationship?
Bernd: I know he was also involved in MetaFont, I think. But AZ program?
Audience: Hz. Hz, like his initials.
Bernd: I'm not familiar with that, I have to admit.
Audience: Thanks.
Herald: Microphone number two.
Audience: Hey. You said that the idea of variable fonts came up pretty early and
that you kind of are at the mercy of the big tech
companies like Adobe and Microsoft. And what's next
on your wish list? What could be, but isn't yet?
Bernd: Oh, that's interesting. I think for a long time,
we were begging for After Effects to support
variable fonts so long that competitors actually
developed solutions that are better, that no one
was really waiting for After Effects anymore.
So I think if a pain point is big enough, there will
be a solution from the industry or somewhere else.
So that, yeah, I have no specific wish list at the moment. I think the spec in some places,
it's a little bit outdated. Like I said, on the weight
axis, it goes from 100 to 1000. So there's a lot
of possible steps in between. But on the width
axis, it goes from 1 to 9. That might not be enough
these days.
Herald: Microphone number five.
Audience: Hey, are we going to see letters changing to other letters?
Or are we going to see animated emojis?
Bernd: I think there's examples of that. Underware, a Type
Foundry from the Netherlands, they made Scribo,
I think, where letters morph into other letters.
Like I don't, I think this will cause a lot of
confusions.
Audience: Yes.
Bernd: Because usually when we type a letter, it's
connected to Unicode. We expect a certain visual.
And if that's not happening, it's kind of like a visual coding, decoding error.
Yeah, I think it will cause confusion. But these
experiments are super interesting. And there
is animated emojis as well. But yeah, I think
it's very niche, all these things that could fill
another talk.
Audience: Thank you.
Herald: Microphone number three.
Did you do experiments on changing the fonts on single letters, spatially?
Bernd: Sorry?
So for example, you have here very thin on the top and very thick on the bottom.
Bernd: Yeah.
Audience: For the letters in the middle, you could alter the font within the letter itself.
Bernd: Yeah.
Audience: Did you do experiments on that?
Bernd: I think this was basically my, like, usually I try to show
finished work. Now I opened the box of experiments
that I don't know where they're going, if they went
anywhere. And yeah, I don't know if any of this will
ever be released, if it works as a product. But I
think it's interesting experiments. I think there's
so much to experiment with. So letters changing,
it's, I'm talking about masters that are predefined.
But in the font, this is how we design it. But in the
font itself, it's a origin and deltas that move points
away. So this would be a whole nother experiment
and box of experiments playing with those deltas
instead of defining masters, addressing these by
script or some way or another. But yeah, no plans yet.
Herald: Microphone number two.
Audience: Hi. I don't know about the
variable font API, but it looks like all this classical
curve-based shapes. Is it also open technically to
do some GPU real-time shader behavior on the font?
Bernd: Yeah, I'm wondering because then…
I'm wondering. I think the font as itself, it
has this limitation that it needs to have, like,
it either needs to define the design space or have
the instruction on how to move points. So it's not
that open. There have been experiments like Beowulf,
which was a Type 1 font. That's an old font format,
where Erik van Blokland and Just van Rossum hacked
the font itself. So it actually was random. And the
outlines were actually manipulated every time it was
created on the fly, basically. But I don't think,
like, it's more constrained with variable fonts.
Herald: Microphone number four.
Audience: Hey, thanks for the talk.
I was wondering about the CSS specification, because there's currently only like five or six
keywords describing one of these languages, or one of the fonts. But you've been using,
for example, serifs as a custom scale, I think. Do
you know if there's any work being done in the CSS
or in the browser rendering space that will lengthen
this list of parameters? Because currently I've
been only seeing like three or four.
Bernd: I think there's been some, like, when the spec came
out, designers reacted to it in different ways.
And there were some people really pushing it, like
Amstelvar, for example. There's this platform called
Axis-Praxis, where you can try different variable
fonts. And it has a lot of on-spec, but a lot of
off-spec axes as well. So that's already kind of
like the wish list for, hey, wouldn't it be nice to
have this as an axis? Serifs, it's not a specified
axis in the spec. It's something, some experiment
that I thought would be interesting trying. And yeah,
I think I managed to turn it into a usable product,
but it's not following the specification. So yeah, there's no documentation on non-specified
access, I think.
Herald: Question from the internet?
Signal: Yeah, question from the internet. How do ligatures work with variable fonts?
Bernd: How do what work?
Signal: Ligatures. The ligatures.
Bernd: Ah, ligatures. Okay. So that's a broad question. Like, all applications do something
different. So most, I think all browsers support
Liga, so the standard ligatures by default. Then we
have contextual alternates, we have discretionary
ligatures. So we have different OpenType features
where we can put ligatures.
Signal: I think the question goes a little bit in, I think, the design direction. So
there's a question about strange looking space between variable things.
Bernd: Ah, okay. So with ligatures, I think the problem is,
especially if we now live in a world where we can
change spacing and all that. But in a ligature,
we can't, it's like one character for two or three
characters. So it's like a CH ligature or an FL
or FI ligature, where two characters are morphed
together. The problem with that is, if you change
the spacing, the ligature will have the same spacing.
So if you make everything a little wider because it
looks too tight in small sizes, the ligature will
still be tight in that more generously spaced text.
And the other way around, if you make it tighter, the
same. And at some point, these ligatures even break
because you change the spacing in the browser, in the
design app, whatever. So my personal opinion on
ligatures is, I try to avoid it, to be honest.
Herald: Microphone number four.
Audience: How do things like projection play a role in variable fonts,
projection like kerning and projection with where you might need to scale the font size
differently from scaling the white space between the characters?
Bernd: If you talk about kerning, like
letter combination specific spacing of letters. So
we have linear interpolation of kerning in variable
fonts. But we would need something else, to be
honest. So if we think about a capital T, lowercase O
combination, and the font is super bold, the O
doesn't fit under the T. So the kerning needs to be
different than if it would be a hairline where
we actually want to squeeze it under it. And then
if we move along the design space, there will
always be this awkward moment where it shouldn't
interpolate linear, but behave a little different.
So there's workarounds for that, but it's not super
commonly used at the moment, I would say.
Audience: Thank you.
Herald: Okay, so we're running a bit short on time,
so please short question, short answer. Microphone number five.
Audience: Yeah, thanks for the demo,
but actually you only talked about the shape of
the letters. So is there any possibility to embed
color or alpha transparency information?
Bernd: There's different color font formats and there's also
variable color fonts. There's a designer experimenting
with that. He almost has the same last name as I have,
but with an F, Arthur Folmer, he's doing really cool stuff with variable color fonts.
Herald: Microphone number four.
Thanks. Did you experiment with how having these changes within a longer text,
maybe changes reading?
Bernd: Yeah. I told you I was experimenting with the optical size axis and one
experiment I did early on when I was still working
at a big company. We thought we could improve reading
behavior based on optical size and how far the
person is away from the laptop. So we tried to
use head tracking and connect it to an optical
size axis. I don't know if you can imagine, but
like it constantly recalculates, so the text was
constantly reflowing. It was a complete mess.
It was a nice experiment, but it was a complete mess.
I don't know. Maybe someone else is smarter than me.
Herald: So final question from number one.
Bernd: Yeah, this seems like both a chance and a risk for accessibility.
Like for example, you can reshape as a user the font so that
it's easier to read when you have dyslexia or something.
But on the other side, maybe then you don't see that something is a
link anymore if you hover over it. Do you have any thoughts on that?
Yeah, I think all examples I showed were rather experimental, trying to trigger
the wish for experimentation rather than being super
accessible. I think it always depends on what you're
designing for. Keep your audience in mind. I want to
spark interest in design experimentation. I want to spark
interest in using variable fonts. There can be a
lot being done in that direction of legibility,
accessibility. But yeah, that's a whole nother topic, I think.