How do I get the font name from an otf or ttf file?

I have used a custom font in my previous app.

The file name was "ProximaNova-Regular.otf" and to load the font I just used...

[UIFont fontWithName:@"ProximaNova-Regular" size:20];

This worked perfectly.

Now in this new app I have three font files...

Dude_Willie.otf
Impact
handsean.ttf

But I'm not sure how to load these.

I have tried

[UIFont fontWithName:<the file name> size:20];

But this just falls back to using Helvetica.

How can I find what name to use?

Right click on the TTF -> Get Info

"Full Name" is what you're looking for.

That's what worked for me with TTFs.

Edit:

I just used a font that had a different name from the "Full Name" in Get Info.

For the compilation of this answer, If the quick check above doesn't work, run this code in your project:

for (NSString *fontFamilyName in [UIFont familyNames]) {
    for (NSString *fontName in [UIFont fontNamesForFamilyName:fontFamilyName]) {
        NSLog(@"Family: %@    Font: %@", fontFamilyName, fontName);
    }
}

And search for the correct name of the font you want to use.

Swift 3.0 code:

for fontFamilyName in UIFont.familyNames{
    for fontName in UIFont.fontNames(forFamilyName: fontFamilyName){
        print("Family: \(fontFamilyName)     Font: \(fontName)")
    }
}

Follow these four easy steps to add and use a new font in your iOS app:

• Add your_new_font.ttf or your_new_font.otf to your Xcode project
• In your project's info.plist, add a new entry for your_new_font.ttf or your_new_font.otf to the UIAppFonts array (plain text for this one is 'Fonts provided by application')
• At this point, I recommend adding this temporary chunk of debug code to dump all fonts that are accessible by your app, including your newly added your_new_font:

//Swift

    for family: String in UIFont.familyNames {
        print("\(family)")
        for names: String in UIFont.fontNames(forFamilyName: family) {
            print("== \(names)")
        }
    }

//Objective-c

for(NSString *fontfamilyname in [UIFont familyNames]) {
    NSLog(@"family:'%@'",fontfamilyname);
    for(NSString *fontName in [UIFont fontNamesForFamilyName:fontfamilyname]) {
        NSLog(@"\tfont:'%@'",fontName);
    }
    NSLog(@"-------------");
}

• In the debug output, look for your new font's 'family' and 'font' name. Pass whatever is displayed as the 'font' name corresponding to your new font family (there could be more than one 'font' associated with your new font 'family') to UIFont *myNewFont = [UIFont fontWithName:@"font_name_from_debug_output" size:20] and you should be in business!

• Install the font
• Open Font Book app on your Mac
• Select the font and click on 'info' button
• The name you're looking for is PostScript name
  • MacOS: View -> Show Font Info

To use fonts in iOS, you have to load the font based on the font's FULL NAME (PostScript Name), which is sometimes (and usually is) different from the font's actual FILE NAME.

Imagine yourself renaming the Font file "Arial-regular.ttf" to be "foo.ttf". The font contained inside the font file you just renamed is still "Arial-regular".

There are some good programmatic ways to get the font name already on this thread, but I have a different approach using the command line.

If you are on a Mac or Linux, simply run this script from the command line in the directory where you have your custom fonts (uses the fc-scan utility from fontconfig which is probaly already installed, but if not you can install it via homebrew: brew install fontconfig):

for file in "$arg"*.{ttf,otf}; do fc-scan --format "%{postscriptname}\n" $file; done

Here is a screenshot of the above command running on my ~/Library/Fonts directory:

The script above will run through all the .ttf and .otf files in the current directory, then print out the PostScript Name for each font which you can use to reference the font file in XCode or elsewhere.

If you want to get fancy with some additional information (PostScriptName, Filename) and some color coding, you can run this alternative script:

for file in "$arg"*.{ttf,otf}; do 
    postscriptname=$(fc-scan --format "%{postscriptname}\n" $file);
    printf "\033[36m PostScript Name:\033[0m %s \e[90m(%s)\033[0m\n" "$postscriptname" "$file";
done

This is a bit faster than copy-pasting code inside of your AppDelegate.m file to print out the names every time you want to add a new font file, which is the popular method, and it's also faster than opening the Font in FontBook to inspect the PostScript Name.

USEFUL TIP: If you alias the above script in your terminal so that all you need to do is type a single command to get all the PostScript font names for all the files in the current directory (my function is called fontnames so all I have to do is type fontnames at the terminal inside the directory with fonts in it, and the PostScript names will be printed automatically, then you will save time in your development workflow and have this handy script ready to use when you need it.

Hope this helps!