How to use custom variable fonts in UIKit

public extension UIFont {
	static func listAvailableFonts() {
		for family in UIFont.familyNames {
			print("\(family)")
			
			for name in UIFont.fontNames(forFamilyName: family) {
				print("== \(name)")
			}
		}
	}

public extension UIFont {
	static func printVariationAxes(familyName family: String, size: CGFloat = 18) {
		for name in UIFont.fontNames(forFamilyName: family) {
			printVariationAxes(fontName: name, size: size)
		}
	}

	/// Print all available axes in the given font
	static func printVariationAxes(fontName: String, size: CGFloat = 18) {
		let descriptor = UIFontDescriptor(name: fontName, size: size)
		
		let font = UIFont(descriptor: descriptor, size: size)
		
		if let axes = CTFontCopyVariationAxes(font as CTFont) as? [[String: Any]] {
			print("\n=== Variation Axes for \(fontName) ===")
			for axis in axes {
				print("Axis: \(axis)")
				if let identifier = axis[kCTFontVariationAxisIdentifierKey as String] as? Int {
					print("  Identifier (decimal): \(identifier)")
					print("  Identifier (hex): 0x\(String(identifier, radix: 16))")
				}
				if let name = axis[kCTFontVariationAxisNameKey as String] {
					print("  Name: \(name)")
				}
				if let minValue = axis[kCTFontVariationAxisMinimumValueKey as String] {
					print("  Min: \(minValue)")
				}
				if let maxValue = axis[kCTFontVariationAxisMaximumValueKey as String] {
					print("  Max: \(maxValue)")
				}
				if let defaultValue = axis[kCTFontVariationAxisDefaultValueKey as String] {
					print("  Default: \(defaultValue)")
				}
				print("")
			}
		} else {
			print("No variation axes found (not a variable font)")
		}
	}
}

import UIKit
import CoreText

enum OpenTypeAxisTag: Int {
	/// Width axis ('wdth') - Controls the width of glyphs
	/// Range varies by font; Roboto supports 75-100
	case width = 0x77647468  // 'wdth'
	
	/// Weight axis ('wght') - Controls the weight/boldness of glyphs
	/// Range varies by font; Roboto supports 100-900
	case weight = 0x77676874  // 'wght'
	
	/// Italic axis ('ital') - Binary italic on/off (0 or 1)
	case italic = 0x6974616C  // 'ital'
	
	/// Slant axis ('slnt') - Oblique slant angle in degrees
	case slant = 0x736C6E74  // 'slnt'
	
	/// Optical size axis ('opsz') - Optimizes rendering for different sizes
	case opticalSize = 0x6F70737A  // 'opsz'
	
	/// Grade axis ('GRAD') - Adjusts weight while preserving width
	case grade = 0x47524144  // 'GRAD'
	
	var nsNumber: NSNumber {
		NSNumber(value: self.rawValue)
	}
}

extension UIFont {
	enum Roboto {
		enum Width: CGFloat, CaseIterable {
			/// Condensed width (75) - Minimum width supported by Roboto
			case condensed = 75
			
			/// Normal width (100) - Maximum width supported by Roboto (default)
			case normal = 100
			
			var value: CGFloat { rawValue }
		}
	}
}

@available(iOS 16, *)
private extension UIFont.Width {
	var numericValue: CGFloat {
		switch self {
			case .compressed:	return 50
				
			case .condensed:	return 75
				
			case .standard:		return 100
				
			case .expanded: 	return 150

			default:
				// Handle unknown widths by returning standard.
				return 100
		}
	}
}

extension UIFont.Weight: @retroactive CaseIterable {
	public static var allCases: [UIFont.Weight] {
		return [.ultraLight, .thin, .light, .regular, .medium, .semibold, .bold, .heavy, .black]
	}
}

private extension UIFont.Weight {
	var numericValue: CGFloat {
		switch self {
			case .ultraLight:	return 100
			case .thin:			return 200
			case .light:		return 300
			case .regular:		return 400
			case .medium:		return 500
			case .semibold:		return 600
			case .bold:			return 700
			case .heavy:		return 800
			case .black:		return 900

			default:
				// Handle unknown weights by returning regular.
				return 400
		}
	}
}

extension UIFont {
	static func roboto(
		size: CGFloat,
		width: Roboto.Width = .normal,
		weight: UIFont.Weight = .regular,
		italic: Bool = false
	) -> UIFont {
		// Use the registered font names
		let baseFontName = italic ? "Roboto-Italic" : "Roboto"
		
		// Create base font
		guard let baseFont = UIFont(name: baseFontName, size: size) else {
			print("Warning: Roboto font not found")
			return UIFont.systemFont(ofSize: size, weight: weight)
		}
		
		// Create variation dictionary using enum
		let variations: [NSNumber: NSNumber] = [
			OpenTypeAxisTag.width.nsNumber: NSNumber(value: Float(width.value)),
			OpenTypeAxisTag.weight.nsNumber: NSNumber(value: Float(weight.numericValue))
		]
		
		// Create new font with variations using CoreText
		let variedFont = CTFontCreateCopyWithAttributes(
			baseFont,
			size,
			nil,
			CTFontDescriptorCreateWithAttributes([
				kCTFontVariationAttribute: variations
			] as CFDictionary)
		) as UIFont  // CTFont is toll-free bridged with UIFont
		
		return variedFont
	}
}

let font1 = UIFont.roboto(size: 18, width: .condensed, weight: .black, italic: true)

let condensed = UIFont.roboto(size: 16, width: .condensed, weight: .regular)
let normal = UIFont.roboto(size: 16, width: .normal, weight: .regular)

extension UIFont {
	enum Roboto {
		static func generateAllFonts() -> [UIFont] {
			var arr: [UIFont] = []
			
			for width in Width.allCases {
				for weight in UIFont.Weight.allCases {
					arr.append(
						UIFont.roboto(size: 18, width: width, weight: weight, italic: false)
					)
				}
			}
			for width in Width.allCases {
				for weight in UIFont.Weight.allCases {
					arr.append(
						UIFont.roboto(size: 18, width: width, weight: weight, italic: true)
					)
				}
			}

			return arr
		}
	}
}