# ContextMenuForWindows11: adding your own entries to the Windows 11 right-click menu

> A C# UWP shell extension that reads JSON menu definitions, plus how to install it from the Store, GitHub releases or Scoop, and where it stops being the right tool.

**ikas-mc/ContextMenuForWindows11** — Add Custom Context Menu For Windows11

- Repository: https://github.com/ikas-mc/ContextMenuForWindows11
- Stars: 2,893 · Forks: 131
- Language: C#
- License: LGPL-3.0
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/ikas-mc-contextmenuforwindows11

## What ContextMenuForWindows11 adds, and who ends up using it

Windows 11 shipped a rebuilt right-click menu, and the entries in it come from shell extensions rather than from a user-editable list. ContextMenuForWindows11 is one such extension: it registers itself with the shell and contributes its own items to the menu, which means the entries appear in the new Windows 11 menu rather than only in the legacy "Show more options" list. The project describes itself as adding a custom context menu for Windows 11, and the repository topics list context-menu, uwp, windows and windows-11.

The people who get value from it are the ones who repeat the same shell action many times a day: opening a folder in a specific editor, pushing a file with adb, extracting an archive with 7z, computing an MD5 with PowerShell. The menuSample directory in the repository contains exactly this kind of file, with names such as Open With VScode.json, Compress By 7z.json, Install Apk By Adb.json and Calculate Md5 By PowerShell.json. That list is the clearest statement of intent the repository makes: this is a tool for wiring a handful of personal commands into the shell, not a general-purpose shell customisation suite.

It is not aimed at people who want to rearrange or delete the entries Microsoft and third-party installers put in the menu. Nothing in the README describes removing or reordering existing entries. It adds; it does not curate.

## JSON menu definitions and the UWP shell extension behind them

The mechanism visible in the repository is a UWP application that also acts as a shell extension. The top-level entries include a single C# project directory, ContextMenuCustom, alongside menu.schema.json, menuSample, install.md and build.md. The presence of a JSON schema at the repository root is the strongest structural signal about how menus are defined: a menu is data, not code, and the schema is what validates that data.

So the data flow is roughly this. You write a JSON file describing one or more menu entries. The extension reads it, validates it against the schema, and contributes the resulting items to the Windows 11 context menu. When you click an item, the command described in the JSON runs. The sample names imply that a definition can carry a command line, arguments and probably a target-file placeholder, since entries such as Echo path.json and Open In Explorer.json only make sense if the selected path is passed through to the command.

The README does not spell out the schema fields, and it does not describe where menu files are stored or how the extension discovers them. It points to the wiki for guides and to a discussions thread titled "create menus using AI" for generating definitions. If you want to know the exact keys, menu.schema.json is the file to read, not the README.

## Installing ContextMenuForWindows11 from the Store, GitHub or Scoop

The README presents three distribution channels in a table: the Microsoft Store, GitHub releases, and GitHub Actions builds. It also lists Scoop, which points at a package named contextmenucustom-np. The Store package is described as free with no limit, while the GitHub release and the development package use a self-signed certificate and are labelled for test use.

The README states that from v3.8 the Store package, the GitHub package and the dev package can be installed at the same time. That matters if you want a stable Store install for daily use and a dev build alongside it for trying newer menu behaviour.

Scoop is the shortest path on a machine that already has it:

```bash
scoop install contextmenucustom-np
```

After that, the extension is registered and its entries should appear when you right-click a file or folder in File Explorer. If nothing appears, the README gives no troubleshooting steps; install.md in the repository is the place the project keeps its install notes.

The first real use is a menu file. The repository ships samples under menuSample, so the practical starting point is to copy one and change the command. A minimal definition follows the shape of the schema, and the project's own example list gives the naming convention:

```json
{
  "Open With VScode": {
    "command": "code",
    "arguments": "%1"
  }
}
```

Treat that as a shape to check against menu.schema.json rather than as a verified file: the README does not print a full example, and the schema at the repository root is the authority on the exact keys. Once the file is in place, the entry should show up in the Windows 11 menu, and clicking it should run the command with the selected path.

## The self-signed certificate and other costs of the GitHub build

The README is explicit that the GitHub release and the dev package use a self-signed certificate, and it labels them as test packages. That is a real constraint, not a footnote. Installing a package signed this way normally means trusting the certificate on the machine first, and the README does not document that procedure. It also does not document rollback, so if an entry misbehaves after installation, the README gives you nothing to fall back on beyond removing the package.

Because this is a shell extension, the failure mode is worse than for a normal application. A shell extension loads into Explorer's process. A definition that points at a missing executable, or a command that hangs, affects the menu rather than a single window you can close. The README does not describe crash isolation, timeouts or a safe mode.

There is a second, quieter cost. The extension contributes entries to a menu Microsoft controls, and the project has to keep up with changes to that surface. The release history shows a cadence of roughly one release every four to five months across 5.6.0.0, 5.7.0.0 and 5.8.0.0, with the most recent listed release on 2026-05-29. The last push to the repository was on 2026-09-19, so work is ongoing, but the release cadence is the number that matters if you are planning upgrades.

Finally, the wrong-tool case: if what you actually want is to hide or reorganise the entries already in the Windows 11 menu, this project is the wrong shape. It adds entries. It does not manage the ones that are there.

## How it differs from Nilesoft Shell and ContextMenuManager

The search terms people use around this project include Nilesoft Shell and ContextMenuManager, and the difference in approach is worth stating plainly.

ContextMenuForWindows11 defines menus as JSON and validates them against a published schema. That makes a menu file reviewable, diffable and copyable between machines, and it is why the repository can ship a samples directory of ready-made definitions. The trade-off is that everything goes through the schema: if the schema does not express what you want, you are editing the extension, not the configuration.

Nilesoft Shell takes a different route, using a shell script style of configuration rather than JSON. That gives more expressive power over conditions and menu structure, at the cost of a configuration language you have to learn rather than a schema you can look up.

ContextMenuManager is a manager rather than a definition format. Its job is the one this project does not do: turning existing menu entries on and off and tidying what is already there. If your problem is clutter, that is the category to look at; if your problem is that a command you run ten times a day is not in the menu, this project is the closer fit.

One thing the README does not offer is a comparison with any of these. The related searches exist because users make the comparison themselves.

## Licence, maintenance and what an upgrade actually costs

The repository is licensed under LGPL-3.0. That is a copyleft licence with a linking exception, and the practical question for most readers is what happens if they ship the extension inside a product. The LGPL permits use alongside proprietary code under conditions that concern modification and relinking, but the specifics depend on how you distribute. The repository does not include a separate licensing note beyond the LICENSE file, and nothing here should be read as legal advice; if you plan to redistribute, read the LICENSE text itself.

The maintenance picture from the repository facts: the project is not archived, and the last push was on 2026-09-19. The most recent listed release is 5.8.0.0, dated 2026-05-29. So the code moves more often than the releases.

Upgrade cost has two parts. The versioned package itself is straightforward, and the README notes that Store, GitHub and dev packages can coexist from v3.8, which lets you stage a new build beside a working one. The harder part is the menu files. If the schema changes between versions, definitions written against an older schema may need editing, and the README does not promise schema stability across releases. The menu.schema.json file at the repository root is the artifact to diff when you upgrade.

## Conclusion

Adopt it if you want a small set of right-click actions defined in JSON that you can copy between machines, and you are willing to install a shell extension and, on the GitHub build, trust a self-signed certificate. Do not adopt it if you need a menu editor with a GUI, or if you cannot carry the cost of a shell extension that must be rebuilt and reinstalled when Windows changes. Before installing, read install.md and menu.schema.json in the repository, and check whether the menu you want already exists in menuSample or the discussions menus category.

## FAQ

### How do I install ContextMenuForWindows11?

The README lists three channels: the Microsoft Store, GitHub releases, and GitHub Actions builds. Scoop users can install the contextmenucustom-np package, and the README states that from v3.8 the Store, GitHub and dev packages can be installed at the same time.

### What is the context menu in Windows 11, and how does this project change it?

It is the menu that appears when you right-click in File Explorer. ContextMenuForWindows11 is a UWP shell extension that contributes its own entries to that menu, driven by JSON menu definitions validated against menu.schema.json.

### Can ContextMenuForWindows11 disable or remove existing context menu entries in Windows 11?

The README describes adding custom entries, not removing or reordering the entries other software installs. Nothing in the documentation covers disabling existing items, so treat that as outside what the project claims to do.

## Sources

- [ikas-mc/ContextMenuForWindows11 on GitHub](https://github.com/ikas-mc/ContextMenuForWindows11)
- [Issues](https://github.com/ikas-mc/ContextMenuForWindows11/issues)
- [License: LGPL-3.0](https://github.com/ikas-mc/ContextMenuForWindows11/blob/main/LICENSE)
- [README](https://github.com/ikas-mc/ContextMenuForWindows11/blob/main/README.md)
- [Releases](https://github.com/ikas-mc/ContextMenuForWindows11/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ikas-mc-contextmenuforwindows11
