You cannot open an icon by right clicking because a right click does not open files at all. It asks Windows Explorer to build a context menu. When that menu is missing, truncated, or slow, the cause is almost always a broken shell extension, a corrupted registry handler, a policy block, or an Explorer process that has lost its message hook. Opening requires a double click or Enter, which routes through a different code path entirely.
That distinction explains most of the confusion behind this search. People report that right clicking "does nothing" and assume the file association is broken. Usually the association is fine. The menu builder is not.
The message-to-menu mechanism
A right click on a desktop icon or File Explorer item generates a WM_CONTEXTMENU message. Explorer receives it, identifies the item under the cursor, and queries the shell namespace for every registered handler that claims that file type. Each handler is a COM object, usually an in-process DLL. Explorer loads each one, asks it to contribute menu items, and assembles the result into a single popup.
The critical detail is where those handlers live. Most context menu entries are registered under HKEY_CLASSES_ROOT, in subkeys named shellex\ContextMenuHandlers. Each subkey holds a CLSID that points to a DLL somewhere on disk. Windows 11 adds a second layer: a packaged-app path plus a legacy path, and the modern menu only shows a subset of legacy entries until you choose "Show more options" or press Shift+F10.
If any single handler in that chain hangs, crashes, or blocks, the entire menu can fail to appear. Explorer does not gracefully skip a bad handler by default. It waits, times out, or dies and restarts. That is why one misbehaving third-party DLL can make right click appear completely dead across every file type.
A useful mental model: opening a file is one function call. Building a context menu is a fan-out to dozens of independent programs, any of which can veto the result.
How often this fails, and why the numbers skew
Shell extension faults are among the most common Explorer crash causes in enterprise telemetry, though Microsoft does not publish a single public percentage. What is documented is the structural risk. A typical Windows 11 install with common software carries 40 to 120 registered context menu handlers; a developer machine or a system with multiple archiving, cloud-sync, and antivirus tools can exceed 200.
Each handler is a chance for failure. If even 1 percent of handlers are faulty, a machine with 100 handlers has roughly a 63 percent chance that at least one is bad, assuming independence. That arithmetic is why the problem feels ubiquitous on heavily loaded systems and rare on clean ones.
Timing matters too. Explorer gives handlers a limited window to respond. Handlers that perform network calls, scan large files, or query cloud services on menu invocation routinely add 200 to 2,000 milliseconds. Users perceive anything past roughly 400 milliseconds as lag and past several seconds as "broken," so a slow handler reads as a missing menu even when it eventually appears.
The counterintuitive part: the file you right click is often irrelevant. The handler causing the stall may be registered globally, for all files or all folders, and only reveals itself on the item you happened to test.
Timeline of what actually happens
| Stage | Elapsed time (typical) | What occurs | Failure mode |
|---|---|---|---|
| Click registered | 0 ms | WM_CONTEXTMENU posted to Explorer | Input blocked by hung window |
| Item identified | 1-10 ms | Shell resolves the namespace item | Stale or broken shortcut target |
| Handler enumeration | 5-50 ms | Registry queried for CLSIDs | Corrupt or orphaned registry keys |
| Handler loading | 10-500 ms | COM DLLs loaded, some signed-checked | Missing DLL, wrong bitness, blocked load |
| Handler execution | 0-2,000+ ms | Each handler adds items, may do I/O | Network timeout, file scan, deadlock |
| Menu rendering | 5-30 ms | Popup drawn at cursor | Off-screen placement on multi-monitor |
| Dismissal | variable | Menu closes, handlers unloaded | Leaked handles accumulate over sessions |
The table shows where to look. Almost all real failures cluster in the loading and execution rows, not in click registration.
Edge cases that mimic a broken right click
Several situations produce the same symptom without any registry fault. Isolating them saves hours.
Touch and pen input. A long press is supposed to equal a right click, but pressure sensitivity, palm rejection, and driver quirks can swallow the gesture. Testing with a mouse separates hardware from software instantly.
Multiple monitors and DPI scaling. A menu can render off-screen when the cursor sits near an edge of a secondary display with different scaling. The menu exists but is invisible.
Explorer already hung. If Explorer is mid-crash or awaiting a stalled handler from a previous action, new context menus queue behind it. Restarting Explorer clears the queue.
Policy restrictions. Managed environments can disable context menu items or the entire shell menu through Group Policy. The registry keys exist but are overridden at a higher precedence.
Files on network or cloud paths. Right clicking an item on a disconnected mapped drive or a placeholder file can stall while the shell waits for a remote response that never arrives.
Red-flag warnings worth treating seriously:
The menu is missing for every file type, including the desktop, after installing new software. This points to a global handler, not a file association. Right click works in Safe Mode but not normally. A third-party extension is the cause with high confidence. Explorer restarts every time you right click a specific folder. A single handler is crashing the process. The problem began immediately after a Windows update. A shell component or compatibility shim changed behavior. Antivirus logs show repeated blocked DLL loads at menu time. Security software is intercepting the handler chain.
Misconceptions worth retiring
The most common wrong belief is that right click "opens" a file and the association is broken. It is not. Opening and menu construction are separate subsystems, so a working double click alongside a dead right click actually confirms the association is healthy.
A second misconception: reinstalling the application fixes the menu. It sometimes does, because the installer re-registers the CLSID. But if the registry key is orphaned or points to a moved DLL, reinstalling an unrelated app changes nothing. The fault follows the handler, not the file type.
A third: registry cleaners repair context menus. They can remove orphaned keys, but they cannot distinguish a legitimately unregistered handler from one that is temporarily absent because its service is stopped. Aggressive cleaning can delete working entries and produce new gaps.
The professional caveat: many "missing" menus are actually deferred. Windows 11's simplified menu hides legacy entries behind "Show more options" by design, and some handlers load only after a delay. Before diagnosing a fault, confirm whether the item appears after pressing Shift+F10 or waiting several seconds. This single check eliminates a large share of false reports.
Practical diagnosis and repair
Work from least invasive to most, and stop as soon as the symptom resolves. Each step targets a different layer of the chain.
Confirm the baseline. Right click a plain desktop area, then a folder, then a file. If all three fail, the problem is global. If only one fails, narrow to that item's handler set. Test Safe Mode. Boot into Safe Mode and repeat the three tests. Working menus in Safe Mode confirm a third-party extension as the cause. Check the modern menu behavior. Press Shift+F10 and look for "Show more options." If items appear there, the handler is registered and the issue is menu presentation, not registration. Restart Explorer. End and relaunch explorer.exe in Task Manager. This clears hung handler state without a reboot and costs about 10 seconds. Audit shell extensions with a reputable manager tool. Disable handlers in batches of five to ten, retesting after each batch. Bisection finds the culprit in a few rounds even with 100 handlers. Repair or re-register the suspect handler. Reinstalling the owning application is safer than manual registry edits. If you must edit, export the key first and change one value at a time. Run system file and image checks. Corrupted shell components are repaired by the built-in servicing tools, which restore signed binaries from a local component store.
Thresholds worth setting: if the menu takes longer than one second consistently, treat it as a performance fault and hunt slow handlers. If Explorer restarts more than once per session during menu use, treat it as a crash fault and prioritize bisection. If the problem survives Safe Mode, stop looking at extensions and examine policy and system integrity instead.
For managed fleets, the durable fix is a controlled allowlist of context menu handlers deployed by policy. That converts an unpredictable per-machine lottery into a known, testable set.
What this diagnosis cannot tell you
No web guide can identify your specific faulty handler without local inspection. The registry differs on every machine, and handler behavior depends on installed versions, security software, and policy. Treat any article that names one universal culprit with suspicion.
Modern Windows also obscures the chain. The split between the simplified and legacy menus, plus packaged-app handlers that do not appear in classic registry locations, means older diagnostic advice can miss entire categories of extension. Bitness mismatches add another layer: a 32-bit handler registered for a 64-bit shell may silently fail to load.
Finally, performance and correctness are different problems with different fixes. A handler that adds 800 milliseconds of latency is not broken, but it will feel broken. Chasing it as a crash wastes effort; measuring load time first tells you which problem you actually have. Start with the three-item baseline test, because it costs under a minute and routes you to the right layer before you touch the registry.