Getting and using installed system font family members

lostminds · February 5, 2025, 4:16pm

Godot Version

4.3

Question

I’m trying to build a font selector where the user can use pick between installed systems fonts to use.

Using OS.get_system_fonts() I can get a list of all installed font family names on the system. However, the issue I’m running into is that this is just the first step to picking a font. Each such font family usually has a number of style variations (from 1 up to 12), like Bold, Italic, This, Regular, Roman, Semi-Bold etc. And to identify and select a specific font you need to know both the font family name and the style name. For example “Roboto Light Italic”. However, I’ve found no way of finding what style members each font family has.

Given a font family name from the OS.get_system_fonts() list (like “Roboto”), is there a way to get what style variations are available for this font family?

The way to use a system font is then via the SystemFont class, which works sort of like a query where you can assign a number of font_names (family names) and traits (like font_italic and font_weight values). But it works with fallbacks, so if no match is found you get the closest fallback instead of nothing. And there seems to be no way of getting them by their style name (like “Thin”, “Roman” or “Semi-bold”)? So if you were able to get the names of the style members of a font family, how would you get that specific system font?

lostminds · February 6, 2025, 8:54pm

After a little more research it seems this is not currently possible to do in Godot. So I’ve added a proposal for an addition to SystemFont to support specifying font style names and getting a list of available such styles per font family.

You can support the proposal or contribute to the discussion here:

github.com/godotengine/godot-proposals

Add style_name support to SystemFont to allow using specific members of font families

opened 06:38PM - 06 Feb 25 UTC

lostminds

### Describe the project you are working on A non-game application where the us…er can select fonts from the system to use in the application ### Describe the problem or limitation you are having in your project With the addition of https://github.com/godotengine/godot/pull/62973 we now have support for accessing fonts installed on the system via the [SystemFont](https://docs.godotengine.org/en/stable/classes/class_systemfont.html) class. And we can get a list of the names of the installed fonts via [OS.get_system_fonts()](https://docs.godotengine.org/en/stable/classes/class_os.html#class-os-method-get-system-fonts). However, a limitation to this is that the list only provides the font family names of the installed fonts (such as "Roboto" or "Arial") but there is no way to get the names of the members of the font family, for example Thin, Italic, Semi-Bold, Bold-Italic etc. Below is an example of the font family Roboto as seen in the macOS font manager. ![Image](https://github.com/user-attachments/assets/fde58d05-c50e-4fde-8058-3fd4ff465cbc) When loading a font from file, this name is accessible via [get_style_name()](https://docs.godotengine.org/en/stable/classes/class_font.html#class-font-method-get-font-style-name) so to keep with this convention I'll call this name `style_name` from now on. However, there is no way to specify this `style_name` in SystemFont to access a specific font version. Instead, what you can do is specify `font_weight` or `font_italic` to try and find bold or italic style versions. There is also no way to get what style_name members a font family has (could be just one or twelve, with various names), which makes it impossible to present a selector interface to select available system fonts where you can also show and pick the different variations of each font. ### Describe the feature / enhancement and how it helps to overcome the problem or limitation First complement the existing `OS.get_system_fonts()` with a new `OS.get_system_font_style_names(font_family_name)` which would return an array containing the style names of all members of the installed font identified with the font family name (if any). Second, extend the SystemFont class with a `font_style_names` property. This would work together with the [font_names](https://docs.godotengine.org/en/stable/classes/class_systemfont.html#class-systemfont-property-font-names) property to pick which font family member is selected and used by SystemFont. If `font_style_names` is set this should be used first and the `font_weight`, `font_italic` etc properties are disregarded if a match is found in the `font_style_names` array. However, in the spirit of the current implementation they could still be used as fallbacks. So for example if you specify a `style_names` "Thin" and `font_weight` 100 this could fall back to some other light style with low weight if no style named "Thin" is found. ### Describe how your proposal will work, with code, pseudo-code, mock-ups, and/or diagrams To get and populate a font selector list you could do something like: ``` var font_family_names:PackedStringArray = OS.get_system_fonts() var font_style_names:PackedStringArray for font_family_name:String in font_family_names: font_style_names = OS.get_system_font_style_names(font_family_name) # add selector items / sub-items based on font_family_name and font_style_names ``` To use a specific font style, for example Roboto Thin Italic you would then use: ``` var robotoFont:SystemFont = SystemFont.new() robotoFont.font_names = ["Roboto"] robotoFont.font_style_names = ["Thin Italic"] ``` or some user-selected font version using ``` var userFont:SystemFont = SystemFont.new() userFont.font_names = [selected_font_family_name] userFont.font_style_names = [selected_font_style_name] ``` ### If this enhancement will not be used often, can it be worked around with a few lines of script? No, it's currently not possible to get a list of installed font family members, at least not via the Godot font system. Possibly you could try getting paths to the system font files and try to list the files in these directories and try guess based on the filenames. But this seems inefficient and prone to errors. It is also not possible to select a specific known font style member of an installed system font. In simple cases (like if there's a "Bold" style) it could be selected by setting the font family name as SystemFont `font_names` and setting `font_weight` to a guessed value of what the "Bold" style would have. But this will be increasingly difficult with style names like "Semi-Bold", "Book", "Roman", "Caption", "Display" etc that may not just refer to weight (and you don't know if they exist for this font). ### Is there a reason why this should be core and not an add-on in the asset library? Both SystemFont and the OS.get_system_fonts() function are core components, and the proposed support for getting and specifying font_style_names I think would allow them to be used as I think the original intention with the features was.

logM · October 18, 2025, 4:39pm

Hello! Sorry to necro an old topic - I am in the same boat as you, trying to make an application in Godot that would benefit from a system font picker. I read over the GitHub discussion and it seems there aren’t any great options at the moment.

I just wanted to ask if you’ve found a solution to your font picker problems. There seem to be precious few resources on the topic, so I’m curious if you’ve found a workaround or managed to build something that works well enough.

lostminds · October 18, 2025, 5:46pm

No, unfortunately not. My initial research about it basically ended in realizing this was a limitation in Godot that was hard to get around, and me writing that proposal to get a discussion started. I’d still like this functionality, but I’ve since then just put it on the backlog and concentrated on other features.

If you’re going to make a try for it I did think of a couple of different approaches that I might try if I get back to this, maybe you could get some inspiration from these. In all these cases I’m thinking of periodically (like at startup) somehow building up my own database of installed system fonts with font variants.
To do this some possible options could be:

Use the Godot supplied list of font family names OS.get_system_fonts(), and then iterate over different common style names with SystemFont to see if any of them return a different font (meaning these fonts styles exist). The drawbacks are kind of obvious, and it’s probably both very slow and resource wasteful, but it’s quite easy to build and should get most installed font versions if you test enough common style names.
Use the Godot system font access to get access to the system font paths, then use file system access to try and find all font files in this location and from there try to get the installed different fonts. Not sure how/if this would work, but it’s a different approach at least.
Try to build a custom C# font manager that uses either built in .net system font access (if that exists) or some cross-platform system font C# library or .net module, and get access to the system font list with style variants that way bypassing the Godot font system.
And a forth approach I just thought of now: You might be able to get the installed fonts via command line tools. On linux there’s apparently a command fc-list, and on macOS there’s atsutil fonts -list if there’s one on windows as well that could be used to get the available fonts. Found Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts' might work on windows, but haven’t tested it (yet).

Let me know if you try any of these or if you figure out some other way.