Massive lag due to Font.CacheFontForText. Please help!

You can try to create dummy text during your level load time to make sure the dynamic caching does it work then and not at some other importunate times?

If not, you can try "TextMesh Pro", it is optimize to do little to no run-time allocation. Once your font is loaded, you are pretty much guarantied to be alloc free.

And loading a font is also extremely efficient as its using very compact SDF atlas.

For anyone else who encounters this same issue, here is another solution you could consider. I ran into the same problem as a result of using custom GUIStyle objects for rendering in my OnGUI calls, some of which referenced custom dynamic fonts (this is the source of the problem - dynamic font glyphs get cached to an internal font cache texture in Unity).

To avoid taking the big hit all at once when Font.CacheFontForText() is first called by means of an OnGUI call, inside an Awake() call for my UI code I spin up a coroutine to asynchronously precache each of my dynamic fonts' glyph data, making repeated calls to Font.RequestCharactersInTexture(). This has worked nicely so far for my relatively simple UI needs, and avoids having one giant blocking stall where the GUI font cache is populated all at once.

Here is some sample code to illustrate the basic approach I used:

 public class GUIClass : MonoBehaviour
 {
     private static readonly string kPrecacheFontGlyphsString= "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\\:;\"'<>,.?/ ";
     
     // utility struct used in font caching
     struct CacheFont
     {
         public Font theFont;
         public int size;
         public FontStyle style;
     };
     
     void Awake()
     {
         // gather custom fonts that we will be using
         CacheFont[] myCustomFonts= RetrieveMyCustomFonts();
 
         if (null != myCustomFonts)
         {
             for (int fontIndex= 0; fontIndex < myCustomFonts.Length; ++fontIndex)
             {
                 StartCoroutine(PrecacheFontGlyphs(
                     myCustomFonts[fontIndex].theFont,
                     myCustomFonts[fontIndex].fontSize,
                     myCustomFonts[fontIndex].fontStyle,
                     kPrecacheFontGlyphsString));
             }
         }
         
         return;
     }
 
     // Precache the font glyphs for the given font data.
     // Intended to run asynchronously inside of a coroutine.
     IEnumerator PrecacheFontGlyphs(Font theFont, int fontSize, FontStyle style, string glyphs)
     {
         for (int index= 0; (index < glyphs.Length); ++index)
         {
             theFont.RequestCharactersInTexture(
                 glyphs[index].ToString(),
                 fontSize, style);
             yield return null;
         }
         
         yield break;
     }
 
 
     void OnGUI()
     {
         // now that dynamic font glyphs have been precached,
         // there won’t be a terrible hitch the first time this is called
     }
 };