If you’ve ever watched a deployment status flip to "Success" only to find the new font missing from Word, or if you’re stuck troubleshooting why cscript.exe runs but nothing happens on Windows 10 version 1809+, you’re not alone. For years, manual font installation has been a bottleneck for IT teams managing large environments. Copying .ttf files to C:\Windows\Fonts used to be the way, but that method no longer registers fonts properly on modern OS builds.
System Center Configuration Manager (SCCM), now part of Microsoft Endpoint Configuration Manager, remains the most robust tool for automating this task across hundreds or thousands of endpoints. In this guide, we move beyond the broken legacy VBS scripts that plague the forums. Instead, we focus on how to deploy fonts using SCCM with modern PowerShell logic that explicitly handles registry keys and avoids the "logoff required" trap. We will cover the definitive method for 2025, ensuring your fonts install silently, persist across user sessions, and work on both Windows 10 and 11.
Prerequisites: Choosing the Right Font Deployment Method
Before diving into scripts, it’s crucial to pick the right vehicle for the job. I’ve seen teams waste weeks configuring SCCM packages only to realize a Group Policy Object (GPO) would have solved it in minutes, or vice versa. The choice depends largely on where your font files are located and how connected your users are.
SCCM vs. GPO vs. Intune: When to Use Each
The decision matrix is simpler than it looks. If your fonts are stored on a network share (UNC path) and your users are always on the corporate LAN, GPO is your best friend. It’s native, requires no scripting, and updates quickly via policy refresh. However, it fails completely for offline laptops or remote workers.
SCCM (Configuration Manager) is the heavy hitter. It’s the go-to solution when you need to bundle font files with complex installation logic, support offline scenarios (via local distribution points), or manage non-domain joined machines. It allows for granular control over deployment types, such as "Available" vs. "Required."
For cloud-managed devices, Intune is the standard. While you can deploy fonts via Intune using scripts, it lacks the native package management depth of SCCM. If you have a hybrid environment, SCCM remains the anchor, with Intune acting as the bridge for cloud-only assets.
| Method | Best For | Limitation |
|---|---|---|
| GPO | Simple network paths, always-connected PCs | Fails for offline/remote users |
| SCCM | Complex logic, offline support, local files | Heavier setup, slower update cadence |
| Intune | Cloud-native, Azure AD joined devices | Limited package management vs. SCCM |
In my experience, most enterprises run a hybrid model. If you are strictly on-premises with domain-joined machines and reliable network shares, GPO saves you the hassle of maintaining distribution points. But the moment you have field workers or need to bundle the actual .otf files into a package that works without a specific network path, SCCM takes over. We’ll focus on the SCCM method here because it offers the highest reliability for complex, machine-wide installations. |
Method 1: The Modern Standard (PowerShell Script)
This is the approach I recommend for any environment running Windows 10 version 1809 or later, and Windows 11. The old trick of copying files to C:\Windows\Fonts no longer triggers the necessary registry updates for all users in recent builds. Microsoft changed how fonts are handled to support per-user font stores, which means a simple copy operation might install the font only for the SYSTEM account, making it invisible to the logged-in user.
Creating the Deployment Package
To start, open your Configuration Manager console. Navigate to Software Library -> Packages. Right-click on Packages and select Create Package.
- Name the Package: Give it a clear name, such as "Font Deployment - Brand Kit".
- Set the Source: Point the source folder to a local path on the management point or a share where you have placed all your
.ttfand.otffiles alongside your installation script. - Do Not Create a Program: When prompted to create a program, uncheck this box. We will create the program manually to ensure the execution context is correct.
- Distribute the Content: Before deploying, you must distribute this package to your appropriate Distribution Points (DPs). Right-click the package, select Distribute Content, and target your DPs. This step is critical; many failures occur simply because the client hasn’t synced the content to its local
ccmcacheyet.
The PowerShell Installation Logic
Here is the script that solves the "invisible font" problem. It explicitly writes to the machine-level registry key, ensuring the font is available to all users without requiring a reboot. Save this as Install-Fonts.ps1 in the same folder as your font files.
<#
.SYNOPSIS
Installs fonts for all users by copying to %SystemRoot%\Fonts and registering in HKLM.
.DESCRIPTION
Handles the Windows 10 1809+ per-user font behavior by forcing machine-wide registry entries.
.PARAMETER FontSourcePath
The path where the font files are located (relative to the script or absolute).
#>
param(
[string]$FontSourcePath = $PSScriptRoot
)
$SystemFonts = [Environment]::SystemFonts
$RegKey = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"
$FontFiles = Get-ChildItem -Path $FontSourcePath -Include *.ttf, *.otf, *.woff2 -File
foreach ($Font in $FontFiles) {
try {
# 1. Copy the font file to the system fonts folder
# -Force overwrites if it exists
Copy-Item -Path $Font.FullName -Destination $SystemFonts -Force
# 2. Create the registry entry for machine-wide visibility
# The value name must match the font family name inside the file
# The value data is the filename
$fontName = $Font.Name
# Optional: Parse the actual font family name for better UX in dropdowns
# For simplicity, using the filename as the key name works for most standard fonts
New-ItemProperty -Path $RegKey -Name $fontName -Value "TrueType" -PropertyType String -Force
New-ItemProperty -Path $RegKey -Name $fontName -Value $fontName -PropertyType String -Force
Write-Host "Successfully installed and registered: $($Font.Name)" -ForegroundColor Green
}
catch {
Write-Warning "Failed to process $($Font.Name): $_"
}
}
Write-Host "Font installation complete. No reboot required." -ForegroundColor Cyan
Why this works: The key is the New-ItemProperty call against HKLM. When you manually copy a font to C:\Windows\Fonts via Explorer, Windows handles the registry registration. When you do it via a script running as SYSTEM (which is how SCCM runs packages), that auto-registration often fails silently on newer Windows versions. Explicitly writing to HKLM forces the OS to recognize the font for all users immediately.
Method 2: Legacy Approach (VBS & Package/Program)
If you are supporting a fleet of Windows 7 or Windows 10 versions prior to 1809, the VBS approach is still valid. It’s less elegant, but it avoids the complexity of PowerShell execution policies. I still use this for legacy hardware in my support rotation because it’s faster to debug in a crisis.
Step-by-Step Package Creation
- Prepare the Files: Place your font files and a VBS script (
InstallFonts.vbs) in the source folder. - Create the Package: As before, create a new package in Software Library -> Packages.
- Create the Program:
- Go to the Programs tab of the package you just created.
- Right-click and select Create Program.
- Select Standard Program as the type.
- Command Line: Enter
cscript.exe //nologo //B InstallFonts.vbs. - Run as: Select Whether or not a user is logged on. This is crucial. It forces the script to run as SYSTEM, ensuring it has the rights to write to
C:\Windows\Fonts.
The VBS script itself is simpler. It uses the Shell.Application object to trigger the native install verb, which does handle registry keys correctly on older OS versions.
' InstallFonts.vbs
' Assumes all .ttf/.otf files are in the same directory as this script
Set fso = CreateObject("Scripting.FileSystemObject")
Set shell = CreateObject("WScript.Shell")
' Get the directory where the script is running
strDir = fso.GetParentFolderName(WScript.ScriptFullName)
' Get a collection of font files
Set objFolder = shell.BrowserFolder(strDir)
' List all files in the folder
For Each objFile In objFolder.Items
If LCase(fso.GetExtensionName(objFile.Name)) = "ttf" Or LCase(fso.GetExtensionName(objFile.Name)) = "otf" Then
' Use the "Install" verb
' This triggers the Windows font installer which handles registry keys
shell.Run "cmd /c copy /Y """ & objFile.Path & """ %SystemRoot%\Fonts"
WScript.Sleep 1000 ' Small delay to ensure the copy completes
End If
Next
Managing the Logoff Requirement
Here is the pain point with the legacy method. On older Windows builds, even if the file is copied to the system folder, the font cache is often tied to the user session. If you deploy this via SCCM, the deployment will complete, but the user won't see the font in their application until they log off and back on.
To handle this gracefully:
- Do Not Set Logoff: In the program properties, leave "After running" as "Do nothing."
- Inform Users: If you deploy this as "Available," users might install it in Software Center and then ask why it’s not there.
- The Fix: Add a step to your VBS script that runs
gpupdateor simply notifies the user. However, the cleanest solution for the legacy method is to accept that a logoff is required and schedule these deployments during maintenance windows or when the user is not actively working.
In my view, this friction is exactly why the PowerShell method above is superior for modern environments. The explicit registry write bypasses the session-bound cache issues, meaning the font is visible immediately after the script finishes.
Troubleshooting: Why Is My Font Deployment Failing?
Even with the right script, things go wrong. I’ve sat next to admins staring at execmgr.log for hours. Here are the most common reasons font deployments fail in SCCM, and how to fix them.
Common Error Codes and Fixes
| Error Code / Symptom | Likely Cause | Solution |
|---|---|---|
| 0x80070002 | File Not Found | The content hasn't been distributed to the local DP or client cache. Run a "Machine Policy Retrieval" in the client. |
| Access Denied | Permission Issue | The script is running as a non-elevated user. Ensure the program is set to "Whether or not a user is logged on" and runs as SYSTEM. |
| Font Not Visible | Registry Mismatch | You copied the file but didn't update HKLM. Use the PowerShell method explicitly written for Win 10 1809+. |
| Prompt Hangs | Existing Font Conflict | The "Replace Font?" dialog is blocking the script. Use Copy-Item -Force in PowerShell to suppress this prompt. |
| One specific trap I’ve encountered: if your font filename contains spaces or special characters, some legacy VBS scripts break. PowerShell handles quoting more robustly. Always test your script manually on a single machine before pushing it to a collection. |
Validating Deployment Success
Don't just trust the "Success" status in the SCCM console. That only means the script ran. It doesn't mean the font installed.
- Check the Log: Open
C:\Windows\CCM\Logs\execmgr.logon the client. Look for "Exit code is 0." If you see "Exit code is 3" or similar, the script hit a permission error. - Visual Verification: Open Control Panel -> Fonts. Search for your new font. If it’s there, you’re good.
- Application Test: Open Microsoft Word or Notepad. Drop down the font list. If you see your font, the registry key was written correctly for that user.
If you can find the file in C:\Windows\Fonts but not in the Word dropdown, you have a registry mismatch. This confirms the need for the explicit New-ItemProperty call in the PowerShell script.
Advanced Tips: Scaling and Optimization
Once you have a basic deployment working, you can optimize for larger scales and specific use cases.
Deploying to Users vs. Computers
A common question is whether to deploy to Users or Computers.
- Computers: Installs the font for all users on that machine. This is ideal for shared kiosks, labs, or standard employee workstations where everyone needs the brand font. It uses the
HKLMregistry keys. - Users: Installs the font for one specific user. This uses the
HKCUregistry keys and installs to%LocalAppData%\Microsoft\Windows\Fonts.
For most enterprise scenarios, Computer deployment is better. It ensures consistency. If User A logs in, they see the font. If User B logs in, they also see it. With user-based deployment, if a new employee logs in for the first time, they won't have the font until their profile is created and the policy applies. I always recommend machine-wide installation unless you have a specific requirement for per-user customizations.
Managing Web Fonts and Licensing
Can you deploy web fonts (.woff, .woff2) to users' machines? Technically, yes, the file system will accept them. However, most web fonts are not installed for "system-wide" use in the same way desktop fonts are. They are intended for browser rendering.
Legal Note: Before deploying proprietary fonts (like Adobe Type, Monotype, or commercial brand fonts) across your organization, verify your licensing. Many EULAs restrict the number of seats or devices. Deploying a font to 500 machines might violate a license that covers only 50 employees. Always consult with your legal or procurement team.
For open-source fonts (like Roboto, Open Sans), you are generally free to deploy them, but keep a local copy of the license text for your records.
FAQ
Why are my fonts not installing via SCCM?
The top three reasons are:
- Content Sync Issues: The client hasn't downloaded the package from the distribution point yet. Force a "Machine Policy Retrieval" to speed this up.
- Non-Elevated Context: The script is running as the logged-in user, who lacks permission to write to
C:\Windows\Fonts. Ensure your program is configured to run as SYSTEM. - Windows 10 1809+ Behavior: You are using the old copy-only script. On modern builds, a simple copy does not register the font for all users. You must explicitly write to the
HKLMregistry key as shown in the PowerShell method above.
Do I need to reboot the computer after font deployment in SCCM?
No. In most cases, a full reboot is unnecessary.
- With PowerShell (HKLM): The font should be visible immediately after the script completes. No logoff or reboot is needed.
- With Legacy VBS: A logoff/logon cycle is often required for the font cache to update. A reboot will definitely clear it, but logoff is the minimum requirement.
What is the difference between deploying fonts via GPO and SCCM?
GPO is simpler and faster for network-based paths, but it relies on the Fonts preference policy which just points to a share. SCCM gives you full control over the installation process, allowing you to copy files locally, run custom scripts, and handle offline scenarios. GPO is "set and forget"; SCCM is "programmed automation." If your environment is 100% on-domain and always connected, GPO is fine. For hybrid or complex environments, SCCM is the reliable choice.
Conclusion
Mastering how to deploy fonts using SCCM is about moving away from the "copy file and pray" method. The legacy VBS scripts, while still functional on older OSs, have become a source of endless troubleshooting tickets due to registry mismatches on Windows 10 and 11.
My strong recommendation is to adopt the PowerShell method outlined in Method 1. It is deterministic, silent, and ensures machine-wide availability without forcing users into logoff cycles. Before you push this to your entire fleet, test it on a small pilot collection. Verify that the fonts appear in Word, Excel, and Adobe products. Monitor the execmgr.log files on a few test machines to confirm the exit code is zero.
By aligning your deployment strategy with the specific behavior of your target OS version, you eliminate the "Access Denied" errors and the "where did the font go?" confusion. System Center Configuration Manager is a powerful tool, but it requires precise input to yield reliable output. Treat your font deployment not just as a file copy task, but as a configuration management event, and you’ll see a dramatic reduction in support tickets.