Google Releases Its New Google Sans Flex Font as Open Source
Key topics
The release of Google Sans Flex as open source has sparked a lively discussion about the merits of variable fonts, with commenters weighing in on the benefits and potential pitfalls of this versatile typography tool. Some users are thrilled about the flexibility offered by Google Sans Flex, particularly its 12-axis variable controls, while others note that Apple's SF font has already set a high bar for variable fonts, albeit with restrictive licensing. As commenters explore the font's capabilities, they're discovering innovative features like roundness control and debating the potential for over-tinkering with the numerous toggles available. With the added ability to fine-tune text, some are even joking that it could lead to an obsession with perfecting font styles, while others see it as a chance to create more expressive text components using CSS properties like `font-stretch`.
Snapshot generated from the HN discussion
Discussion Activity
Very active discussionFirst comment
41m
Peak period
98
0-12h
Avg / period
27.8
Based on 111 loaded comments
Key moments
- 01Story posted
Dec 12, 2025 at 1:07 PM EST
21 days ago
Step 01 - 02First comment
Dec 12, 2025 at 1:49 PM EST
41m after posting
Step 02 - 03Peak activity
98 comments in 0-12h
Hottest window of the conversation
Step 03 - 04Latest activity
Dec 19, 2025 at 3:10 PM EST
14 days ago
Step 04
Generating AI Summary...
Analyzing up to 500 comments to identify key contributors and discussion patterns
Want the full context?
Jump to the original sources
Read the primary article or dive into the live Hacker News thread when you're ready.
Has 12-axis of variables (whereas most only have 1 or 2)
https://fonts.google.com/specimen/Roboto+Flex/tester
> Apple restricts the usage of the typeface by others. It is licensed to registered third-party developers only for the design and development of applications for Apple's platforms. Only SF Pro, SF Compact, SF Mono, SF Arabic, SF Hebrew and New York variants are available for download on Developer website and they are the only SF variants allowed to be used by developers.
https://en.wikipedia.org/wiki/San_Francisco_(sans-serif_type...
I/O test for Sans Flex: https://snipboard.io/wXCQq5.jpg
It passes the O0 distinction but not the Il one
Ambiguous characters may have been acceptable in typefaces designed before 1990, but they are certainly not acceptable for any more recent design, unless the typeface is designed for a very specific and limited purpose, e.g. for a single advertising poster.
However, I see the worst offenders on various Web pages where I do not control the typeface, unless I instruct the browser to ignore the style sheet of the rendered Web page and use my own fonts instead, which can be tedious or create other problems in the rendered page.
I really can't imagine this is the thinking
But yeah this whole thing seems absurd of removing the distinguishing marks on things whose only purpose is to allow us to distinguish them.
While were at it N can become \ and M as well. D can become close paren. Q can become O.
And entire font of just vertical bar, horizontal bar, open paren, close paren, forward slash, backslash and a circle. Just think of how clean it would look...
https://fonts.google.com/specimen/Atkinson+Hyperlegible
https://wakamaifondue.com
Plug the TTF into there to see what toggles are available. Looks like there's also a magic sequence which renders the Google logo.
But how do you emphasize a lowercase 'l'? The only method I know is to make it cursive, which looks terrible.
(I don't really need to distinguish l from I, because I put serifs on I. But I do sometimes need to distinguish it from 1; in natural writing, 1 and l are identical.)
And of course in cursive I and l look nothing alike, no matter which cursive you write
Serif fonts solved this problem generations ago.
Serifs have appeared as a feature of the Latin letters of the inscriptions in stone of the Roman Empire, which are the model for the present capital letters.
On the other hand, the model for the present small letters are the letters of the manuscripts of the Carolingian Empire, written with pen (i.e. goose feather) on parchment.
The small letters originally did not have serifs. The small "l" letter had a right hook at its lower end, which distinguished it easily from an "I".
Serifs were added to the small letters, in imitation of the capital letters, only in the first books that were printed with "Antiqua" letters, in Italy, after the invention of printing.
The addition of a serif at the low end of "l" has lead to the removal of the right hook that it had previously. When sans-serif fonts were created in the 19th century, they have removed the serifs from the letters, so by removing the serifs from "I" and "l" they have become hard or impossible to distinguish.
The wiser typeface designers have realized that this is wrong and they have restored to small "l" the low right hook that it had at its origin in the Caroline script, distinguishing it from capital "I" even in a sans-serif font.
Unfortunately, too many sans-serif fonts have continued to perpetuate the mistake of removing the serifs from small "l" without restoring its original low right hook.
Therefore having non-ambiguous characters has been an explicit design requirement for them, at least since the Apple Monaco font.
I use Fira Code (like many) and it is very readable as well. But yours is indeed perfect
https://fonts.google.com/specimen/Atkinson+Hyperlegible
Mainly for its attention to detail. It’s careful to make it obvious when it matters. For example, O and 0, lower case L and 1, and others.
It's hyperlegible!
> No Modified Version of the Font Software may use the Reserved Font Name
And if you are fine changing the name, you might as well just type "Ubuntu" and discover you needn't modify Google's new font. I really don't see the point of designing a font that is worse than what's already out there
For instance, I set Inter[1] as my UI font in Obsidian, but I have set “Atkinson Hyperlegible Next”[2] as my Editor Font. I would gladly use such clean sans-serif fonts (Inter, Flex Sans, Geist, etc.)[3] because they are easy for the human eye to read quickly, even if there is a spelling error, and hence the distinction between the “O0 & Il” would not matter.
So, It Depends on the use case. “Atkinson Hyperlegible Next” is a fantastic, highly readable/recognizable font, but it will look pretty ugly when using it to design interfaces.
1. https://rsms.me/inter/
2. https://en.wikipedia.org/wiki/Atkinson_Hyperlegible
3. https://vercel.com/font
https://www.brailleinstitute.org/freefont/
https://github.com/googlefonts/atkinson-hyperlegible-next-mo...
https://fonts.google.com/specimen/Atkinson+Hyperlegible+Mono
Strongly agree on this, Bitwarden previously used a font that made passwords that contains i (or was it I?) and l difficult to distinguish.
(Yes, yes, I know about passphrases or multi-word passwords)
I think I needed ince to spell my password, and a chose a letters-only (small case) shorter one, or multi-word
I think the right answer here is to avoid including 1/I/l/O/0 in your tokens. For example, I'm pretty sure that Nintendo gift card codes can't contain those characters?
For me it comes up often as names of people or places, because those are more likely to be in a font that doesn’t distinguish and also there is no additional redundancy
Google Flex Sans supports font-feature-settings: "zero" - but doesn't seem to support lower-case l, upper-case I disambiguation.
I have this set as my OS default and also forced for all webpages, I just find it so clear and easy to read. On the occasion that I have to browse the web without it, I don't struggle per-say, but I definitely find that I have to read slower, and find myself rereading words more often.
-- Secretary of War ~~Pete Hegseth~~ Colin Jost.
I know I've seen Mozilla proudly pat themselves on the back in their announcement of anti-racist Firefox themes
This font fails hard.
I recently compared it once more to others – https://www.programmingfonts.org/ makes it easy to narrow down to your favourites one by one ... JetBrains Mono still wins. :)
https://github.com/be5invis/Iosevka
It takes a day or so to get used to the condensed form factor, but after that you can enjoy much more horizontal space in your terminal windows.
There is one downside: all the other fonts will look bulky :)
You can see it in action here:
https://www.programmingfonts.org/#iosevka
(and then put your finger on the last line and select another font)
But you are inspiring me to give it another go. Thanks.
They are beautiful fonts and are often updated, too. Clearly a lot care goes into their crafting.
Ubuntu Mono remains undefeated for now for me though.
While there are a few other programming fonts with a very similar quality, for myself JetBrains Mono has a distinctive advantage: it includes a much greater character set than any other good programming font that I have ever tested (DejaVu Sans Mono also has a big character set, but it is definitely uglier), for instance it has a lot of mathematical symbols that I need.
https://www.codingfont.com/
I like using silly fonts, e.g. Comic Sans Mono has been my daily driver for the past year or so, and it's really fun to see the Minecraft fonts and old DOS and VT323 fonts. If anyone's into retro computing, it's worth checking those out, particularly the website link for the IBM VGA 9x16, which has loads and loads more old fonts.
I think I'll try using Monocraft in the shell for a while and see if it works well for me, though I might stick to Comic Sans for actual coding :)
However, the general movement toward redistributable and license-friendly fonts is wonderful and I'm very happy to see it continue. As someone who has had to deal with font licensing hell in the past, having these available is a huge improvement. Even just setting up my personal linux systems and having actually usable fonts available is a massive improvement, before even getting into trying to build apps/websites/etc. Many thanks to Google and any others who are releasing these!
[1]: https://news.ycombinator.com/item?id=46247559 [2]: https://news.ycombinator.com/item?id=46247693
This is a feature that few, if any, open source typefaces possess.
Being open source, the same techniques can be reused in the design of another parametrized font, with less ambiguous glyphs.
Now I want to see a rounded terminal (as in command-line apps, not terminals in letters.) Would I type in a circle? Sounds cool.
That is why Microsoft Windows has included such a rounded font for the Korean script: Gulim. On Windows, if you want to render a text with Latin letters with rounded ends, you can use Gulim for the normal text, coupled with Arial Round for the bold text.
On MacOS, there was a Hiragino Maru Gothic rounded font for Japanese (where also the Latin letters are rounded). I no longer use Apple computers, so I do not know whether the Hiragino fonts have remained the fonts provided for Japanese.
No really, I'm not trying to be edgy. Does the font we're using to read a document matters??
Last time I checked, scientist agreed that the best for an average user is the font you're used to. Serif, sans serif,.. didn't matter. Just keep using the one you always used.
So I don't get why every so often, Google work on a new font. Pick one and stick to it, user don't care.
Or am I missing something ?
BTW, personnel opinion but the only fonts i found to really look better than anything else were apple fonts. They don't make things easier to read but they just look so nice whereas Google always feel meh.
But am I the only one who actually prefers both to be relatively identical? Or at least the lowercase L must not have any quiggles or crooks? I like em both north-south. 12:30.
I think typically the I will be a little thicker than the i for regular (text? roman?) weights and below.
I hate it in UX because it's so "geometric" -- works well for a logo, but not body text, so it's just a bizarre choice for UX. Unlike Roboto which continues to be great for that. (Google Sans is fine as display text though -- headings, logo, etc.)
But my understanding was that Google wanted to differentiate its first-party apps from other Android apps with a proprietary Google font.
But now they're opening that font up for everyone to use, so Google's apps will no longer look uniquely Google-branded.
I'm so confused what the heck is going on over there in Mountain View.
https://github.com/googlefonts/googlesans-code
https://coldtype.goodhertz.com/introduction.html