The original article on this topic covered the three basic DISM commands for injecting drivers into a WinPE boot image. This updated guide expands that into a complete reference — covering manual DISM injection, the modern PowerShell cmdlet approach, SCCM ConfigMgr console methods, OEM driver pack automation, and a critical ADK compatibility warning for ConfigMgr 2509 users that is breaking boot image driver injection in early 2026.

Detail
Last UpdatedMarch 2026
Applies ToWindows PE, SCCM/ConfigMgr 2309+, Windows ADK
Tools UsedDISM, Add-WindowsDriver, Mount-WindowsImage
⚠️ ADK WarningADK 10.28000.x is NOT compatible with ConfigMgr 2509
DifficultyIntermediate

⚠️ ADK Compatibility Warning — ConfigMgr 2509 (March 2026)

If you are running ConfigMgr 2509 and recently updated to Windows ADK 10.28000.x, your boot image driver injection may silently fail — drivers are not loaded when WinPE boots, resulting in no network connectivity or storage access during task sequences. The root cause is an ADK version incompatibility with ConfigMgr 2509. The fix is to downgrade ADK to the previous supported version until Microsoft releases a patch.

Check your current ADK version before proceeding:

# Check installed Windows ADK version
$adkPath = "HKLM:\SOFTWARE\Microsoft\Windows Kits\Installed Roots"
if (Test-Path $adkPath) {
    $adkVersion = (Get-ItemProperty -Path $adkPath).KitsRoot10
    Write-Host "Windows ADK installed at: $adkVersion"

    # Also check ADK version from registry
    Get-ChildItem "HKLM:\SOFTWARE\Microsoft\Windows Kits\Installed Roots" |
        Get-ItemProperty |
        Select-Object KitsRoot10 |
        Format-Table -AutoSize
} else {
    Write-Host "Windows ADK not found in registry."
}

Why Inject Drivers Into Boot Media?

Windows PE is a minimal OS — it only includes the drivers Microsoft bundles in the Windows ADK WinPE add-on. When you deploy to hardware that has a NIC or storage controller not covered by those built-in drivers, WinPE boots without network connectivity or cannot see the local disk — and your task sequence fails immediately. The typical drivers you need to inject are:

  • Network (NIC) drivers — required to connect to the distribution point or PXE server during deployment
  • Mass storage / NVMe drivers — required when the target disk uses a controller not included in the ADK build
  • Wi-Fi drivers — for deployments over wireless (uncommon but sometimes needed)

Do not inject unnecessary drivers — display adapters, audio, Bluetooth, and peripheral drivers serve no purpose in WinPE and increase boot image size without benefit. Keep the boot image lean: only NIC and storage drivers for your hardware models.

Method 1: Manual Injection via DISM (Original Approach)

The original three-command workflow — still valid and the fastest approach for one-off injections:

# Step 1 — Mount the boot.wim (index 2 for task sequence / WinPE maintenance)
# Index 1 = Windows PE Setup; Index 2 = WinPE Maintenance (used by SCCM TS)
dism /Mount-Image /ImageFile:"C:\temp\boot.wim" /Index:2 /MountDir:"C:\mount"

# Step 2 — Inject all drivers from folder recursively
dism /Image:"C:\mount" /Add-Driver /Driver:"C:\Drivers" /Recurse

# Step 3 — Commit and unmount
dism /Unmount-Image /MountDir:"C:\mount" /Commit

Verify which index is which before mounting:

# Check available indexes in boot.wim
dism /Get-WimInfo /WimFile:"C:\temp\boot.wim"

Method 2: PowerShell Cmdlets (Preferred)

The modern PowerShell approach offers better error handling and integrates cleanly into automated scripts:

# Mount boot.wim index 2
Mount-WindowsImage `
    -ImagePath "C:\temp\boot.wim" `
    -Index 2 `
    -Path "C:\mount"

# Add all drivers from folder recursively with verbose output
Add-WindowsDriver `
    -Path "C:\mount" `
    -Driver "C:\Drivers" `
    -Recurse `
    -Verbose

# Verify injected drivers (filter out Microsoft built-in ones)
Get-WindowsDriver -Path "C:\mount" |
    Where-Object { $_.ProviderName -notlike "*Microsoft*" } |
    Select-Object OriginalFileName, ProviderName, Version, Date |
    Format-Table -AutoSize

# Commit and unmount
Dismount-WindowsImage -Path "C:\mount" -Save

Method 3: SCCM ConfigMgr Console (GUI)

For environments managed via ConfigMgr, the recommended workflow is to import drivers into the Drivers repository first and then associate them with the boot image — ConfigMgr handles the mount/inject/unmount cycle automatically.

Via Boot Image Properties

  1. Navigate to Software Library → Operating Systems → Boot Images
  2. Right-click your boot image → Properties
  3. Go to the Drivers tab → click the star icon to add drivers
  4. Browse to the drivers imported in the Drivers node and select the ones to inject
  5. Click OK — ConfigMgr will update the boot image and prompt to update distribution points

Via the Drivers Node (Recommended for Bulk)

  1. Navigate to Software Library → Operating Systems → Drivers
  2. Select the drivers to inject (Ctrl+click for multiple)
  3. Right-click → Edit → Boot Images
  4. Select the target boot image(s) and click OK

Method 4: Automate via PowerShell + ConfigMgr SDK

For scripted driver injection via ConfigMgr — useful in CI/CD pipelines or when you regularly refresh boot images after new hardware arrives:

# Inject drivers into SCCM boot image via ConfigMgr PowerShell module
# Run on the site server or a machine with ConfigMgr console installed

# Connect to site
Import-Module "$($env:SMS_ADMIN_UI_PATH)\..\ConfigurationManager.psd1"
$SiteCode = "ABC"  # Replace with your site code
Set-Location "$SiteCode`:\"

# Get boot image object
$bootImage = Get-CMBootImage -Name "Boot image (x64)"

# Get drivers to inject — filter by category or model
$drivers = Get-CMDriver | Where-Object {
    $_.LocalizedCategoryInstanceNames -contains "WinPE Drivers" -and
    $_.IsEnabled -eq $true
}

Write-Host "Found $($drivers.Count) drivers to inject."

# Add drivers to boot image
foreach ($driver in $drivers) {
    Set-CMBootImage -InputObject $bootImage -AddDriverToBootImage $driver
}

Write-Host "Drivers added. Updating distribution points..."

# Update distribution points
Update-CMDistributionPoint -BootImageName "Boot image (x64)"
Write-Host "Done."

OEM Driver Pack Automation (Dell, HP, Lenovo)

All three major OEMs publish WinPE driver packs — pre-packaged ZIP or CAB files containing only the WinPE-specific NIC and storage drivers for their hardware. Using these is strongly preferred over extracting individual drivers — they are pre-tested with WinPE and updated regularly.

  • Dell — Dell WinPE Driver Pack available at dell.com/support, search “WinPE Driver Pack”
  • HP — HP WinPE Driver Pack available at hp.com/go/clientmanagement
  • Lenovo — Lenovo WinPE Driver Pack available at support.lenovo.com (deployment recipe cards)

Download and extract the driver pack, then use the recursive injection approach. Here is a complete end-to-end script for injecting an OEM driver pack into boot.wim:

# Inject-OEMDriversToBootWIM.ps1
# Full end-to-end script — backup, inject, verify, commit
# Requires elevation (Run as Administrator)

param (
    [string]$BootWimPath  = "C:\temp\boot.wim",
    [int]   $BootWimIndex = 2,
    [string]$MountDir     = "C:\mount",
    [string]$DriverPath   = "C:\Drivers\Dell_WinPE",
    [string]$BackupDir    = "C:\temp\boot_backup"
)

$ErrorActionPreference = "Stop"

try {
    # Verify paths
    foreach ($p in @($BootWimPath, $DriverPath)) {
        if (-not (Test-Path $p)) { throw "Path not found: $p" }
    }

    # Create mount directory
    if (-not (Test-Path $MountDir)) { New-Item -ItemType Directory -Path $MountDir -Force | Out-Null }

    # Backup original boot.wim
    if (-not (Test-Path $BackupDir)) { New-Item -ItemType Directory -Path $BackupDir -Force | Out-Null }
    $backupFile = Join-Path $BackupDir "boot_$(Get-Date -Format 'yyyyMMdd_HHmmss').wim"
    Copy-Item -Path $BootWimPath -Destination $backupFile
    Write-Host "Backup created: $backupFile"

    # Show available indexes
    Write-Host "`nAvailable boot.wim indexes:"
    Get-WindowsImage -ImagePath $BootWimPath | Select-Object ImageIndex, ImageName | Format-Table -AutoSize

    # Mount
    Write-Host "Mounting index $BootWimIndex..."
    Mount-WindowsImage -ImagePath $BootWimPath -Index $BootWimIndex -Path $MountDir
    Write-Host "Mounted at $MountDir"

    # Count drivers before injection
    $driversBefore = (Get-WindowsDriver -Path $MountDir |
        Where-Object { $_.ProviderName -notlike "*Microsoft*" }).Count
    Write-Host "Third-party drivers before injection: $driversBefore"

    # Inject drivers
    Write-Host "`nInjecting drivers from $DriverPath..."
    Add-WindowsDriver -Path $MountDir -Driver $DriverPath -Recurse -Verbose

    # Count drivers after injection
    $driversAfter = (Get-WindowsDriver -Path $MountDir |
        Where-Object { $_.ProviderName -notlike "*Microsoft*" }).Count
    Write-Host "`nThird-party drivers after injection: $driversAfter (+$($driversAfter - $driversBefore) added)"

    # List injected drivers
    Get-WindowsDriver -Path $MountDir |
        Where-Object { $_.ProviderName -notlike "*Microsoft*" } |
        Select-Object OriginalFileName, ProviderName, Version |
        Format-Table -AutoSize

    # Commit and unmount
    Write-Host "Committing and unmounting..."
    Dismount-WindowsImage -Path $MountDir -Save
    Write-Host "Done. Modified boot.wim saved to $BootWimPath"
    Write-Host "Original backup at: $backupFile"

} catch {
    Write-Host "ERROR: $_" -ForegroundColor Red
    Write-Host "Attempting to discard and unmount..."
    try { Dismount-WindowsImage -Path $MountDir -Discard -ErrorAction SilentlyContinue } catch {}
    exit 1
}

After Injection: Update Distribution Points

After modifying a boot.wim used by SCCM, the updated image must be distributed to all PXE-enabled distribution points. If you injected drivers manually outside of ConfigMgr, re-import the modified boot.wim:

  1. In ConfigMgr console → Software Library → Boot Images
  2. Right-click the boot image → Update Distribution Points
  3. Monitor the distribution status under Monitoring → Distribution Status → Content Status

If you modified the boot.wim file outside ConfigMgr, reload it via ConfigMgr console or via PowerShell:

# Reload modified boot.wim in ConfigMgr and update DPs
Import-Module "$($env:SMS_ADMIN_UI_PATH)\..\ConfigurationManager.psd1"
Set-Location "ABC:\"  # Replace with your site code

# Trigger DP update for the boot image
$bootImage = Get-CMBootImage -Name "Boot image (x64)"
Update-CMDistributionPoint -BootImageName $bootImage.Name
Write-Host "Distribution point update triggered."

Troubleshooting

IssueCauseFix
Drivers injected but not loading in WinPEADK 10.28000.x incompatibility with ConfigMgr 2509Downgrade ADK to previous supported version — check learn.microsoft.com/configmgr for supported ADK matrix
Driver injection error — architecture mismatchx86 driver injected into x64 boot.wim or vice versaEnsure driver matches boot.wim architecture — check INF file [Manufacturer] section
Mount fails — directory not emptyPrevious mount not cleanly unmountedRun: dism /Cleanup-Mountpoints then retry
No IP address after PXE bootNIC driver missing or wrong version in boot imageCheck smsts.log (F8 in WinPE → cmd → ipconfig), verify NIC driver is in image via Get-WindowsDriver
Boot image size too large after injectionNon-WinPE drivers (display, audio) injectedOnly inject NIC and storage drivers — remove unnecessary ones with Remove-WindowsDriver
File not found error in DISM logDriver path on UNC share not accessible from site server machine accountCopy drivers to a local path on the site server before injecting

To check DISM logs after a failed injection:

# View DISM log for injection errors
Get-Content "C:\Windows\Logs\DISM\dism.log" | Select-Object -Last 50

# Check for stuck mounts
dism /Get-MountedImageInfo

# Clean up orphaned mount points
dism /Cleanup-Mountpoints

Summary

Driver injection into WinPE boot media is a fundamental OSD maintenance task in any ConfigMgr environment. The PowerShell cmdlet approach is cleaner and more scriptable than raw DISM commands, and the OEM WinPE driver packs from Dell, HP, and Lenovo make it easy to stay current without hunting for individual driver INF files. Always keep a timestamped backup of boot.wim before modifying it, and check the ADK/ConfigMgr compatibility matrix before any ADK update.

  • Only inject NIC and mass storage drivers into boot.wim — keep the image lean
  • Use Mount-WindowsImage + Add-WindowsDriver -Recurse + Dismount-WindowsImage -Save for the cleanest scripted workflow
  • Always back up boot.wim before modifying — use the timestamped backup in the script above
  • After manual injection outside ConfigMgr, trigger Update Distribution Points in the console
  • ⚠️ ADK 10.28000.x is not compatible with ConfigMgr 2509 — check the supported ADK matrix at learn.microsoft.com before updating