Kando: A Cross-Platform Pie Menu for Windows, macOS and Linux

The problem Kando solves: a radial launcher instead of a dock or a search box

Most desktop launchers assume a linear input: you type a name, scroll a list, or click an icon in a bar. Kando takes the opposite position. It draws a pie menu, and the direction you move in selects the entry. The README calls it "a cross-platform pie menu for your desktop" and describes the interaction as "unconventional, fast, highly efficient, and fun". That word choice matters, because the tool is not trying to replace your application menu with a faster search field. It is trying to replace the search step entirely.

The intended audience is anyone whose primary pointing device is not a mouse. The README lists mouse, stylus, touch and controller input, and adds that Kando "can also be efficiently controlled with a keyboard". A stylus or a game controller has no comfortable way to type a launcher query, so a radial layout that maps directions to targets fits the hardware. A keyboard user gets a shortcut-driven path instead.

The project is a desktop application, not a library. It runs on Windows, macOS and Linux, and the README notes that on Linux "most desktop environments are supported, however some require additional configuration", pointing to a dedicated installation guide. That sentence is the honest boundary: cross-platform does not mean uniform behaviour across every Linux session.

How Kando works: Electron shell, native input module, JSON menus

The repository layout shows an Electron Forge application. The top level contains forge.config.ts, webpack.main.config.ts, webpack.renderer.config.ts and webpack.rules.ts, which is the standard split between a main process and a renderer process. package.json sets "main" to ".webpack/main", so the packaged entry point is the webpack output rather than a source file.

There is a native component. The postinstall script runs "cmake-js compile", and a CMakeLists.txt sits at the repository root alongside TypeScript configuration. That combination implies a compiled module loaded by the Electron process, which is how a desktop tool would read global input outside its own window. The README does not document the module's API, so the exact boundary between the native code and the TypeScript layer cannot be confirmed from the repository documentation.

The renderer side is React: @types/react and @types/react-dom are devDependencies, and @formkit/auto-animate is pinned at 0.8.2, which suggests animated transitions in the menu UI. Menus themselves are configuration rather than code. The README separates a Usage Guide from a Configuration Guide, and the repository carries a locales/ directory plus i18next.config.ts and scripts named i18n:extract and i18n:types, so menu labels and UI strings go through a translation pipeline. The data flow is therefore: a global input event triggers the Electron app, the renderer draws the pie menu from a menu definition, and the selected item runs an action such as launching an application, simulating a keyboard shortcut or opening a file.

Installing Kando and opening the example menu

The README does not put install commands in the repository. It directs readers to per-platform pages: installation-on-windows, installation-on-macos and installation-on-linux on kando.menu. There is no npm or Homebrew command listed in the README, so treat the release page and those three pages as the source of truth for your platform.

Building from source is documented separately at kando.menu/compile-from-source. The README is explicit that this path is "only required if you want to contribute to the project or if you want to use the latest features that are not yet released". The scripts in package.json are the ones that page would use. The start script launches Electron Forge through tsx, and postinstall compiles the native module, so a source checkout needs a working CMake toolchain before the first run.

npm install
npm start

The first command triggers the postinstall hook, which runs cmake-js compile. If CMake or a C++ toolchain is missing, that step is where the install fails, not at the Electron download. The second command starts the app in development mode.

Once Kando is running, the README gives one concrete thing to try: "Kando comes with an example menu which you can open by pressing Ctrl+Space on most platforms". That is the fastest way to see whether radial selection suits you. The README then points to the Usage Guide for interaction basics and the Configuration Guide for building your own menus, which is where the real work of adopting the tool begins.

For contributors, the test and lint entry points are ordinary npm scripts. The test script runs ts-mocha over test/**/*.spec.ts, and lint runs eslint over the repository.

npm run lint
npm test

Where Kando is the wrong tool

The clearest limitation is release maturity. The most recent release in the release list is v3.0.0-beta.1 from 2026-08-29, preceded by v3.0.0-alpha.1 in July and v2.3.1 in June. If you want a launcher you configure once and forget, a beta line is the wrong branch to start on, and the README offers no rollback procedure for moving between the 2.x and 3.x configurations. The README does not document migration between major versions at all, so the cost of trying 3.0 and returning to 2.3.1 is unknown from the documentation.

Linux is the second boundary. The README states that most desktop environments are supported but "some require additional configuration". That is a soft way of saying the global input hook depends on the session. On a desktop environment that is not covered, Kando may install cleanly and still fail to receive the trigger that opens a menu, which is a harder failure to diagnose than a missing dependency.

There is also an input-modality mismatch. A pie menu rewards users who can point and flick in one motion. If your habit is to type three letters and press Enter, Kando adds a step rather than removing one. The keyboard control the README mentions exists, but it is a fallback for an interface designed around direction, not a faster search field.

Finally, packaging. This is an Electron desktop app with a compiled native module. It is not something you add to a server image or a CI container, and it will not help you automate a headless machine.

Kando compared with a keyboard launcher

The natural alternative is a keyboard-driven launcher such as Ulauncher or Albert on Linux, or the built-in Spotlight and PowerToys Run on macOS and Windows. The difference is not speed in the abstract; it is which part of the interaction is eliminated.

A keyboard launcher eliminates the pointer. You keep your hands on the keys, type a fragment of the application name, and the launcher filters a list. Its cost is that you must know, or guess, a string that matches the target. Its strength is that the candidate set can be large, because typing narrows it quickly.

Kando eliminates the query. The menu shows the candidates as sectors, and you select by direction, which means the target set has to stay small enough to be distinguishable by angle. That is a real design constraint, not a stylistic one. A radial menu with thirty entries is unusable; a text field with thirty thousand is fine. Kando's README does not describe a search-within-menu mechanism, so the practical ceiling on menu size is set by how many directions a person can hit reliably.

The two approaches also differ in input hardware. A keyboard launcher assumes a keyboard. Kando assumes a pointer, and the README extends that to stylus, touch and controller. If your machine is a tablet, a pen display or a couch setup with a gamepad, the keyboard launcher is the awkward option and Kando is the natural one.

Maintenance, licence and the cost of following the 3.0 line

The repository is not archived, and the last push was on 2026-09-21, so the project is being worked on. The release list gives three dated releases but no stated cadence, and it does not state a support window for 2.x. The practical upgrade cost is therefore tied to the configuration format: the README routes menu creation through a Configuration Guide rather than describing the schema in the repository, so any change to that schema between 2.3.1 and 3.0 would be documented on the website, not in the README.

Licensing needs a careful read rather than an assumption. The repository metadata is flagged NOASSERTION, while package.json declares "license": "MIT". The README's own header carries SPDX tags: the file is CC-BY-4.0, and the source files carry SPDX-FileCopyrightText and SPDX-License-Identifier lines. The repository also contains a LICENSES/ directory and a REUSE.toml, which is the REUSE compliance convention, and the README links a REUSE badge. A NOASSERTION flag on the repository page usually means the automated detector could not reduce the licence set to a single identifier, which is consistent with a project that mixes an MIT application licence with CC-BY-4.0 documentation. If you plan to redistribute Kando or bundle it into a product, read LICENSE.md and the LICENSES/ directory yourself; the repository documentation here is not enough to tell you the terms of every file.

One more cost to note: the README thanks SignPath.io and the SignPath Foundation for the code signing certificate used for the Windows installers, and links a code-signing policy page. That is a positive signal for Windows users, since an unsigned installer is a common friction point for small desktop projects.

Editorial conclusion

Adopt Kando if you want a radial launcher driven by mouse, stylus, touch or controller input and you are comfortable installing a desktop app rather than a package from a language registry. Do not adopt it if you need a stable, feature-frozen launcher: the newest release listed is v3.0.0-beta.1, and the README points Linux users at a per-desktop-environment installation guide because some environments need extra configuration. Before committing, check the licence file, since the repository is flagged NOASSERTION while package.json declares MIT, and confirm that your desktop environment is covered by the Linux installation page.

Frequently asked questions

Official sources

1. Issues
2. kando-menu/kando on GitHub
3. Project website
4. README
5. Releases