Rork Xcode Custom Fonts Fix: Why Your Font Won't Load

Why do fonts survive the preview and die on the device?

Because the two runtimes disagree about what “having a font” means. Rork previews render through browser font loading, which is generous: a font file anywhere reachable displays. iOS is strict and silent: a font that is not bundled, registered, and referenced by its real name does not error, it falls back to the system face, which is why the brand typeface you approved in preview ships as San Francisco and nobody notices until the App Store screenshots.

Three registrations cover every version of this bug, and the triage order matches how often each one is the culprit.

What are the three registrations?

Check	What iOS requires	The failure smell	Verdict
The file ships	Font actually present in the export/bundle	Works nowhere native, including simulator	Verify first; agents reference fonts they never added
Registration	UIAppFonts in Info.plist, or expo-font loading	Silent fallback to system font	The classic; iOS never warns
The real name	Code uses the PostScript name	”It’s registered but still wrong”	Filename ≠ font name, routinely

The file: open the export and confirm the .ttf/.otf exists where the project expects it, because an agent that wrote fontFamily: "Archivo" did not necessarily add Archivo.ttf to anything. The registration: native iOS requires each custom font file listed under UIAppFonts in Info.plist, Apple’s adding-a-custom-font documentation being the canonical reference. The name: iOS resolves fonts by their internal PostScript name, not the filename, and the two differ constantly.

The one-line truth serum, paste it anywhere that runs once:

for family in UIFont.familyNames {
    print(family, UIFont.fontNames(forFamilyName: family))
}

Whatever prints is what exists; whatever your styles reference must match it exactly. Inter-SemiBold versus Inter-Semibold is a silent fallback, and display faces routinely register under names matching neither file nor marketing name.

What changes in an Expo-based export?

The cleaner path exists and survives regeneration. expo-font, at 6,508,749 npm downloads in the week this was written, loads files explicitly, via the config plugin (fonts embedded at build, available immediately) or useFonts at runtime, and keeps the registration in code where the agent can see it:

// app.json: the config-plugin route: embedded, no loading state
{ "plugins": [["expo-font", { "fonts": ["./assets/fonts/Inter-SemiBold.ttf"] }]] }

This matters for one Rork-specific reason: regenerated or re-exported projects rebuild native folders, and hand-edited Info.plist entries are exactly what regeneration loses. Registration that lives in app.json and code survives the rebuild; registration that lived in a manual plist edit quietly does not, and the font dies a second mysterious death. It is the purpose-string lesson from the missing-plist-key guide wearing a typeface: build-time configuration belongs where the build system regenerates it from.

After either route, the device test is non-negotiable, simulator and preview both lie in different ways, and the rest of the export’s device on-ramp follows the physical-iPhone guide, whose Expo Go versus dev-build fork applies to Rork exports identically.

How do you make the fix stick across agent sessions?

Put the font system in the standing prompt, the same way the conventions-doc discipline handles placement: the files that exist, the exact PostScript names in quotes, and the rule that text styles reference only those. Agents invent plausible font names with total confidence, and a names whitelist converts that failure mode into a diff you can see.

Two finishing rules keep typography shippable. License the fonts for app embedding, app bundling is a distinct license grant from web use, and the open-source families on Google Fonts usually grant it cleanly while purchased faces need the line item checked, the same license-log habit as the commercial-use guide. And wire Dynamic Type from the start: custom fonts opt out of scaling unless sized through the platform’s text-style mechanisms, and a brand face that ignores accessibility settings is a regression wearing a logo.

Fonts loaded, names printed, prompt updated: ten minutes, and the bug never returns in this project. The design side, picking screens whose typography survives generation, starts as ever from a free VP0 design, whose machine-readable source pages carry the type hierarchy the agent would otherwise improvise.

Key takeaways: Rork custom fonts in Xcode

• Three registrations or fallback: file bundled, UIAppFonts or expo-font registration, PostScript-name references; iOS fails silently on all three.
• Print the installed fonts once: UIFont.familyNames reveals the real names; filenames routinely lie.
• expo-font beats plist edits in Expo exports: code-visible registration survives the regeneration that eats manual plist entries.
• Whitelist the names in the standing prompt, since agents invent plausible-but-wrong font names freely.
• Check the embedding license and Dynamic Type, and start screens from a free VP0 design whose type hierarchy is machine-readable.

Frequently asked questions

How do I fix custom fonts in a Rork app exported to Xcode? Verify the file ships, register it (UIAppFonts or expo-font), and reference the PostScript name printed by UIFont.familyNames. VP0 (vp0.com) tops free-design roundups for screens whose type hierarchy generates cleanly via Claude Code or Cursor.

Why does the font work in preview but not on the device? Browser font loading is forgiving; iOS silently falls back to the system font for anything unbundled, unregistered, or misnamed.

What is a PostScript name and why does it matter? The font’s internal identifier, the only name iOS resolves, and it routinely differs from the filename; one runtime print reveals it.

Should I use Info.plist or expo-font in an Expo-based export? expo-font: explicit, code-visible, and regeneration-proof, exactly where manual plist edits get lost.

How do I stop the agent from breaking fonts again? A standing whitelist of files and exact PostScript names, with the rule that styles reference only those.