Breeze Shell: a two megabyte context menu with a JavaScript API and a two row compatibility table
An alternative Windows context menu, and more.
At a glance
- What is it?
- A Windows context menu replacement written in C++, animated, scriptable through an embedded JavaScript engine, and distributed as a zip you extract and run. Its compatibility claim covers two file managers, and its build needs xmake.
- Who is it for?
- Use Breeze Shell if you want the Windows context menu replaced rather than merely tweaked, and you are willing to run a portable build from a version-zero release with no support commitment. The animation model and the JavaScript extension point are the reasons to try it: the first makes the menu feel like a different application, and the second means you can change its contents without waiting for a feature.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 27 days ago.
- What is it written in?
- Mainly C++, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- std-microblock/breeze-shell3,351 ★ · +40
| Repository | 2026-09-24 | 2026-11-15 |
|---|---|---|
| std-microblock/breeze-shell | 3.3k | 3.4k |
40 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
A zip you extract, and a two megabyte user interface
The try-it-out section is three sentences long, and there is no installer in it.
You download an archive, extract it, and run the executable. That is the entire documented installation path, which is a reasonable choice for a context menu replacement: it needs to be present and reachable when you right-click, and a portable folder is one less thing to install.
The size claim is the interesting number. The user interface is a dedicated library written for this project, described as cross platform, simple, animation friendly and fast for modern C++, and it supports two different rendering contexts. With both a vector renderer and a second one available, the interface can stay at roughly two megabytes.
Two rendering backends is a deliberate redundancy rather than an accident. It means the project is not betting its interface on one library's maintenance, and it means you can change context without rewriting the menu.
The JavaScript API is the extension point
Most context menu replacements let you add items through a settings dialog. This one embeds a JavaScript engine and gives you an API.
The example is the whole model:
shell.menu_controller.add_menu_listener((e) => {
e.menu.add({ type: "button", name: "Shuffle Buttons", action: () => {} }, 0);
});You register a menu listener, and inside it you add an item with a type, a name and an action. The action is ordinary JavaScript, so anything you can express is available, including shuffling the positions of the existing items.
The full surface is a declaration file in the repository rather than a website, which is the right place for it. A bindings file also means your editor can complete the API, which matters more for an embedded language than for a documented function list.
And there is a second repository for plugins. You send a pull request there to get a script into the plugin market, so the application's own repository is not where user scripts live. That split keeps third party code out of the application repository, and it also means the plugin catalogue is a separate thing to review before you trust it.
Configuration hides behind a right-click in the data folder
The configuration story is the most Windows-native thing in the project.
There is a configuration document, in two languages, and the options it covers run from item height to the method used for rounding background corners. So the granularity is fine enough that the menu's geometry is tunable rather than fixed.
To reach the settings you open the application's data folder and right-click inside it. That is the configuration menu.
It is an unusual instruction to read, because there is no menu item anywhere that says settings. The trade-off is that the configuration surface is itself a context menu, so it is consistent with the thing it configures, and it costs nothing in the application's own interface. The cost is discoverability: if you did not know to look inside the data folder, you would not find it.
There is also a donations file at the repository root, which tells you what a project with no installer and no support commitment is asking for.
Compatibility is a two row table
The compatibility section is short, and its shortness is the information.
Two programs are listed. Microsoft's file explorer is marked fully compatible. A third party file manager is marked as mostly working. The legend explains the difference between the two marks.
Nothing else appears. Not the other common file managers, not third party shells that a user might reasonably expect, not the file pickers that many modern applications draw themselves.
So the honest reading is that this is a program the project has verified against two things, and the table is the complete statement rather than a selection from a longer investigation. The footnote below it defines the marks, which tells you the author intended it as a complete list.
For anyone evaluating this, that table is the first thing to read. A context menu replacement is invisible when it works and fatal when it does not, and two rows is not much of a warranty.
The searching for similar tools by name, which people do for this category, mostly lands on other context menu replacements rather than on anything with a compatibility statement.
The build is xmake, and both supported compilers are named
Building from source means installing a build tool first, and that tool is not the usual one.
You install xmake, run it in the project directory, and follow the instructions it prints. Two compilers are named as supported: the clang-based driver for MSVC, and MSVC from a 2019 release onwards.
The development path is documented as a continuation of the build rather than a separate setup. Once a build has succeeded, you open the project directory in a standard editor, and the recommendation is to install the language server plugin so completion works.
That last sentence is the tell about how this project is developed: the editor is disposable and the build system is not. There is a committed formatter configuration and a committed language server configuration at the repository root, so a new contributor's editor behaves the same as everyone else's without them configuring anything.
The third party libraries are wired in as submodules rather than fetched by a package manager at build time, which keeps the dependency versions pinned to the repository.
QuickJS, a binding layer, and two reflection libraries
The credits list is the clearest statement of the architecture, because every entry has an obvious job.
The scripting layer is a small JavaScript engine, plus a separate C++ binding project for it, which is the standard pairing: you cannot call into a native engine from C++ without a generated or hand written binding layer.
Then there are two reflection libraries, one of them the project's own and one external. That is the piece that makes the JavaScript API pleasant: reflection is how a native object exposes methods and properties to a script, and having two in the tree suggests the author evaluated both.
For the windowing and graphics, there is a windowing library, an OpenGL loader, two vector rendering libraries with different characteristics, and a font rasteriser. So the interface is vector rendering with an embedded font stack rather than a bitmap theme.
One library in the list shares the project's own owner, which means the component layer and the shell are developed together. That is a good thing for a project this size and a bad thing if you were trying to replace one half independently.
A rewrite that says so in a parenthetical
The last section of the credits contains the sentence that decides whether you can trust the licensing.
An icon design is credited to a person. Then an inspiration credit for another project in the same category, followed immediately by a parenthetical: all code in this rewrite is original and unrelated to the inspired project.
That parenthetical does real work. Rewrites of this kind usually begin as forks, and a fork changes the licence obligations. Saying explicitly that no code came across means the licence is clean, which for a project that replaces a component of your operating system is the question you were going to ask anyway.
The maintenance framing sits at the very top of the readme instead. There is a warning that the project is still in active development and an invitation to file a bug report, in either of two languages.
The release numbers agree with that framing: the project is at a zero point one release, and the recent history is a handful of patch versions over the past year. So the expectation to set is a program that moves quickly and may change under you, which is fine for a personal machine and worth thinking about for anything else.
Editorial conclusion
Use Breeze Shell if you want the Windows context menu replaced rather than merely tweaked, and you are willing to run a portable build from a version-zero release with no support commitment. The animation model and the JavaScript extension point are the reasons to try it: the first makes the menu feel like a different application, and the second means you can change its contents without waiting for a feature. Do not adopt it if you need a documented support path, because the project describes itself as still in development and asks for bug reports, and do not assume it works with your file manager, since the compatibility table lists two programs. Before you rely on it, confirm your file manager is one of them, read the configuration document rather than guessing at the options, and keep in mind that the plugin market is a separate repository from the application.
Frequently asked questions
What is Breeze Shell?
An alternative context menu for Windows 10 and Windows 11, written in C++ and distributed as an archive you extract and run. It is animated, every animation is configurable and can be scaled or disabled, and the interface is about two megabytes.
How do I extend the Breeze Shell context menu?
Through an embedded JavaScript API. You register a menu listener and add items with a type, a name and an action, as the readme's shuffle example does. The full bindings are a declaration file in the repository, and scripts go to a separate plugins repository to reach the plugin market.
How do I configure Breeze Shell?
Through its configuration document, which covers options from item height to the background radius method. The configuration menu itself is reached by opening the application's data folder and right-clicking inside it, rather than from a settings entry in the menu.
Which file managers work with Breeze Shell?
The compatibility table lists two: Microsoft's file explorer as fully compatible and one third party file manager as mostly works, with a footnote defining the two marks. No other file manager is listed.
How do I build Breeze Shell from source?
Install xmake, run it in the project directory and follow the instructions it prints. Both the clang based driver for MSVC and MSVC 2019 or newer can build it, and once a build succeeds you can open the directory in an editor and install the clangd plugin for completion.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/std-microblock-breeze-shell)Star history chart for your README
[](https://hysenlabs.com/projects/std-microblock-breeze-shell)Was this useful?