How to Deploy Custom Fonts to Windows Devices Using Microsoft Intune

First, you need Microsoft's official packaging tool to convert your font deployment into an Intune-compatible package.

Navigate to the official Microsoft GitHub repository and download the latest Win32 Content Prep Tool:

# Download from: https://github.com/Microsoft/Microsoft-Win32-Content-Prep-Tool
# Extract IntuneWinAppUtil.exe to C:\Tools\Intune

Create a working directory for your font deployment project:

New-Item -Path "C:\FontDeployment" -ItemType Directory -Force
New-Item -Path "C:\FontDeployment\fonts" -ItemType Directory -Force

Create the main installation script that will copy fonts to the Windows Fonts directory and register them in the system registry.

Create installfonts.ps1 in your FontDeployment directory:

# installfonts.ps1
$ErrorActionPreference = "Stop"
$LogPath = "C:\Windows\Temp\FontInstall.log"

# Start logging
Start-Transcript -Path $LogPath -Append

try {
    # Get all font files from the fonts subdirectory
    $fonts = Get-ChildItem -Path ".\fonts" -Include *.ttf,*.otf -Recurse
    $fontRegPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"
    
    Write-Host "Found $($fonts.Count) font files to install"
    
    foreach ($font in $fonts) {
        $fontName = [System.IO.Path]::GetFileNameWithoutExtension($font.Name)
        $fontFileName = $font.Name
        $destinationPath = "C:\Windows\Fonts\$fontFileName"
        
        # Check if font already exists
        if (-not (Test-Path $destinationPath)) {
            Write-Host "Installing font: $fontName"
            
            # Copy font file to Windows Fonts directory
            Copy-Item $font.FullName $destinationPath -Force
            
            # Register font in registry
            $regName = "$fontName (TrueType)"
            if ($font.Extension -eq ".otf") {
                $regName = "$fontName (OpenType)"
            }
            
            New-ItemProperty -Path $fontRegPath -Name $regName -Value $fontFileName -PropertyType String -Force
            Write-Host "Registered font: $regName"
        } else {
            Write-Host "Font already installed: $fontName"
        }
    }
    
    # Create success marker
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    "Font installation completed successfully at $timestamp" | Out-File "C:\Windows\Temp\FontInstallSuccess.txt" -Force
    
    Write-Host "Font installation completed successfully"
    exit 0
    
} catch {
    Write-Error "Font installation failed: $($_.Exception.Message)"
    exit 1
} finally {
    Stop-Transcript
}

Create the uninstallation script that removes fonts and cleans up registry entries when the app is uninstalled.

Create uninstallfonts.ps1 in your FontDeployment directory:

# uninstallfonts.ps1
$ErrorActionPreference = "Stop"
$LogPath = "C:\Windows\Temp\FontUninstall.log"

# Start logging
Start-Transcript -Path $LogPath -Append

try {
    # Define your custom fonts to remove (customize this list)
    $customFontNames = @(
        "YourCompanyFont-Regular.ttf",
        "YourCompanyFont-Bold.ttf",
        "YourCompanyFont-Italic.ttf"
        # Add more font filenames as needed
    )
    
    $fontRegPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"
    
    foreach ($fontFileName in $customFontNames) {
        $fontPath = "C:\Windows\Fonts\$fontFileName"
        $fontName = [System.IO.Path]::GetFileNameWithoutExtension($fontFileName)
        
        # Remove font file
        if (Test-Path $fontPath) {
            Remove-Item $fontPath -Force
            Write-Host "Removed font file: $fontFileName"
        }
        
        # Remove registry entries
        $regEntries = Get-ItemProperty -Path $fontRegPath | Get-Member -MemberType NoteProperty | Where-Object { $_.Name -like "*$fontName*" }
        
        foreach ($entry in $regEntries) {
            try {
                Remove-ItemProperty -Path $fontRegPath -Name $entry.Name -ErrorAction SilentlyContinue
                Write-Host "Removed registry entry: $($entry.Name)"
            } catch {
                Write-Warning "Could not remove registry entry: $($entry.Name)"
            }
        }
    }
    
    # Remove success marker
    Remove-Item "C:\Windows\Temp\FontInstallSuccess.txt" -Force -ErrorAction SilentlyContinue
    
    Write-Host "Font uninstallation completed successfully"
    exit 0
    
} catch {
    Write-Error "Font uninstallation failed: $($_.Exception.Message)"
    exit 1
} finally {
    Stop-Transcript
}

The detection script tells Intune whether the fonts are successfully installed on the target device. This is crucial for proper deployment monitoring.

Create DetectionCheck.ps1 in your FontDeployment directory:

# DetectionCheck.ps1
$ErrorActionPreference = "SilentlyContinue"

# Define your font files to check (must match your actual font files)
$requiredFonts = @(
    "YourCompanyFont-Regular.ttf",
    "YourCompanyFont-Bold.ttf",
    "YourCompanyFont-Italic.ttf"
)

$allFontsInstalled = $true
$fontRegPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"

foreach ($fontFile in $requiredFonts) {
    $fontPath = "C:\Windows\Fonts\$fontFile"
    $fontName = [System.IO.Path]::GetFileNameWithoutExtension($fontFile)
    
    # Check if font file exists
    if (-not (Test-Path $fontPath)) {
        $allFontsInstalled = $false
        break
    }
    
    # Check if font is registered
    $regEntries = Get-ItemProperty -Path $fontRegPath -ErrorAction SilentlyContinue
    $fontRegistered = $false
    
    foreach ($property in $regEntries.PSObject.Properties) {
        if ($property.Name -like "*$fontName*" -and $property.Value -eq $fontFile) {
            $fontRegistered = $true
            break
        }
    }
    
    if (-not $fontRegistered) {
        $allFontsInstalled = $false
        break
    }
}

# Check for success marker file
$successMarker = Test-Path "C:\Windows\Temp\FontInstallSuccess.txt"

if ($allFontsInstalled -and $successMarker) {
    Write-Host "All fonts are properly installed and registered"
    exit 0  # Success
} else {
    Write-Host "Fonts are not properly installed"
    exit 1  # Not installed
}

Now organize your font files and scripts into the proper structure for packaging.

Copy your custom font files to the fonts subdirectory:

# Copy your .ttf and .otf files to the fonts directory
Copy-Item "C:\Path\To\Your\Fonts\*.ttf" "C:\FontDeployment\fonts\" -Force
Copy-Item "C:\Path\To\Your\Fonts\*.otf" "C:\FontDeployment\fonts\" -Force

Verify your directory structure looks like this:

C:\FontDeployment\
├── fonts\
│   ├── YourCompanyFont-Regular.ttf
│   ├── YourCompanyFont-Bold.ttf
│   └── YourCompanyFont-Italic.ttf
├── installfonts.ps1
├── uninstallfonts.ps1
└── DetectionCheck.ps1

Check the total package size:

# Check package size (should be under 8GB for Win32 apps)
$size = (Get-ChildItem "C:\FontDeployment" -Recurse | Measure-Object -Property Length -Sum).Sum / 1MB
Write-Host "Package size: $([math]::Round($size, 2)) MB"

Use Microsoft's Win32 Content Prep Tool to create the .intunewin package that Intune can deploy.

Open an elevated Command Prompt and navigate to your tools directory:

cd C:\Tools\Intune

Run the packaging command:

IntuneWinAppUtil.exe -c "C:\FontDeployment" -s "installfonts.ps1" -o "C:\FontDeployment\Output" -q

The parameters mean:

• -c: Source folder containing all files
• -s: Setup file (main installation script)
• -o: Output directory for the .intunewin file
• -q: Quiet mode (minimal output)

The tool will create installfonts.intunewin in the Output directory.

Get-ChildItem "C:\FontDeployment\Output\*.intunewin" | Select-Object Name, Length, CreationTime

Now create the Win32 app in the Microsoft Intune admin center and configure its deployment settings.

Navigate to the Intune admin center:

1. Go to Apps > Windows > Add
2. Select Windows app (Win32)
3. Click Select app package file and upload your installfonts.intunewin file

Configure the app information:

• Name: "Company Custom Fonts"
• Description: "Deploys custom company fonts to Windows devices"
• Publisher: Your company name
• Category: Business (optional)

In the Program tab, configure these commands:

Install command:
%windir%\sysnative\windowspowershell\v1.0\powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -File "installfonts.ps1"

Uninstall command:
%windir%\sysnative\windowspowershell\v1.0\powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -File "uninstallfonts.ps1"

Set these additional program settings:

• Device restart behavior: No specific action
• Return codes: Keep default (0 = Success, 1707 = Success with restart)
• Install behavior: System

Set up the detection method and system requirements for your font deployment.

In the Requirements tab:

• Operating system architecture: x64, x86
• Minimum operating system: Windows 10 1909
• Disk space required: Calculate based on your font files (typically 1-50 MB)
• Physical memory required: Not applicable

In the Detection rules tab:

1. Select Use a custom detection script
2. Click Select file and upload your DetectionCheck.ps1
3. Set Run script as 32-bit process on 64-bit clients: No
4. Set Enforce script signature check: No (unless you have signed scripts)

Alternative detection method (if you prefer file-based detection):

Detection method: Manually configure detection rules
Rule type: File
Path: C:\Windows\Temp
File or folder: FontInstallSuccess.txt
Detection method: File or folder exists

Configure the assignment settings and deploy your font package to target devices or user groups.

In the Assignments tab:

1. Click Add group under Required (for mandatory installation) or Available for enrolled devices (for optional installation)
2. Select your target groups (device groups recommended for fonts)
3. Configure delivery optimization if needed

Set the assignment settings:

• Intent: Required (fonts install automatically)
• Notification: Show all toast notifications
• Availability: As soon as possible
• Installation deadline: As soon as possible

Review and create the application:

1. Click Next to review all settings
2. Verify the package information, commands, and assignments
3. Click Create to deploy the application

Monitor the deployment:

Navigate to: Apps > Windows > Company Custom Fonts > Device install status
Check for: Installation progress and any error codes

Validate that your custom fonts are properly installed and available on target Windows devices.

On a target device, force a sync to check for new applications:

1. Open Settings > Accounts > Access work or school
2. Click your work account and select Info
3. Click Sync to force policy refresh

Verify font installation using PowerShell on the target device:

# Check if font files exist
Get-ChildItem "C:\Windows\Fonts" | Where-Object { $_.Name -like "*YourCompanyFont*" }

# Check registry entries
Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts" | Select-Object *YourCompanyFont*

# Check installation log
Get-Content "C:\Windows\Temp\FontInstall.log" -Tail 20

Test font availability in applications:

1. Open Microsoft Word or Notepad
2. Click the font dropdown menu
3. Search for your custom font names
4. Type some text and apply the custom font

Check Intune reporting:

Intune admin center > Apps > Windows > Company Custom Fonts
- Device install status: Should show "Installed"
- User install status: Check for any failures
- App protection status: Monitor for issues