Cursorless: a spoken language for structural code editing

The idea: refer to code by what it is, not where the cursor is

Cursorless is a spoken language for structural code editing, and the tagline, don't let the cursor slow you down, is a fairly literal description of the problem it targets. Structural editors generally fail for one reason: the interface is expressed in terms of cursor movement, so a change that spans three screens becomes a sequence of navigation steps that have to be planned and then executed exactly. Cursorless changes the unit of reference. It decorates every token on the screen and defines a spoken language for rapid, high-level semantic manipulation of structured text, so you say what the code is rather than where it is. The examples in the project documentation are the best illustration, since they are actual spoken commands: move arg air and each to after drum, chuck tail red pipe slice past end of file, and the curly repack ox one that shows a structural command being applied to a specific construct. The user is a developer who already works with voice, because the entire interface is a spoken grammar over the token tree.

Hats are the addressing scheme, and their colours carry meaning

The mechanism that makes this possible is the hat. Cursorless places a coloured, shaped marker over each token, and a spoken command combines a hat reference with an action, so the action applies to a well-defined set of targets rather than to whatever is under the cursor. The settings that control this are unusually revealing about how the system is designed. There are cursorless.hatSizeAdjustment and cursorless.hatVerticalOffset to tune the marker's size and vertical position as a percentage of font size, and cursorless.hatEnablement.colors and cursorless.hatEnablement.shapes to turn individual colours and shapes on or off. Then there are the penalties, cursorless.hatPenalties.colors and cursorless.hatPenalties.shapes, which set how much each hat colour and shape is penalised, with a stated rule: set the penalty to the number of syllables in that style, and Cursorless sorts every style combination by syllable count when referring to it. cursorless.maximumHatStylePenalty caps the penalty, and any style above it is not used. The design goal is therefore not just identification but speed of speech, since a two-syllable style is cheaper to say than a four-syllable one.

Installing: the marketplace extension and the Talon side

There is no package manager entry for this, and the project does not publish GitHub releases, so the install path is the Visual Studio Marketplace and the documentation. The extension listing in the repository links to the marketplace item pokey.cursorless, and the installation page on the Cursorless docs site is where the steps are described. The second half of the install is Talon, since the extension depends on it for voice input, and the repository carries a Talon user directory alongside a development one, so the user-facing commands are loaded from the Talon side.

After the extension is installed, the interface is tuned through ordinary VS Code settings, and the documentation lists the exact keys the extension contributes: `cursorless.showOnStart` for whether decorations appear on workspace start, `cursorless.hatSizeAdjustment` and `cursorless.hatVerticalOffset` for the size and vertical position of the hats, `cursorless.hatEnablement.colors` and `cursorless.hatEnablement.shapes` for switching individual colours and shapes on, `cursorless.hatPenalties.colors` and `cursorless.hatPenalties.shapes` for the per-style penalty, and `cursorless.maximumHatStylePenalty` for the cap above which a style is not used. Because these are standard editor settings, they live in the usual settings.json file of the workspace or of the user profile. cursorless.showOnStart in particular decides whether a screen full of hats appears the moment the workspace opens, which is a deliberate choice rather than something the extension forces on you.

The dependency on Talon is the whole cost of entry

The installation note is one line and it is the most important thing to understand before evaluating the project: currently depends on Talon, though a keyboard version is planned. Cursorless is therefore not a standalone VS Code extension today, it is the Cursorless side of a Talon voice setup, and Talon is what turns speech into commands. The instruction is to check the installation page and the documentation for the steps, and there is a documentation site plus a video channel for the learning curve. The reason to say this plainly is that the interesting engineering in Cursorless is largely independent of the voice input, which is why a keyboard version is on the roadmap: the extension already addresses the token tree, applies structural operations and renders the hats, and the spoken grammar is one input surface over that machinery. Until that keyboard version exists, an evaluation requires a Talon installation, a working speech pipeline and a microphone, and those are three separate sources of friction before you can test the idea.

A TypeScript and Python monorepo with a Talon side

The repository is a pnpm workspace with packages/ holding the packages, and it spans two languages because the Talon side is Python. The root package.json calls itself the root of the Cursorless monorepo, pins pnpm as the package manager with a preinstall hook that rejects other package managers via only-allow, and requires Node 24.14.0 or newer. The build and check scripts are recursive, so build, clean, typecheck and test all run across every package. Linting is layered: typecheck, a meta-updater check, syncpack for dependency version consistency, oxlint for TypeScript with warnings denied, stylelint for CSS and SCSS, and oxfmt for formatting. There is a generate-grammar script, which is the hook that ties the spoken language to the implementation, and a transform-recorded-tests script for converting recorded test fixtures. The Python side is configured in pyproject.toml, which requires Python 3.11 exactly, matching the note that public Talon 0.4 uses Python 3.11, and it runs ruff with a rule set covering pycodestyle, pyflakes, pyupgrade, bugbear, simplify, isort, comprehensions, import conventions, return practices, FURB and string joining. Ruff is configured to ignore several modern syntax rules because they are not supported in Talon 0.4 actions, which is a nice illustration of the constraint the host imposes.

Three Talon directories, and what they are for

The tree carries three Talon-related directories, and the naming tells you the project's structure and its development workflow. cursorless-talon/ is the Talon user side, the commands and files that Talon loads. cursorless-talon-dev/ is the development counterpart, for iterating on the Talon side without touching a live setup. cursorless-everywhere-talon/ is a broader distribution, a Talon bundle meant to be usable across setups rather than only with this project. Alongside them sit a packages/ directory for the TypeScript packages, including the VS Code application and the engine that the pyproject reference to packages/lib-engine and packages/lib-common shows, resources/ for images and the playground, and the usual project infrastructure: a pnpm-workspace.yaml, flake.nix and flake.lock for a Nix development environment, netlify.toml for the documentation site, an .nvmrc, oxlint.config.mts, stylelint.config.mjs, an AGENTS.md, a CONTRIBUTING.md, a SECURITY.md and a CHANGELOG.md. The pre-commit configuration in the tree means formatting and lint rules are enforced before a commit lands rather than by review.

What the project does not promise

The limits are worth stating because the marketing phrase, coding by voice at speeds not possible with a keyboard, sets a high bar. First, the keyboard version does not exist yet, so the structural editing capability is currently only reachable through Talon, and a developer without a voice pipeline cannot try the core idea at all. Second, the spoken grammar is a learning curve: a structural editing language is only fast once the commands are in muscle memory, and the syllable-based hat penalty system exists precisely because command length matters, which confirms that the interface is not trivially learnable. Third, Cursorless is an editor-agnostic idea implemented as a VS Code extension, so the token decoration and structural operations are tied to that editor's API and its notion of a token tree. Fourth, the repository publishes no GitHub releases, so there is no version history to inspect and no semantic version to pin in a description of what you installed; the marketplace listing and the main branch are the release channel. The last push to the repository was on 2026-10-06, so the work is current, but the packaging is informal.

How this differs from a normal keybinding-driven structural editor

The closest alternatives are keyboard-driven structural editors, where a command such as a delete-node or an extract operation applies to a selection defined by a tree traversal rather than by cursor position, and where the input is a key sequence. The difference in approach is in the addressing layer, not the editing layer. Both systems express edits as operations over a syntax tree. A keyboard system encodes the traversal and the target in the keys themselves, so you can reach any node deterministically once you have learned the grammar, at the cost of a vocabulary that only exists in that editor. Cursorless separates the two layers: the target is named by a hat, and the operation is spoken. That buys two things a pure keybinding system struggles with, which are a target that can be referred to without navigating to it first, and a spoken grammar where multi-syllable target names are penalised and sorted, so common things stay short to say. The cost is the dependency on speech recognition and on Talon, which is the thing the keyboard version is meant to remove.

Editorial conclusion

Adopt Cursorless if you edit code by voice today, or if you are willing to install Talon and learn a structural editing vocabulary, because the payoff comes from targeting code semantically rather than from the extension alone. Do not adopt it expecting a keyboard-driven structural editor, since the project states that the current version depends on Talon and that a keyboard version is only planned. Before you install, read the settings that control hat size, colours, shapes and penalties, because the penalty values determine how Cursorless sorts spoken style combinations by syllable count, and note that the repository publishes no GitHub releases, so you install from the marketplace and track the main branch rather than a version tag.

Frequently asked questions

Official sources

1. cursorless-dev/cursorless on GitHub
2. Issues
3. License: MIT
4. Project website
5. README