⌨️ IntelliKeyPort

Pick a keymap in one IntelliJ-based IDE — IntelliJ IDEA, PhpStorm, WebStorm, PyCharm, GoLand, DataGrip, Rider, … — and IntelliKeyPort reproduces it in the VS Code family: VS Code, VS Code Insiders, VSCodium, Cursor, Windsurf, Antigravity.

It does the whole trip from A to Z:

Every path is derived at runtime from the OS and the IDE's product-info.json, so nothing is tied to one machine or user. Re-run it whenever your JetBrains keymap changes and every editor stays in sync — the shortcuts that matter are identical everywhere.

  ┌────────────────────────────────────────────────────────────┐
  │  1.  Pick the right keymap in your IntelliJ IDE             │  Settings → Keymap
  │  2.  Run the tool                          ./port.py        │
  │  3.  Tick the editors to import into       [x] Code  [x] …  │  checkbox prompt
  │  4.  Done — reload each editor window                       │
  └────────────────────────────────────────────────────────────┘

./port.py with no arguments resolves the active keymap, regenerates keybindings.generated.json, and — when more than one editor is installed, and you are on a terminal — shows an arrow-key checkbox list so you tick the targets.

git clone https://github.com/JtheGunner/intelli-key-port.git intelli-key-port
cd intelli-key-port

# macOS / Linux
./port.py

# Ctrl-based keymap (Windows / XWin style) on a Mac? add the matching layer
./port.py --layer windows-keymap

#  Windows
python port.py

IntelliKeyPort is a small set of plain-Python scripts plus one hand-maintained data file. port.py runs a three-stage pipeline — read it top to bottom:

   "IntelliJ IDE · your active keymap"
     │
   ▼   resolve_keymap.py: find the IDE, flatten the parent chain
     "source/<name>.resolved.xml"
     │
   ▼   generate.py: actions → commands, keys → keys
     "keybindings.generated.json + report.md"
     │
   ▼   install.py: timestamped backup, then write
     "VS Code · Cursor · Windsurf · Antigravity · …"

Each stage is also a standalone script; port.py just runs the three in order and stops at the first failure.

generate.py does a faithful, mechanical translation of your JetBrains keymap. The curated layers are the small human part on top of it — the place for the handful of decisions a machine cannot make for you.

Layers stack in order: overrides.jsonc, then each --layer in the order given. A later layer wins. Its entries come later in the file, and VS Code applies "last entry wins". Its manualActionCommand rows replace earlier ones, and dropActions from all layers add up. Without --layer you get a plain, faithful port. generate.py tells you when a Ctrl-based keymap on a Mac probably wants --layer windows-keymap.

Every layer is a JSONC object with up to three lists:

After editing a layer, re-run ./port.py with the same --layer flags (or add --skip-resolve to skip the IDE read).

Everything runs through port.py. Its flags are flat; it routes each one to the stage that needs it.

./port.py

./port.py --product IntelliJIdea

./port.py --keymap "macOS"

./port.py --app "/Applications/WebStorm.app"

./port.py --config-dir "/path/to/WebStorm2025.2"

./port.py --only Code --only Cursor

./port.py --dry-run

./port.py --file other.json

./port.py --layer windows-keymap --layer ~/dotfiles/mine.jsonc

./port.py --skip-resolve

./port.py --skip-install

./port.py --sync-vendor

Each stage also runs on its own, with the same options:

python3 resolve_keymap.py [--product … --keymap … --app … --config-dir …]
python3 generate.py
python3 install.py        [--only NAME … --dry-run --file PATH]
python3 sync_vendor.py

generate.py builds a delta file. VS Code already ships hundreds of default bindings and the k--kato.intellij-idea-keybindings extension adds a few hundred more; keybindings.generated.json only adds, removes or overrides on top of those. It has two blocks, marked by // ---- comments:

Every run writes a report.md that accounts for all of it. The figures below are from the bundled sample keymap — the full output is committed as the example report (source/default.xml, the stock $default keymap, 485 actions, no layers):

report.md also lists key collisions: resolved by keymap order (earlier action wins), left unresolved (fix in a layer), or overridden on purpose.

k--kato.intellij-idea-keybindings is the base layer in every target editor — it covers the many IntelliJ actions that have no entry in its own command table. IntelliKeyPort's output loads after it and re-binds everything it maps to Ctrl(PC muscle memory, matching the resolved keymap). Install it in each editor:

code   --install-extension k--kato.intellij-idea-keybindings
cursor --install-extension k--kato.intellij-idea-keybindings

Extended key codes (#100XXXX) are decoded to their character and mapped to a VS Code scan-code token, ensuring keybindings follow the physical key across different keyboard layouts.

Reload each editor window, then spot-check with the editor focused (not the terminal). With the bundled $default keymap (or any Ctrl-based one) plus --layer windows-keymap:

Contributions are welcome — bug reports, new IDE/editor coverage, better action mappings.

• 🧭Report a mapping gap. Run ./port.py and open report.md. If an action you use is under "No VS Code command mapping" but a VS Code command does exist, add the pair to manualActionCommand in overrides.jsonc and send a PR.
• 🧠Add a JetBrains product → extend the PRODUCTS table in resolve_keymap.py.
• 💻Add an editor → extend the EDITORS table in install.py.
• 🧪Run the tests before opening a PR:

  python3 -m unittest discover -s tests -v

• 🇬🇧Keep developer-facing text (code, comments, commit messages) in English. Commit messages follow Conventional Commits (feat:, fix:, docs:, …).
• 🚫Don't commit the per-user build outputs — they are git-ignored for a reason.

Released under the MIT License — see LICENSE. MIT is a good fit here: the project is a thin tool, and the mapping data it bundles under vendor/kkato/ is itself MIT-licensed.

• 💡Inspired by vlad-ogol/intellij-keymap-xml-exporter — the idea of turning an IntelliJ keymap into something portable.
• 🗺Mapping data from kasecato/vscode-intellij-idea-keybindings (k--kato.intellij-idea-keybindings). Its ActionIdCommandMapping.json and KeystrokeKeyMapping.json do the heavy lifting of matching IntelliJ actions and AWT keystrokes to their VS Code equivalents — without them this would have been a slog.