Default Keybindings

VSpaceCode

Key Binding: ␣

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ ␣`	Commands	command	`workbench.action.showCommands`
`␣ ↹`	Last buffer	commands	`workbench.action.quickOpenPreviousRecentlyUsedEditorInGroup` `list.select`
`␣ !`	Show terminal	command	`workbench.action.terminal.focus`
`␣ "`	Open new external terminal	command	`workbench.action.terminal.openNativeConsole`
`␣ $`	Run Recent Command in Terminal	command	`workbench.action.terminal.runRecentCommand`
`␣ '`	Show terminal	command	`workbench.action.terminal.focus`
`␣ *`	Search in project with selection	commands	`editor.action.addSelectionToNextFindMatch` `workbench.action.findInFiles` `search.action.focusSearchList`
`␣ .`	Repeat most recent action	command	`whichkey.repeatMostRecent`
`␣ /`	Search in project	command	`workbench.action.findInFiles`
`␣ 0`	Focus on files explorer	command	`workbench.files.action.focusFilesExplorer`
`␣ 1`	Focus 1st window	command	`workbench.action.focusFirstEditorGroup`
`␣ 2`	Focus 2nd window	command	`workbench.action.focusSecondEditorGroup`
`␣ 3`	Focus 3rd window	command	`workbench.action.focusThirdEditorGroup`
`␣ 4`	Focus 4th window	command	`workbench.action.focusFourthEditorGroup`
`␣ 5`	Focus 5th window	command	`workbench.action.focusFifthEditorGroup`
`␣ 6`	Focus 6th window	command	`workbench.action.focusSixthEditorGroup`
`␣ 7`	Focus 7th window	command	`workbench.action.focusSeventhEditorGroup`
`␣ 8`	Focus 8th window	command	`workbench.action.focusEighthEditorGroup`
`␣ ;`	Toggle comment	command	`editor.action.commentLine`
`␣ ?`	Search keybindings	command	`whichkey.searchBindings`
`␣ v`	Smart select/expand region	transient	`editor.action.smartSelect.grow`
`␣ :`	+Tasks	bindings	N/A
`␣ b`	+Buffers	bindings	N/A
`␣ c`	+Compile/Comments	bindings	N/A
`␣ d`	+Debug	bindings	N/A
`␣ e`	+Errors	bindings	N/A
`␣ f`	+File	bindings	N/A
`␣ g`	+Git	bindings	N/A
`␣ h`	+Help	bindings	N/A
`␣ i`	+Insert	bindings	N/A
`␣ j`	+Jump/Join/Split	bindings	N/A
`␣ l`	+Layouts	bindings	N/A
`␣ m`	+Major	conditional	N/A
`␣ p`	+Project	bindings	N/A
`␣ q`	+Quit	bindings	N/A
`␣ r`	+Resume/Repeat	bindings	N/A
`␣ s`	+Search/Symbol	bindings	N/A
`␣ t`	+Toggles	bindings	N/A
`␣ w`	+Window	bindings	N/A
`␣ x`	+Text	bindings	N/A
`␣ z`	+Zoom/Fold	bindings	N/A
`␣ D`	+Diff/Compare	bindings	N/A
`␣ F`	+Frame	bindings	N/A
`␣ S`	+Show	bindings	N/A
`␣ T`	+UI toggles	bindings	N/A

Smart select/expand region

Key Binding: ␣ v

Type: transient

Key Binding	Name	Type	Command(s)
`v`	Grow selection	command	`editor.action.smartSelect.grow`
`V`	Shrink selection	command	`editor.action.smartSelect.shrink`

+Tasks

Key Binding: ␣ :

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ : .`	Rerun last task	command	`workbench.action.tasks.reRunTask`
`␣ : :`	Run task	command	`workbench.action.tasks.runTask`
`␣ : b`	Run build tasks	command	`workbench.action.tasks.build`
`␣ : c`	Configure task runner	command	`workbench.action.tasks.configureTaskRunner`
`␣ : g`	Show running tasks	command	`workbench.action.tasks.showTasks`
`␣ : l`	Show task log	command	`workbench.action.tasks.showLog`
`␣ : t`	Run test task	command	`workbench.action.tasks.test`
`␣ : x`	Terminate task	command	`workbench.action.tasks.terminate`
`␣ : R`	Restart running task	command	`workbench.action.tasks.restartTask`

+Buffers

Key Binding: ␣ b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ b 0`	Last buffer in window	command	`workbench.action.lastEditorInGroup`
`␣ b 1`	First buffer in window	command	`workbench.action.openEditorAtIndex1`
`␣ b 2`	2nd buffer in window	command	`workbench.action.openEditorAtIndex2`
`␣ b 3`	3rd buffer in window	command	`workbench.action.openEditorAtIndex3`
`␣ b 4`	4th buffer in window	command	`workbench.action.openEditorAtIndex4`
`␣ b 5`	5th buffer in window	command	`workbench.action.openEditorAtIndex5`
`␣ b 6`	6th buffer in window	command	`workbench.action.openEditorAtIndex6`
`␣ b 7`	7th buffer in window	command	`workbench.action.openEditorAtIndex7`
`␣ b 8`	8th buffer in window	command	`workbench.action.openEditorAtIndex8`
`␣ b 9`	9th buffer in window	command	`workbench.action.openEditorAtIndex9`
`␣ b b`	Show all buffers	command	`workbench.action.showAllEditorsByMostRecentlyUsed`
`␣ b d`	Close active buffer	command	`workbench.action.closeActiveEditor`
`␣ b h`	Move buffer into left window	command	`workbench.action.moveEditorToLeftGroup`
`␣ b j`	Move buffer into below window	command	`workbench.action.moveEditorToBelowGroup`
`␣ b k`	Move buffer into above window	command	`workbench.action.moveEditorToAboveGroup`
`␣ b l`	Move buffer into right window	command	`workbench.action.moveEditorToRightGroup`
`␣ b n`	Next buffer	command	`workbench.action.nextEditor`
`␣ b p`	Previous buffer	command	`workbench.action.previousEditor`
`␣ b s`	Scratch buffer	command	`workbench.action.files.newUntitledFile`
`␣ b t`	Pin buffer	command	`workbench.action.pinEditor`
`␣ b u`	Reopen closed buffer	command	`workbench.action.reopenClosedEditor`
`␣ b B`	Show all buffers in active window	command	`workbench.action.showEditorsInActiveGroup`
`␣ b H`	Move buffer into left window	command	`workbench.action.moveEditorToLeftGroup`
`␣ b J`	Move buffer into below window	command	`workbench.action.moveEditorToBelowGroup`
`␣ b K`	Move buffer into above window	command	`workbench.action.moveEditorToAboveGroup`
`␣ b L`	Move buffer into right window	command	`workbench.action.moveEditorToRightGroup`
`␣ b M`	Close other buffers	command	`workbench.action.closeOtherEditors`
`␣ b P`	Paste clipboard to buffer	commands	`editor.action.selectAll` `editor.action.clipboardPasteAction`
`␣ b R`	Revert the current buffer	command	`workbench.action.files.revert`
`␣ b T`	Unpin buffer	command	`workbench.action.unpinEditor`
`␣ b Y`	Copy buffer to clipboard	command	`vspacecode.copyWholeBuffer`
`␣ b N`	+New Buffer	bindings	N/A

+Compile/Comments

Key Binding: ␣ c

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ c c`	Compile project	command	`workbench.action.tasks.build`
`␣ c l`	Toggle line comment	command	`editor.action.commentLine`
`␣ c n`	Next error	command	`editor.action.marker.nextInFiles`
`␣ c N`	Previous error	command	`editor.action.marker.prevInFiles`

+Debug

Key Binding: ␣ d

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ d c`	Continue debug	command	`workbench.action.debug.continue`
`␣ d d`	Start debug	command	`workbench.action.debug.start`
`␣ d i`	Step into	command	`workbench.action.debug.stepInto`
`␣ d j`	Jump to cursor	command	`debug.jumpToCursor`
`␣ d o`	Step out	command	`workbench.action.debug.stepOut`
`␣ d p`	Pause debug	command	`workbench.action.debug.pause`
`␣ d s`	Step over	command	`workbench.action.debug.stepOver`
`␣ d v`	REPL	command	`workbench.debug.action.toggleRepl`
`␣ d w`	Focus on watch window	command	`workbench.debug.action.focusWatchView`
`␣ d C`	Continue to cursor	command	`editor.debug.action.runToCursor`
`␣ d D`	Run without debugging	command	`workbench.action.debug.run`
`␣ d R`	Restart debug	command	`workbench.action.debug.restart`
`␣ d S`	Stop debug	command	`workbench.action.debug.stop`
`␣ d W`	Add to watch	command	`editor.debug.action.selectionToWatch`
`␣ d b`	+Breakpoint	bindings	N/A

+Errors

Key Binding: ␣ e

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ e .`	Error transient	transient	N/A
`␣ e e`	Show error	command	`editor.action.showHover`
`␣ e f`	Fix error	command	`editor.action.quickFix`
`␣ e l`	List errors	command	`workbench.actions.view.problems`
`␣ e n`	Next error	command	`editor.action.marker.nextInFiles`
`␣ e p`	Previous error	command	`editor.action.marker.prevInFiles`
`␣ e N`	Previous error	command	`editor.action.marker.prevInFiles`

+File

Key Binding: ␣ f

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ f f`	Open file/folder	command	`file-browser.open`
`␣ f l`	Change file language	command	`workbench.action.editor.changeLanguageMode`
`␣ f n`	New file	command	`explorer.newFile`
`␣ f o`	+Open with	command	`explorer.openWith`
`␣ f r`	+Open recent	command	`workbench.action.openRecent`
`␣ f s`	Save file	command	`workbench.action.files.save`
`␣ f t`	Toggle tree/explorer view	conditional	N/A
`␣ f w`	Open active in new window	command	`workbench.action.files.showOpenedFileInNewWindow`
`␣ f D`	Delete current file	commands	`workbench.files.action.showActiveFileInExplorer` `deleteFile`
`␣ f L`	Locate file	command	`revealFileInOS`
`␣ f R`	Rename file	commands	`revealInExplorer` `renameFile`
`␣ f S`	Save all files	command	`workbench.action.files.saveAll`
`␣ f T`	Show active file in tree/explorer view	command	`workbench.files.action.showActiveFileInExplorer`
`␣ f e`	+Emacs/VSpaceCode	bindings	N/A
`␣ f i`	+Indentation	bindings	N/A
`␣ f y`	+Yank	bindings	N/A

+Git

Key Binding: ␣ g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ g b`	Blame file	command	`magit.blame-file`
`␣ g c`	Clone	command	`git.clone`
`␣ g i`	Initialize repository	command	`git.init`
`␣ g m`	Magit dispatch	command	`magit.dispatch`
`␣ g s`	Status	command	`magit.status`
`␣ g S`	Stage file	command	`magit.stage-file`
`␣ g U`	Unstage file	command	`magit.unstage-file`
`␣ g f`	+File	bindings	N/A

+Help

Key Binding: ␣ h

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ h d`	Open VSCode Documentation	command	`workbench.action.openDocumentationUrl`
`␣ h k`	Open global key bindings	command	`workbench.action.openGlobalKeybindings`
`␣ h D`	Open VSpaceCode Documentation	command	`vspacecode.openDocumentationUrl`
`␣ h I`	Report VSCode Issue	command	`workbench.action.openIssueReporter`
`␣ h T`	Open VSCode Tutorial	command	`workbench.action.showInteractivePlayground`

+Insert

Key Binding: ␣ i

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ i j`	Insert line below	command	`editor.action.insertLineAfter`
`␣ i k`	Insert line above	command	`editor.action.insertLineBefore`
`␣ i s`	Insert snippet	command	`editor.action.insertSnippet`

+Jump/Join/Split

Key Binding: ␣ j

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ j +`	Format buffer	command	`editor.action.formatDocument`
`␣ j =`	Format region or buffer	command	`editor.action.format`
`␣ j c`	Jump to previous change	command	`workbench.action.editor.previousChange`
`␣ j i`	Jump to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ j j`	Jump to character	command	`vim.remap`
`␣ j l`	Jump to line	command	`vim.remap`
`␣ j n`	Split new line	command	`lineBreakInsert`
`␣ j v`	Jump to outline/variables	command	`breadcrumbs.focusAndSelect`
`␣ j w`	Jump to word	command	`vim.remap`
`␣ j C`	Jump to next change	command	`workbench.action.editor.nextChange`
`␣ j I`	Jump to symbol in project	command	`workbench.action.showAllSymbols`

+Layouts

Key Binding: ␣ l

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ l d`	Close workspace	command	`workbench.action.closeFolder`

+Major

Key Binding: ␣ m

Type: conditional

Condition	Name	Type	Command(s)
`languageId:agda`	Agda	bindings	N/A
`languageId:clojure`	Clojure	bindings	N/A
`languageId:coq`	coq	bindings	N/A
`languageId:cpp`	C++	bindings	N/A
`languageId:csharp`	C#	bindings	N/A
`languageId:dart`	Dart/Flutter	bindings	N/A
`languageId:elixir`	Elixir	bindings	N/A
`languageId:fsharp`	F#	bindings	N/A
`languageId:go`	Go	bindings	N/A
`languageId:java`	Java	bindings	N/A
`languageId:javascript`	JavaScript	bindings	N/A
`languageId:julia`	Julia	bindings	N/A
`languageId:latex`	LaTeX	bindings	N/A
`languageId:markdown`	Markdown	bindings	N/A
`languageId:objectpascal`	ObjectPascal	bindings	N/A
`languageId:php`	PHP	bindings	N/A
`languageId:python`	Python	bindings	N/A
`languageId:quarto`	quarto	bindings	N/A
`languageId:r`	R	bindings	N/A
`languageId:ruby`	Ruby	bindings	N/A
`languageId:rust`	Rust	bindings	N/A
`languageId:typescript`	TypeScript	bindings	N/A
`languageId:cuda-cpp`	CUDA-C++	bindings	N/A

+Project

Key Binding: ␣ p

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ p c`	Compile project	command	`workbench.action.tasks.build`
`␣ p f`	+Find file in project	command	`workbench.action.quickOpen`
`␣ p l`	+Switch project	command	`workbench.action.openRecent`
`␣ p p`	+Switch project	command	`workbench.action.openRecent`
`␣ p t`	Show tree/explorer view	command	`workbench.view.explorer`
`␣ p R`	+Replace in files	command	`workbench.action.replaceInFiles`
`␣ p T`	Test project	command	`workbench.action.tasks.test`

+Quit

Key Binding: ␣ q

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ q f`	Close frame	command	`workbench.action.closeWindow`
`␣ q q`	Close frame	command	`workbench.action.closeWindow`
`␣ q r`	Reload frame	command	`workbench.action.reloadWindow`
`␣ q s`	Save all and close frame	commands	`workbench.action.files.saveAll` `workbench.action.closeWindow`
`␣ q Q`	Quit application	command	`workbench.action.quit`
`␣ q R`	Reload frame with extensions disabled	command	`workbench.action.reloadWindowWithExtensionsDisabled`

+Resume/Repeat

Key Binding: ␣ r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ r .`	Repeat recent actions	command	`whichkey.repeatRecent`
`␣ r b`	Recent buffers	command	`workbench.action.showAllEditorsByMostRecentlyUsed`
`␣ r s`	Search in project	command	`workbench.action.findInFiles`

+Search/Symbol

Key Binding: ␣ s

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ s c`	Clear highlight	command	`vim.remap`
`␣ s e`	Edit symbol	command	`editor.action.rename`
`␣ s h`	Highlight symbol	transient	`editor.action.wordHighlight.trigger`
`␣ s j`	Jump to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ s p`	Search in project	command	`workbench.action.findInFiles`
`␣ s r`	Search all references	command	`editor.action.referenceSearch.trigger`
`␣ s s`	Fuzzy search in current buffer	command	`fuzzySearch.activeTextEditorWithCurrentSelection`
`␣ s J`	Jump to symbol in project	command	`workbench.action.showAllSymbols`
`␣ s P`	Search in project with selection	commands	`editor.action.addSelectionToNextFindMatch` `workbench.action.findInFiles`
`␣ s R`	Search all references in side bar	command	`references-view.find`
`␣ s S`	Fuzzy search with selection in current buffer	commands	`editor.action.addSelectionToNextFindMatch` `fuzzySearch.activeTextEditorWithCurrentSelection`

+Toggles

Key Binding: ␣ t

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ t c`	Toggle find case sensitive	command	`toggleFindCaseSensitive`
`␣ t l`	Toggle word wrap	command	`editor.action.toggleWordWrap`
`␣ t w`	Toggle render whitespace	command	`editor.action.toggleRenderWhitespace`

+Window

Key Binding: ␣ w

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ w -`	Split window below	command	`workbench.action.splitEditorDown`
`␣ w /`	Split window right	command	`workbench.action.splitEditor`
`␣ w =`	Reset window sizes	command	`workbench.action.evenEditorWidths`
`␣ w [`	Shrink window	transient	`workbench.action.decreaseViewSize`
`␣ w ]`	Enlarge window	transient	`workbench.action.increaseViewSize`
`␣ w 1`	Single column window layout	command	`workbench.action.editorLayoutSingle`
`␣ w 2`	Double column window layout	command	`workbench.action.editorLayoutTwoColumns`
`␣ w 3`	Triple column window layout	command	`workbench.action.editorLayoutThreeColumns`
`␣ w 4`	Grid window layout	command	`workbench.action.editorLayoutTwoByTwoGrid`
`␣ w d`	Close window	command	`workbench.action.closeEditorsInGroup`
`␣ w h`	Focus window left	command	`workbench.action.navigateLeft`
`␣ w j`	Focus window down	command	`workbench.action.navigateDown`
`␣ w k`	Focus window up	command	`workbench.action.navigateUp`
`␣ w l`	Focus window right	command	`workbench.action.navigateRight`
`␣ w m`	Maximize window	command	`workbench.action.toggleMaximizeEditorGroup`
`␣ w o`	Switch frame	command	`workbench.action.quickSwitchWindow`
`␣ w s`	Split window below	command	`workbench.action.splitEditorDown`
`␣ w v`	Split window right	command	`workbench.action.splitEditor`
`␣ w w`	Focus next window	command	`workbench.action.focusNextGroup`
`␣ w x`	Close all windows	command	`workbench.action.closeAllGroups`
`␣ w z`	Combine all buffers	command	`workbench.action.joinAllGroups`
`␣ w D`	Close all other windows	command	`workbench.action.closeEditorsInOtherGroups`
`␣ w F`	Open new empty frame	command	`workbench.action.newWindow`
`␣ w H`	Move window left	command	`workbench.action.moveActiveEditorGroupLeft`
`␣ w J`	Move window down	command	`workbench.action.moveActiveEditorGroupDown`
`␣ w K`	Move window up	command	`workbench.action.moveActiveEditorGroupUp`
`␣ w L`	Move window right	command	`workbench.action.moveActiveEditorGroupRight`
`␣ w M`	Maximize window without hiding others	command	`workbench.action.toggleEditorWidths`
`␣ w W`	Focus previous window	command	`workbench.action.focusPreviousGroup`

+Text

Key Binding: ␣ x

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ x .`	Quick fix	command	`editor.action.quickFix`
`␣ x a`	Find all references	command	`editor.action.referenceSearch.trigger`
`␣ x i`	Organize Imports	command	`editor.action.organizeImports`
`␣ x o`	Open link	command	`editor.action.openLink`
`␣ x r`	Rename symbol	command	`editor.action.rename`
`␣ x u`	To lower case	command	`editor.action.transformToLowercase`
`␣ x J`	Move lines down	transient	`editor.action.moveLinesDownAction`
`␣ x K`	Move lines up	transient	`editor.action.moveLinesUpAction`
`␣ x R`	Refactor	command	`editor.action.refactor`
`␣ x U`	To upper case	command	`editor.action.transformToUppercase`
`␣ x d`	+Delete	bindings	N/A
`␣ x l`	+Lines	bindings	N/A
`␣ x m`	+Merge conflict	bindings	N/A

+Zoom/Fold

Key Binding: ␣ z

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ z f`	+Frame	transient	N/A
`␣ z i`	+Image preview	transient	N/A
`␣ z x`	+Font	transient	N/A
`␣ z .`	+Fold	bindings	N/A

+Diff/Compare

Key Binding: ␣ D

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ D c`	Compare active file with clipboard	command	`workbench.files.action.compareWithClipboard`
`␣ D m`	Compare current merge conflict	command	`merge-conflict.compare`
`␣ D s`	Compare active file with saved	command	`workbench.files.action.compareWithSaved`
`␣ D w`	Toggle ignore trim whitespace	command	`toggle.diff.ignoreTrimWhitespace`
`␣ D D`	+Compare active file with	command	`workbench.files.action.compareFileWith`

+Frame

Key Binding: ␣ F

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ F n`	Duplicate workspace in new frame	command	`workbench.action.duplicateWorkspaceInNewWindow`
`␣ F o`	Switch frame	command	`workbench.action.quickSwitchWindow`
`␣ F N`	Open new empty frame	command	`workbench.action.newWindow`

+Show

Key Binding: ␣ S

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ S d`	Show debug console	command	`workbench.debug.action.toggleRepl`
`␣ S e`	Show explorer	command	`workbench.view.explorer`
`␣ S g`	Show source control	command	`workbench.view.scm`
`␣ S n`	Show notification	command	`notifications.toggleList`
`␣ S o`	Show output	command	`workbench.action.output.toggleOutput`
`␣ S p`	Show problem	command	`workbench.actions.view.problems`
`␣ S r`	Show remote explorer	command	`workbench.view.remote`
`␣ S s`	Show search	command	`workbench.view.search`
`␣ S t`	Show test	command	`workbench.view.extension.test`
`␣ S x`	Show extensions	command	`workbench.view.extensions`

+UI toggles

Key Binding: ␣ T

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ T b`	Toggle side bar visibility	command	`workbench.action.toggleSidebarVisibility`
`␣ T c`	Toggle centered layout	command	`workbench.action.toggleCenteredLayout`
`␣ T i`	Select icon theme	command	`workbench.action.selectIconTheme`
`␣ T j`	Toggle panel visibility	command	`workbench.action.togglePanel`
`␣ T m`	Toggle maximized panel	command	`workbench.action.toggleMaximizedPanel`
`␣ T s`	Select theme	command	`workbench.action.selectTheme`
`␣ T t`	Toggle tool/activity bar visibility	command	`workbench.action.toggleActivityBarVisibility`
`␣ T z`	Toggle zen mode	command	`workbench.action.toggleZenMode`
`␣ T F`	Toggle full screen	command	`workbench.action.toggleFullScreen`
`␣ T M`	Toggle minimap	command	`editor.action.toggleMinimap`
`␣ T T`	Toggle tab visibility	command	`workbench.action.toggleTabsVisibility`

+New Buffer

Key Binding: ␣ b N

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ b N h`	New untitled buffer (split left)	commands	`workbench.action.splitEditorLeft` `workbench.action.files.newUntitledFile` `workbench.action.closeOtherEditors`
`␣ b N j`	New untitled buffer (split down)	commands	`workbench.action.splitEditorDown` `workbench.action.files.newUntitledFile` `workbench.action.closeOtherEditors`
`␣ b N k`	New untitled buffer (split up)	commands	`workbench.action.splitEditorUp` `workbench.action.files.newUntitledFile` `workbench.action.closeOtherEditors`
`␣ b N l`	New untitled buffer (split right)	commands	`workbench.action.splitEditorRight` `workbench.action.files.newUntitledFile` `workbench.action.closeOtherEditors`
`␣ b N n`	New untitled buffer	command	`workbench.action.files.newUntitledFile`

+Breakpoint

Key Binding: ␣ d b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ d b b`	Toggle breakpoint	command	`editor.debug.action.toggleBreakpoint`
`␣ d b c`	Add conditional breakpoint	command	`editor.debug.action.conditionalBreakpoint`
`␣ d b d`	Delete breakpoint	command	`debug.removeBreakpoint`
`␣ d b e`	Enable breakpoint	command	`debug.enableOrDisableBreakpoint`
`␣ d b f`	Add function breakpoint	command	`workbench.debug.viewlet.action.addFunctionBreakpointAction`
`␣ d b i`	Toggle inline breakpoint	command	`editor.debug.action.toggleInlineBreakpoint`
`␣ d b n`	Next breakpoint	transient	`editor.debug.action.goToNextBreakpoint`
`␣ d b p`	Previous breakpoint	transient	`editor.debug.action.goToPreviousBreakpoint`
`␣ d b s`	Disable breakpoint	command	`debug.enableOrDisableBreakpoint`
`␣ d b D`	Delete all breakpoints	command	`workbench.debug.viewlet.action.removeAllBreakpoints`
`␣ d b E`	Enable all breakpoints	command	`workbench.debug.viewlet.action.enableAllBreakpoints`
`␣ d b S`	Disable all breakpoints	command	`workbench.debug.viewlet.action.disableAllBreakpoints`

Error transient

Key Binding: ␣ e .

Type: transient

Key Binding	Name	Type	Command(s)
`f`	Fix error	command	`editor.action.quickFix`
`n`	Next error	command	`editor.action.marker.nextInFiles`
`p`	Previous error	command	`editor.action.marker.prevInFiles`
`N`	Previous error	command	`editor.action.marker.prevInFiles`

Toggle tree/explorer view

Key Binding: ␣ f t

Type: conditional

Condition	Name	Type	Command(s)
	Show explorer view	command	`workbench.view.explorer`
`when:sideBarVisible && explorerViewletVisible`	Hide side bar	command	`workbench.action.toggleSidebarVisibility`

+Emacs/VSpaceCode

Key Binding: ␣ f e

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ f e d`	Open settings	command	`workbench.action.openGlobalSettings`
`␣ f e k`	Open global key bindings	command	`workbench.action.openGlobalKeybindings`
`␣ f e l`	Open language settings	command	`workbench.action.configureLanguageBasedSettings`
`␣ f e s`	Configure user snippets	command	`workbench.action.openSnippets`
`␣ f e w`	Open workspace settings	command	`workbench.action.openWorkspaceSettings`
`␣ f e D`	Open settings JSON	command	`workbench.action.openSettingsJson`
`␣ f e K`	Open global key bindings JSON	command	`workbench.action.openGlobalKeybindingsFile`
`␣ f e W`	Open workspace settings JSON	command	`workbench.action.openWorkspaceSettingsFile`

+Indentation

Key Binding: ␣ f i

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ f i d`	Detect indentation	command	`editor.action.detectIndentation`
`␣ f i i`	Change indentation	command	`changeEditorIndentation`
`␣ f i r`	Reindent	command	`editor.action.reindentlines`
`␣ f i s`	Convert indentation to spaces	command	`editor.action.indentationToSpaces`
`␣ f i t`	Convert indentation to tabs	command	`editor.action.indentationToTabs`
`␣ f i R`	Reindent selected	command	`editor.action.reindentselectedlines`

+Yank

Key Binding: ␣ f y

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ f y c`	Copy path of active file with line and column	command	`vspacecode.copyPathWithLineColumn`
`␣ f y d`	Copy directory path of the active file	command	`vspacecode.copyDirectoryPath`
`␣ f y l`	Copy path of active file with line	command	`vspacecode.copyPathWithLine`
`␣ f y n`	Copy filename of active file	command	`vspacecode.copyFilename`
`␣ f y y`	Copy path of active file	command	`vspacecode.copyPath`
`␣ f y C`	Copy relative path of active file with line and column	command	`vspacecode.copyRelativePathWithLineColumn`
`␣ f y D`	Copy relative directory path of the active file	command	`vspacecode.copyRelativeDirectoryPath`
`␣ f y L`	Copy relative path of active file with line	command	`vspacecode.copyRelativePathWithLine`
`␣ f y N`	Copy filename without extension of active file	command	`vspacecode.copyFilenameBase`
`␣ f y Y`	Copy relative path of active file	command	`vspacecode.copyRelativePath`

+File

Key Binding: ␣ g f

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ g f d`	Diff	command	`magit.diff-file`
`␣ g f l`	Show log/timeline	command	`timeline.focus`

Agda

Key Binding: ␣ m languageId:agda

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:agda ,`	Show goal type and context (simplified)	command	`agda-mode.goal-type-and-context[Simplified]`
`␣ m languageId:agda .`	Show goal type, context and inferred type (simplified)	command	`agda-mode.goal-type-context-and-inferred-type[Simplified]`
`␣ m languageId:agda =`	Show constraints	command	`agda-mode.show-constraints`
`␣ m languageId:agda ?`	Show all goals	command	`agda-mode.show-goals`
`␣ m languageId:agda a`	Automatic proof search	command	`agda-mode.auto`
`␣ m languageId:agda b`	Move to previous goal	command	`agda-mode.previous-goal`
`␣ m languageId:agda c`	Case split	command	`agda-mode.case`
`␣ m languageId:agda d`	Infer type (simplified)	command	`agda-mode.infer-type[Simplified]`
`␣ m languageId:agda e`	Show context (simplified)	command	`agda-mode.context[Simplified]`
`␣ m languageId:agda f`	Move to next goal	command	`agda-mode.next-goal`
`␣ m languageId:agda h`	Show helper function type (simplified)	command	`agda-mode.helper-function-type[Simplified]`
`␣ m languageId:agda l`	Load file	command	`agda-mode.load`
`␣ m languageId:agda n`	Compute normal form (simplified)	command	`agda-mode.compute-normal-form[DefaultCompute]`
`␣ m languageId:agda r`	Refine	command	`agda-mode.refine`
`␣ m languageId:agda s`	Solve constraints (simplified)	command	`agda-mode.solve-constraints[Simplified]`
`␣ m languageId:agda t`	Show goal type (simplified)	command	`agda-mode.goal-type[Simplified]`
`␣ m languageId:agda w`	Why in scope	bindings	`agda-mode.why-in-scope`
`␣ m languageId:agda x`	+Backend	bindings	N/A

Clojure

Key Binding: ␣ m languageId:clojure

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure !`	Disconnect from REPL	command	`calva.disconnect`
`␣ m languageId:clojure "`	Jack-in to REPL	command	`calva.jackIn`
`␣ m languageId:clojure '`	Connect to REPL	command	`calva.connect`
`␣ m languageId:clojure .`	Connect or jack-in	command	`calva.jackInOrConnect`
`␣ m languageId:clojure =`	+Format	bindings	N/A
`␣ m languageId:clojure d`	+Debug	bindings	N/A
`␣ m languageId:clojure e`	+Evaluate	bindings	N/A
`␣ m languageId:clojure k`	+Structural editing	bindings	N/A
`␣ m languageId:clojure m`	+Manage REPL session	bindings	N/A
`␣ m languageId:clojure r`	+Refactor	bindings	N/A
`␣ m languageId:clojure t`	+Tests	bindings	N/A
`␣ m languageId:clojure T`	+Toggle	bindings	N/A

coq

Key Binding: ␣ m languageId:coq

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:coq .`	Proof goto current point	command	`extension.coq.interpretToPoint`
`␣ m languageId:coq b`	Proof step back	command	`extension.coq.stepBackward`
`␣ m languageId:coq f`	Proof step forward	command	`extension.coq.stepForward`
`␣ m languageId:coq g`	Go to the current focus location	command	`extension.coq.moveCursorToFocus`
`␣ m languageId:coq o`	Open proof view	command	`extension.coq.proofView.open`
`␣ m languageId:coq v`	View the proof-state at the cursor position	command	`extension.coq.proofView.viewStateAt`
`␣ m languageId:coq G`	Proof goto end	command	`extension.coq.interpretToEnd`
`␣ m languageId:coq a`	Ask prover	bindings	N/A
`␣ m languageId:coq p`	Send command to prover	bindings	N/A
`␣ m languageId:coq q`	Query prover about foucsed symbol	bindings	N/A
`␣ m languageId:coq T`	UI toggle	bindings	N/A

C++

Key Binding: ␣ m languageId:cpp

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cpp =`	+Format	bindings	N/A
`␣ m languageId:cpp b`	+Backend	bindings	N/A
`␣ m languageId:cpp g`	+Go to	bindings	N/A
`␣ m languageId:cpp r`	+Refactor	bindings	N/A
`␣ m languageId:cpp G`	+Peek	bindings	N/A

C#

Key Binding: ␣ m languageId:csharp

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:csharp =`	+Format	bindings	N/A
`␣ m languageId:csharp b`	+Backend/OmniSharp	bindings	N/A
`␣ m languageId:csharp d`	+Debug	bindings	N/A
`␣ m languageId:csharp g`	+Go to	bindings	N/A
`␣ m languageId:csharp p`	+Project	bindings	N/A
`␣ m languageId:csharp r`	+Refactor	bindings	N/A
`␣ m languageId:csharp t`	+Test	bindings	N/A
`␣ m languageId:csharp G`	+Peek	bindings	N/A

Dart/Flutter

Key Binding: ␣ m languageId:dart

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart ;`	Toggle Dartdoc comment	command	`dart.toggleDartdocComment`
`␣ m languageId:dart a`	Attach	command	`flutter.attach`
`␣ m languageId:dart c`	Clean	command	`flutter.clean`
`␣ m languageId:dart i`	Inspect widget	command	`flutter.inspectWidget`
`␣ m languageId:dart m`	Sort members	command	`dart.sortMembers`
`␣ m languageId:dart r`	Hot reload	command	`flutter.hotReload`
`␣ m languageId:dart s`	Select device	command	`flutter.selectDevice`
`␣ m languageId:dart u`	Flutter upgrade	command	`flutter.upgrade`
`␣ m languageId:dart A`	Attach to process	command	`flutter.attachProcess`
`␣ m languageId:dart D`	Flutter doctor	command	`flutter.doctor`
`␣ m languageId:dart E`	Launch emulator	command	`flutter.launchEmulator`
`␣ m languageId:dart P`	Profile app	command	`flutter.runProfileMode`
`␣ m languageId:dart R`	Hot restart	command	`flutter.hotRestart`
`␣ m languageId:dart S`	Screenshot	command	`flutter.screenshot`
`␣ m languageId:dart =`	+Format	bindings	N/A
`␣ m languageId:dart g`	+Go to	bindings	N/A
`␣ m languageId:dart l`	+Logging	bindings	N/A
`␣ m languageId:dart o`	+Open	bindings	N/A
`␣ m languageId:dart p`	+Project/Packages	bindings	N/A
`␣ m languageId:dart r`	+Refactor	bindings	N/A
`␣ m languageId:dart t`	+Test	bindings	N/A
`␣ m languageId:dart G`	+Peek	bindings	N/A
`␣ m languageId:dart T`	+Toggle	bindings	N/A

Elixir

Key Binding: ␣ m languageId:elixir

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:elixir o`	Expand selected macro	command	`extension.expandMacro`
`␣ m languageId:elixir =`	+Format	bindings	N/A
`␣ m languageId:elixir g`	+Go to	bindings	N/A
`␣ m languageId:elixir r`	+Refactor	bindings	N/A
`␣ m languageId:elixir G`	+Peek	bindings	N/A

F#

Key Binding: ␣ m languageId:fsharp

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:fsharp =`	+Format	bindings	N/A
`␣ m languageId:fsharp c`	+Compile	bindings	N/A
`␣ m languageId:fsharp g`	+Go to	bindings	N/A
`␣ m languageId:fsharp r`	+Refactor	bindings	N/A
`␣ m languageId:fsharp s`	+FSI REPL	bindings	N/A
`␣ m languageId:fsharp G`	+Peek	bindings	N/A

Go

Key Binding: ␣ m languageId:go

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go ␣`	Show all commands	command	`go.show.commands`
`␣ m languageId:go =`	+Format	bindings	N/A
`␣ m languageId:go a`	+Actions	bindings	N/A
`␣ m languageId:go b`	+Backend/environment	bindings	N/A
`␣ m languageId:go g`	+Go to	bindings	N/A
`␣ m languageId:go i`	+Insert/remove	bindings	N/A
`␣ m languageId:go r`	+Refactor	bindings	N/A
`␣ m languageId:go t`	+Test	bindings	N/A
`␣ m languageId:go G`	+Peek	bindings	N/A

Java

Key Binding: ␣ m languageId:java

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:java h`	Describe thing at point	command	`editor.action.showHover`
`␣ m languageId:java D`	Debug Java file	command	`java.debug.debugJavaFile`
`␣ m languageId:java R`	Run Java file	command	`java.debug.runJavaFile`
`␣ m languageId:java =`	+Format	bindings	N/A
`␣ m languageId:java a`	+Code actions	bindings	N/A
`␣ m languageId:java g`	+Go to	bindings	N/A
`␣ m languageId:java r`	+Refactor	bindings	N/A
`␣ m languageId:java t`	+Test	bindings	N/A
`␣ m languageId:java G`	+Peek	bindings	N/A

JavaScript

Key Binding: ␣ m languageId:javascript

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:javascript =`	+Format	bindings	N/A
`␣ m languageId:javascript g`	+Go to	bindings	N/A
`␣ m languageId:javascript G`	+Peek	bindings	N/A

Julia

Key Binding: ␣ m languageId:julia

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:julia ,`	Execute code in REPL	command	`language-julia.executeJuliaCodeInREPL`
`␣ m languageId:julia d`	Show documentation	command	`language-julia.show-documentation`
`␣ m languageId:julia p`	Show plots	command	`language-julia.show-plotpane`
`␣ m languageId:julia w`	Focus on workspace view	command	`REPLVariables.focus`
`␣ m languageId:julia =`	+Format	bindings	N/A
`␣ m languageId:julia b`	+Backend	bindings	N/A
`␣ m languageId:julia c`	+Compile/debug	bindings	N/A
`␣ m languageId:julia c`	+Clear	bindings	N/A
`␣ m languageId:julia e`	+Environment/package	bindings	N/A
`␣ m languageId:julia g`	+Go to	bindings	N/A
`␣ m languageId:julia s`	+Send/REPL	bindings	N/A

LaTeX

Key Binding: ␣ m languageId:latex

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex =`	+Format	bindings	N/A
`␣ m languageId:latex b`	+Backend	bindings	N/A
`␣ m languageId:latex c`	+Build	bindings	N/A
`␣ m languageId:latex g`	+Go to	bindings	N/A
`␣ m languageId:latex i`	+Insert	bindings	N/A
`␣ m languageId:latex l`	+Bibtex	bindings	N/A
`␣ m languageId:latex p`	+Preview	bindings	N/A
`␣ m languageId:latex x`	+Text	bindings	N/A

Markdown

Key Binding: ␣ m languageId:markdown

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:markdown c`	+Buffer commands	bindings	N/A
`␣ m languageId:markdown t`	+Table of Contents	bindings	N/A
`␣ m languageId:markdown x`	+Text	bindings	N/A

ObjectPascal

Key Binding: ␣ m languageId:objectpascal

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:objectpascal =`	+Format	bindings	N/A
`␣ m languageId:objectpascal g`	+Go to	bindings	N/A
`␣ m languageId:objectpascal r`	+Refactor	bindings	N/A
`␣ m languageId:objectpascal G`	+Peek	bindings	N/A

PHP

Key Binding: ␣ m languageId:php

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:php =`	+Format	bindings	N/A
`␣ m languageId:php g`	+Go to	bindings	N/A
`␣ m languageId:php r`	+Refactor	bindings	N/A
`␣ m languageId:php G`	+Peek	bindings	N/A

Python

Key Binding: ␣ m languageId:python

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:python v`	+Virtualenv	command	`python.setInterpreter`
`␣ m languageId:python =`	+Format	bindings	N/A
`␣ m languageId:python b`	+Backend	bindings	N/A
`␣ m languageId:python c`	+Execute	bindings	N/A
`␣ m languageId:python g`	+Go to	bindings	N/A
`␣ m languageId:python r`	+Refactor	bindings	N/A
`␣ m languageId:python s`	+REPL	bindings	N/A
`␣ m languageId:python t`	+Test	bindings	N/A
`␣ m languageId:python G`	+Peek	bindings	N/A

quarto

Key Binding: ␣ m languageId:quarto

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:quarto d`	Debugonce R	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:quarto h`	Help R	command	`r.helpPanel.openForSelection`
`␣ m languageId:quarto i`	Insert cell	command	`quarto.insertCodeCell`
`␣ m languageId:quarto m`	Run current cell	command	`quarto.runCurrentCell`
`␣ m languageId:quarto o`	Objects in workspace R	command	`r.runCommand`
`␣ m languageId:quarto p`	Render	command	`quarto.render`
`␣ m languageId:quarto s`	Run selection	command	`quarto.runSelection`
`␣ m languageId:quarto R`	Restart R	command	`r.runCommand`
`␣ m languageId:quarto =`	+Format	bindings	N/A
`␣ m languageId:quarto a`	+Code actions	bindings	N/A
`␣ m languageId:quarto f`	+Fold	bindings	N/A
`␣ m languageId:quarto g`	+Go to	bindings	N/A
`␣ m languageId:quarto r`	+Refactor	bindings	N/A
`␣ m languageId:quarto v`	+View R	bindings	N/A
`␣ m languageId:quarto G`	+Peek	bindings	N/A

R

Key Binding: ␣ m languageId:r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:r d`	Debugonce	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:r h`	Help	command	`r.helpPanel.openForSelection`
`␣ m languageId:r o`	Objects in workspace R	command	`r.runCommand`
`␣ m languageId:r s`	Run selection	command	`r.runSelection`
`␣ m languageId:r R`	Restart R	command	`r.runCommand`
`␣ m languageId:r =`	+Format	bindings	N/A
`␣ m languageId:r a`	+Code actions	bindings	N/A
`␣ m languageId:r g`	+Go to	bindings	N/A
`␣ m languageId:r r`	+Refactor	bindings	N/A
`␣ m languageId:r v`	+View	bindings	N/A
`␣ m languageId:r G`	+Peek	bindings	N/A

Ruby

Key Binding: ␣ m languageId:ruby

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:ruby =`	+Format	bindings	N/A
`␣ m languageId:ruby g`	+Go to	bindings	N/A
`␣ m languageId:ruby r`	+Refactor	bindings	N/A
`␣ m languageId:ruby G`	+Peek	bindings	N/A

Rust

Key Binding: ␣ m languageId:rust

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:rust T`	Toggle inlay hints	command	`rust-analyzer.toggleInlayHints`
`␣ m languageId:rust =`	+Format	bindings	N/A
`␣ m languageId:rust a`	+Actions	bindings	N/A
`␣ m languageId:rust b`	+Backend	bindings	N/A
`␣ m languageId:rust g`	+Goto	bindings	N/A
`␣ m languageId:rust r`	+Refactor	bindings	N/A
`␣ m languageId:rust G`	+Peek	bindings	N/A

TypeScript

Key Binding: ␣ m languageId:typescript

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:typescript =`	+Format	bindings	N/A
`␣ m languageId:typescript g`	+Go to	bindings	N/A
`␣ m languageId:typescript G`	+Peek	bindings	N/A

CUDA-C++

Key Binding: ␣ m languageId:cuda-cpp

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cuda-cpp =`	+Format	bindings	N/A
`␣ m languageId:cuda-cpp b`	+Backend	bindings	N/A
`␣ m languageId:cuda-cpp d`	+Debug	bindings	N/A
`␣ m languageId:cuda-cpp g`	+Go to	bindings	N/A
`␣ m languageId:cuda-cpp r`	+Refactor	bindings	N/A
`␣ m languageId:cuda-cpp G`	+Peek	bindings	N/A

Highlight symbol

Key Binding: ␣ s h

Type: transient

Key Binding	Name	Type	Command(s)
`/`	Search in project with selection	commands	`editor.action.addSelectionToNextFindMatch` `workbench.action.findInFiles`
`n`	Next occurrence	command	`editor.action.wordHighlight.next`
`p`	Previous occurrence	command	`editor.action.wordHighlight.prev`
`N`	Previous occurrence	command	`editor.action.wordHighlight.prev`

Shrink window

Key Binding: ␣ w [

Type: transient

Key Binding	Name	Type	Command(s)
`[`	Shrink window	command	`workbench.action.decreaseViewSize`
`]`	Enlarge window	command	`workbench.action.increaseViewSize`

Enlarge window

Key Binding: ␣ w ]

Type: transient

Key Binding	Name	Type	Command(s)
`[`	Shrink window	command	`workbench.action.decreaseViewSize`
`]`	Enlarge window	command	`workbench.action.increaseViewSize`

Move lines down

Key Binding: ␣ x J

Type: transient

Key Binding	Name	Type	Command(s)
`J`	Move lines down	command	`editor.action.moveLinesDownAction`
`K`	Move lines up	command	`editor.action.moveLinesUpAction`

Move lines up

Key Binding: ␣ x K

Type: transient

Key Binding	Name	Type	Command(s)
`J`	Move lines down	command	`editor.action.moveLinesDownAction`
`K`	Move lines up	command	`editor.action.moveLinesUpAction`

+Delete

Key Binding: ␣ x d

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ x d w`	Delete trailing whitespace	command	`editor.action.trimTrailingWhitespace`

+Lines

Key Binding: ␣ x l

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ x l d`	Duplicate lines down	command	`editor.action.copyLinesDownAction`
`␣ x l s`	Sort lines in ascending order	command	`editor.action.sortLinesAscending`
`␣ x l D`	Duplicate lines up	command	`editor.action.copyLinesUpAction`
`␣ x l S`	Sort lines in descending order	command	`editor.action.sortLinesDescending`

+Merge conflict

Key Binding: ␣ x m

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ x m b`	Accept both	command	`merge-conflict.accept.both`
`␣ x m c`	Accept current	command	`merge-conflict.accept.current`
`␣ x m i`	Accept incoming	command	`merge-conflict.accept.incoming`
`␣ x m k`	Compare current conflict	command	`merge-conflict.compare`
`␣ x m n`	Next Conflict	command	`merge-conflict.next`
`␣ x m s`	Accept selection	command	`merge-conflict.accept.selection`
`␣ x m B`	Accept all both	command	`merge-conflict.accept.all-both`
`␣ x m C`	Accept all current	command	`merge-conflict.accept.all-current`
`␣ x m I`	Accept all incoming	command	`merge-conflict.accept.all-incoming`
`␣ x m N`	Previous Conflict	command	`merge-conflict.previous`

+Frame

Key Binding: ␣ z f

Type: transient

Key Binding	Name	Type	Command(s)
`+`	Zoom in	command	`workbench.action.zoomIn`
`-`	Zoom out	command	`workbench.action.zoomOut`
`0`	Reset zoom	command	`workbench.action.zoomReset`
`=`	Zoom in	command	`workbench.action.zoomIn`
`j`	Zoom out	command	`workbench.action.zoomOut`
`k`	Zoom in	command	`workbench.action.zoomIn`

+Image preview

Key Binding: ␣ z i

Type: transient

Key Binding	Name	Type	Command(s)
`+`	Zoom in	command	`imagePreview.zoomIn`
`-`	Zoom out	command	`imagePreview.zoomOut`
`=`	Zoom in	command	`imagePreview.zoomIn`

+Font

Key Binding: ␣ z x

Type: transient

Key Binding	Name	Type	Command(s)
`+`	Zoom in	command	`editor.action.fontZoomIn`
`-`	Zoom out	command	`editor.action.fontZoomOut`
`0`	Reset zoom	command	`editor.action.fontZoomReset`
`=`	Zoom in	command	`editor.action.fontZoomIn`
`j`	Zoom out	command	`editor.action.fontZoomOut`
`k`	Zoom in	command	`editor.action.fontZoomIn`

+Fold

Key Binding: ␣ z .

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ z . a`	Toggle: around a point	command	`editor.toggleFold`
`␣ z . b`	Close: all block comments	command	`editor.foldAllBlockComments`
`␣ z . c`	Close: at a point	command	`editor.fold`
`␣ z . g`	Close: all regions	command	`editor.foldAllMarkerRegions`
`␣ z . m`	Close: all	command	`editor.foldAll`
`␣ z . o`	Open: at a point	command	`editor.unfold`
`␣ z . r`	Open: all	command	`editor.unfoldAll`
`␣ z . G`	Open: all regions	command	`editor.unfoldAllMarkerRegions`
`␣ z . O`	Open: recursively	command	`editor.unfoldRecursively`

Next breakpoint

Key Binding: ␣ d b n

Type: transient

Key Binding	Name	Type	Command(s)
`n`	Next breakpoint	command	`editor.debug.action.goToNextBreakpoint`
`p`	Previous breakpoint	command	`editor.debug.action.goToPreviousBreakpoint`

Previous breakpoint

Key Binding: ␣ d b p

Type: transient

Key Binding	Name	Type	Command(s)
`n`	Next breakpoint	command	`editor.debug.action.goToNextBreakpoint`
`p`	Previous breakpoint	command	`editor.debug.action.goToPreviousBreakpoint`

+Backend

Key Binding: ␣ m languageId:agda x

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:agda x c`	Compile module	command	`agda-mode.compile`
`␣ m languageId:agda x h`	Toggle display of implicit arguments	command	`agda-mode.toggle-display-of-implicit-arguments`
`␣ m languageId:agda x q`	Quit	command	`agda-mode.quit`
`␣ m languageId:agda x r`	Restart	command	`agda-mode.restart`

+Format

Key Binding: ␣ m languageId:clojure =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure = =`	Format current form	command	`calva-fmt.formatCurrentForm`
`␣ m languageId:clojure = a`	Align current form	command	`calva-fmt.alignCurrentForm`
`␣ m languageId:clojure = d`	Dedent line	command	`calva-fmt.tabDedent`
`␣ m languageId:clojure = i`	Indent line	command	`calva-fmt.tabIndent`

+Debug

Key Binding: ␣ m languageId:clojure d

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure d i`	Last evaluation results	command	`calva.debug.instrument`
`␣ m languageId:clojure d r`	Last evaluation results	command	`calva.copyLastResults`
`␣ m languageId:clojure d s`	Last stacktrace	command	`calva.printLastStacktrace`

+Evaluate

Key Binding: ␣ m languageId:clojure e

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure e :`	Evaluate current form as comment	command	`calva.evaluateSelectionAsComment`
`␣ m languageId:clojure e ;`	Evaluate top-level form as comment	command	`calva.evaluateTopLevelFormAsComment`
`␣ m languageId:clojure e e`	Evaluate current expression	command	`calva.evaluateSelection`
`␣ m languageId:clojure e f`	Evaluate top-level expression	command	`calva.evaluateCurrentTopLevelForm`
`␣ m languageId:clojure e i`	Interrupt evaluation	command	`calva.interruptAllEvaluations`
`␣ m languageId:clojure e l`	Clear inline evaluation results	command	`calva.clearInlineResults`
`␣ m languageId:clojure e n`	Evaluate all code in namespace	command	`calva.loadFile`
`␣ m languageId:clojure e s`	Select expression	command	`calva.selectCurrentForm`
`␣ m languageId:clojure e t`	Clear evaluation results	command	`calva.requireREPLUtilities`
`␣ m languageId:clojure e w`	Replace form with evaluation result	command	`calva.evaluateSelectionReplace`

+Structural editing

Key Binding: ␣ m languageId:clojure k

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure k .`	Toggle paredit mode	command	`paredit.togglemode`
`␣ m languageId:clojure k b`	Barf expression forward	command	`paredit.barfSexpForward`
`␣ m languageId:clojure k c`	Convolute expression	command	`paredit.convolute`
`␣ m languageId:clojure k h`	Backward expression	command	`paredit.backwardSexp`
`␣ m languageId:clojure k j`	Forward down expression	command	`paredit.forwardDownSexp`
`␣ m languageId:clojure k k`	Backward down expression	command	`paredit.backwardDownSexp`
`␣ m languageId:clojure k l`	Forward expression	command	`paredit.forwardSexp`
`␣ m languageId:clojure k r`	Raise expression	command	`paredit.raiseSexp`
`␣ m languageId:clojure k s`	Slurp expression forward	command	`paredit.slurpSexpForward`
`␣ m languageId:clojure k t`	Transpose expression	command	`paredit.transpose`
`␣ m languageId:clojure k B`	Barf expression backward	command	`paredit.barfSexpBackward`
`␣ m languageId:clojure k H`	Backward up expression	command	`paredit.backwardUpSexp`
`␣ m languageId:clojure k J`	Join expression	command	`paredit.joinSexp`
`␣ m languageId:clojure k L`	Forward up expression	command	`paredit.forwardUpSexp`
`␣ m languageId:clojure k S`	Slurp expression backward	command	`paredit.slurpSexpBackward`
`␣ m languageId:clojure k w`	+Wrap	bindings	N/A

+Manage REPL session

Key Binding: ␣ m languageId:clojure m

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure m .`	Connect or jack-in	command	`calva.jackInOrConnect`
`␣ m languageId:clojure m c`	Connect to REPL server for project	command	`calva.connect`
`␣ m languageId:clojure m j`	Start REPL server for project (jack-in)	command	`calva.jackIn`
`␣ m languageId:clojure m q`	Disconnect (quit) from REPL server	command	`calva.disconnect`
`␣ m languageId:clojure m r`	Refresh changed namespaces	command	`calva.refresh`
`␣ m languageId:clojure m s`	Select cljs build connection	command	`calva.switchCljsBuild`
`␣ m languageId:clojure m t`	Toggle cljc session (clj, cljs)	command	`calva.toggleCLJCSession`
`␣ m languageId:clojure m C`	Run custom REPL command	command	`calva.runCustomREPLCommand`
`␣ m languageId:clojure m R`	Refresh all namespaces	command	`calva.refreshAll`

+Refactor

Key Binding: ␣ m languageId:clojure r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure r a`	+Add	bindings	N/A
`␣ m languageId:clojure r c`	+Cycle clean convert	bindings	N/A
`␣ m languageId:clojure r e`	+Extract expand	bindings	N/A
`␣ m languageId:clojure r i`	+Introduce inline	bindings	N/A
`␣ m languageId:clojure r m`	+Move	bindings	N/A
`␣ m languageId:clojure r t`	+Thread macros	bindings	N/A

+Tests

Key Binding: ␣ m languageId:clojure t

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure t a`	Run all tests	command	`calva.runAllTests`
`␣ m languageId:clojure t f`	Run failing tests	command	`calva.rerunTests`
`␣ m languageId:clojure t n`	Run tests in current namespace	command	`calva.runNamespaceTests`
`␣ m languageId:clojure t t`	Run current test	command	`calva.runTestUnderCursor`

+Toggle

Key Binding: ␣ m languageId:clojure T

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure T p`	Toggle pretty print results	command	`calva.togglePrettyPrint`

Ask prover

Key Binding: ␣ m languageId:coq a

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:coq a a`	About	command	`extension.coq.query.prompt.about`
`␣ m languageId:coq a c`	Check	command	`extension.coq.query.prompt.check`
`␣ m languageId:coq a f`	Find	command	`extension.coq.query.prompt.search`
`␣ m languageId:coq a l`	Locate	command	`extension.coq.query.prompt.locate`
`␣ m languageId:coq a p`	Print	command	`extension.coq.query.prompt.print`

Send command to prover

Key Binding: ␣ m languageId:coq p

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:coq p f`	Finish coq computations	command	`extension.coq.finishComputations`
`␣ m languageId:coq p i`	Interrupt coqtop backend	command	`extension.coq.interrupt`
`␣ m languageId:coq p q`	Quit coqtop backend	command	`extension.coq.quit`
`␣ m languageId:coq p r`	Reset coqtop backend	command	`extension.coq.reset`

Query prover about foucsed symbol

Key Binding: ␣ m languageId:coq q

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:coq q a`	About	command	`extension.coq.query.about`
`␣ m languageId:coq q c`	Check	command	`extension.coq.query.check`
`␣ m languageId:coq q f`	Find	command	`extension.coq.query.search`
`␣ m languageId:coq q l`	Locate	command	`extension.coq.query.locate`
`␣ m languageId:coq q p`	Print	command	`extension.coq.query.print`

UI toggle

Key Binding: ␣ m languageId:coq T

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:coq T b`	Toggle display of all basic low level contents	command	`extension.coq.display.toggle.allBasicLowLevelContents`
`␣ m languageId:coq T c`	Toggle display of coercions	command	`extension.coq.display.toggle.coercions`
`␣ m languageId:coq T e`	Toggle display of existential variable instances	command	`extension.coq.display.toggle.existentialVariableInstances`
`␣ m languageId:coq T i`	Toggle display of implicit arguments	command	`extension.coq.display.toggle.implicitArguments`
`␣ m languageId:coq T l`	Toggle display of all lowLevel contents	command	`extension.coq.display.toggle.allLowLevelContents`
`␣ m languageId:coq T n`	Toggle display of notations	command	`extension.coq.display.toggle.notations`
`␣ m languageId:coq T r`	Toggle display of raw matching expressions	command	`extension.coq.display.toggle.rawMatchingExpressions`
`␣ m languageId:coq T u`	Toggle display of universe levels	command	`extension.coq.display.toggle.universeLevels`

+Format

Key Binding: ␣ m languageId:cpp =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cpp = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:cpp = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:cpp = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:cpp = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:cpp = B`	Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:cpp = S`	Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Backend

Key Binding: ␣ m languageId:cpp b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cpp b d`	Reset Database	command	`C_Cpp.ResetDatabase`
`␣ m languageId:cpp b w`	Rescan Workspace	command	`C_Cpp.RescanWorkspace`

+Go to

Key Binding: ␣ m languageId:cpp g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cpp g a`	Switch Header/Source	command	`C_Cpp.SwitchHeaderSource`
`␣ m languageId:cpp g d`	Go to declaration	command	`editor.action.revealDeclaration`
`␣ m languageId:cpp g e`	Go to errors/problems	command	`workbench.actions.view.problems`
`␣ m languageId:cpp g f`	Go to file in explorer	command	`workbench.files.action.showActiveFileInExplorer`
`␣ m languageId:cpp g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:cpp g r`	Go to reference	command	`editor.action.goToReferences`
`␣ m languageId:cpp g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:cpp g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:cpp g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Refactor

Key Binding: ␣ m languageId:cpp r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cpp r r`	Rename Symbol	command	`editor.action.rename`

+Peek

Key Binding: ␣ m languageId:cpp G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cpp G d`	Peek declaration	command	`editor.action.peekDeclaration`
`␣ m languageId:cpp G g`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:cpp G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:csharp =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:csharp = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:csharp = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:csharp = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:csharp = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:csharp = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:csharp = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Backend/OmniSharp

Key Binding: ␣ m languageId:csharp b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:csharp b o`	Show output	command	`o.showOutput`
`␣ m languageId:csharp b r`	Restart OmniSharp	command	`o.restart`
`␣ m languageId:csharp b s`	Select a project and start	command	`o.pickProjectAndStart`

+Debug

Key Binding: ␣ m languageId:csharp d

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:csharp d l`	List process for attach	command	`csharp.listProcess`
`␣ m languageId:csharp d L`	List remote processes for attach	command	`csharp.listRemoteProcess`

+Go to

Key Binding: ␣ m languageId:csharp g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:csharp g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:csharp g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:csharp g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:csharp g i`	Go to implementations	command	`editor.action.goToImplementation`
`␣ m languageId:csharp g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:csharp g I`	Find implementations	command	`references-view.findImplementations`
`␣ m languageId:csharp g R`	Find references	command	`references-view.findReferences`

+Project

Key Binding: ␣ m languageId:csharp p

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:csharp p r`	Restore project	command	`dotnet.restore.project`
`␣ m languageId:csharp p R`	Restore all projects	command	`dotnet.restore.all`

+Refactor

Key Binding: ␣ m languageId:csharp r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:csharp r .`	Quick fix	command	`editor.action.quickFix`
`␣ m languageId:csharp r r`	Rename symbol	command	`editor.action.rename`

+Test

Key Binding: ␣ m languageId:csharp t

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:csharp t d`	Debug test under cursor	command	`dotnet.test.debugTestsInContext`
`␣ m languageId:csharp t t`	Run test under cursor	command	`dotnet.test.runTestsInContext`

+Peek

Key Binding: ␣ m languageId:csharp G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:csharp G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:csharp G i`	Peek implementations	command	`editor.action.peekImplementation`
`␣ m languageId:csharp G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:dart =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:dart = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:dart = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:dart = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:dart = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:dart = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Go to

Key Binding: ␣ m languageId:dart g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:dart g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:dart g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:dart g i`	Go to implementations	command	`editor.action.goToImplementation`
`␣ m languageId:dart g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:dart g s`	Go to super	command	`dart.goToSuper`
`␣ m languageId:dart g t`	Go to test/implementation file	command	`dart.goToTestOrImplementationFile`
`␣ m languageId:dart g I`	Find implementations	command	`references-view.findImplementations`
`␣ m languageId:dart g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:dart g T`	Go to tests	command	`dart.goToTests`

+Logging

Key Binding: ␣ m languageId:dart l

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart l a`	Start logging analysis server	command	`dart.startLoggingAnalysisServer`
`␣ m languageId:dart l d`	Start logging debugging	command	`dart.startLoggingDebugging`
`␣ m languageId:dart l e`	Start logging extension only	command	`dart.startLoggingExtensionOnly`
`␣ m languageId:dart l s`	Start logging	command	`dart.startLogging`
`␣ m languageId:dart l S`	Stop logging	command	`dart.stopLogging`

+Open

Key Binding: ␣ m languageId:dart o

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart o a`	Analyzer diagnostics	command	`dart.openAnalyzerDiagnostics`
`␣ m languageId:dart o c`	DevTools CPU profiler	command	`dart.startLoggingDebugging`
`␣ m languageId:dart o d`	Devtools	command	`flutter.openDevTools`
`␣ m languageId:dart o l`	DevTools logging	command	`dart.openDevToolsLogging`
`␣ m languageId:dart o m`	DevTools memory	command	`dart.openDevToolsMemory`
`␣ m languageId:dart o n`	DevTools network	command	`dart.openDevToolsNetwork`

+Project/Packages

Key Binding: ␣ m languageId:dart p

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart p d`	Add dependency	command	`dart.addDependency`
`␣ m languageId:dart p g`	Pub get	command	`flutter.packages.get`
`␣ m languageId:dart p o`	Pub outdated	command	`flutter.packages.outdated`
`␣ m languageId:dart p u`	Pub upgrade	command	`flutter.packages.upgrade`
`␣ m languageId:dart p D`	Add dev dependency	command	`dart.addDevDependency`
`␣ m languageId:dart p U`	Pub upgrade -major versions	command	`flutter.packages.upgrade.majorVersions`
`␣ m languageId:dart p c`	+Create	bindings	N/A

+Refactor

Key Binding: ␣ m languageId:dart r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart r .`	Quick fix	command	`editor.action.quickFix`
`␣ m languageId:dart r r`	Rename symbol	command	`editor.action.rename`

+Test

Key Binding: ␣ m languageId:dart t

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart t c`	Clear test results	command	`testing.clearTestResults`
`␣ m languageId:dart t d`	Debug test at cursor	command	`testing.debugTestAtCursor`
`␣ m languageId:dart t f`	Run failed tests	command	`testing.reRunFailTests`
`␣ m languageId:dart t r`	Run tests	command	`testing.runAll`
`␣ m languageId:dart t t`	Run test at cursor	command	`testing.runTestAtCursor`

+Peek

Key Binding: ␣ m languageId:dart G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:dart G i`	Peek implementations	command	`editor.action.peekImplementation`
`␣ m languageId:dart G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Toggle

Key Binding: ␣ m languageId:dart T

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart T b`	Brightness	command	`flutter.toggleBrightness`
`␣ m languageId:dart T d`	Debug painting	command	`flutter.toggleDebugPainting`
`␣ m languageId:dart T e`	Check elevations	command	`flutter.toggleCheckElevations`
`␣ m languageId:dart T o`	Performance overlay	command	`flutter.togglePerformanceOverlay`
`␣ m languageId:dart T p`	Paint baselines	command	`flutter.togglePaintBaselines`
`␣ m languageId:dart T r`	Repaint rainbow	command	`flutter.toggleRepaintRainbow`
`␣ m languageId:dart T s`	Slow animations	command	`flutter.toggleSlowAnimations`
`␣ m languageId:dart T B`	Debug mode banner	command	`flutter.toggleDebugModeBanner`

+Format

Key Binding: ␣ m languageId:elixir =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:elixir = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:elixir = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:elixir = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:elixir = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:elixir = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:elixir = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Go to

Key Binding: ␣ m languageId:elixir g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:elixir g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:elixir g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:elixir g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:elixir g i`	Go to implementations	command	`editor.action.goToImplementation`
`␣ m languageId:elixir g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:elixir g I`	Find implementations	command	`references-view.findImplementations`
`␣ m languageId:elixir g R`	Find references	command	`references-view.findReferences`

+Refactor

Key Binding: ␣ m languageId:elixir r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:elixir r .`	Quick fix	command	`editor.action.quickFix`
`␣ m languageId:elixir r p`	Transform function call to pipe operator	command	`extension.toPipe`
`␣ m languageId:elixir r r`	Rename symbol	command	`editor.action.rename`
`␣ m languageId:elixir r P`	Transform pipe operator to function call	command	`extension.fromPipe`

+Peek

Key Binding: ␣ m languageId:elixir G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:elixir G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:elixir G i`	Peek implementations	command	`editor.action.peekImplementation`
`␣ m languageId:elixir G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:fsharp =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:fsharp = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:fsharp = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:fsharp = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:fsharp = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:fsharp = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:fsharp = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Compile

Key Binding: ␣ m languageId:fsharp c

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:fsharp c c`	MSBuild: Build current solution	command	`MSBuild.buildCurrentSolution`
`␣ m languageId:fsharp c d`	F#: Run default project	command	`fsharp.runDefaultProject`
`␣ m languageId:fsharp c l`	MSBuild: Clean current solution	command	`MSBuild.cleanCurrentSolution`
`␣ m languageId:fsharp c p`	MSBuild: Build current project	command	`MSBuild.buildCurrent`
`␣ m languageId:fsharp c r`	MSBuild: Re-build current solution	command	`MSBuild.rebuildCurrentSolution`
`␣ m languageId:fsharp c D`	F#: Debug default project	command	`fsharp.debugDefaultProject`
`␣ m languageId:fsharp c L`	MSBuild: Clean current project	command	`MSBuild.cleanCurrent`

+Go to

Key Binding: ␣ m languageId:fsharp g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:fsharp g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:fsharp g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:fsharp g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:fsharp g r`	Go to reference	command	`editor.action.goToReferences`
`␣ m languageId:fsharp g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:fsharp g t`	Go to type definition	command	`editor.action.goToTypeDefinition`
`␣ m languageId:fsharp g I`	Find implementations	command	`references-view.findImplementations`
`␣ m languageId:fsharp g R`	Find references	command	`references-view.findReferences`

+Refactor

Key Binding: ␣ m languageId:fsharp r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:fsharp r r`	Rename symbol	command	`editor.action.rename`

+FSI REPL

Key Binding: ␣ m languageId:fsharp s

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:fsharp s f`	FSI: Send file	command	`fsi.SendFile`
`␣ m languageId:fsharp s l`	FSI: Send line	command	`fsi.SendLine`
`␣ m languageId:fsharp s s`	FSI: Send selection	command	`fsi.SendSelection`
`␣ m languageId:fsharp s G`	FSI: Generate project references	command	`fsi.GenerateProjectReferences`
`␣ m languageId:fsharp s L`	FSI: Send last selection	command	`fsi.SendLastSelection`
`␣ m languageId:fsharp s P`	FSI: Send references from project	command	`fsi.SendProjectReferences`
`␣ m languageId:fsharp s S`	FSI: Start	command	`fsi.Start`

+Peek

Key Binding: ␣ m languageId:fsharp G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:fsharp G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:fsharp G r`	Peek references	command	`editor.action.referenceSearch.trigger`
`␣ m languageId:fsharp G t`	Peek type definition	command	`editor.action.peekTypeDefinition`

+Format

Key Binding: ␣ m languageId:go =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:go = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:go = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:go = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:go = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:go = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Actions

Key Binding: ␣ m languageId:go a

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go a P`	Run code on Go Playground	command	`go.playground`
`␣ m languageId:go a p`	+Package actions	bindings	N/A
`␣ m languageId:go a w`	+Workspace actions	bindings	N/A

+Backend/environment

Key Binding: ␣ m languageId:go b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go b e`	Choose Go environment	command	`go.environment.choose`
`␣ m languageId:go b g`	Show current GOPATH	command	`go.gopath`
`␣ m languageId:go b i`	Install/update tools	command	`go.tools.install`
`␣ m languageId:go b l`	Locate configured Go tools	command	`go.locate.tools`
`␣ m languageId:go b R`	Restart language server	command	`go.languageserver.restart`

+Go to

Key Binding: ␣ m languageId:go g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:go g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:go g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:go g h`	Show call hierarchy	command	`references-view.showCallHierarchy`
`␣ m languageId:go g i`	Go to implementations	command	`editor.action.goToImplementation`
`␣ m languageId:go g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:go g t`	Go to type definition	command	`editor.action.goToTypeDefinition`
`␣ m languageId:go g I`	Find implementations	command	`references-view.findImplementations`
`␣ m languageId:go g R`	Find references	command	`references-view.findReferences`

+Insert/remove

Key Binding: ␣ m languageId:go i

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go i f`	Fill struct	command	`go.fill.struct`
`␣ m languageId:go i i`	Add import	command	`go.import.add`
`␣ m languageId:go i t`	Add tags to struct fields	command	`go.add.tags`
`␣ m languageId:go i I`	Generate interface stubs	command	`go.impl.cursor`
`␣ m languageId:go i T`	Remove tags from struct fields	command	`go.remove.tags`

+Refactor

Key Binding: ␣ m languageId:go r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go r .`	Quick fix	command	`editor.action.quickFix`
`␣ m languageId:go r e`	Extract to function or variable	command	`editor.action.codeAction`
`␣ m languageId:go r r`	Rename symbol	command	`editor.action.rename`

+Test

Key Binding: ␣ m languageId:go t

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go t c`	Cancel running tests	command	`go.test.cancel`
`␣ m languageId:go t d`	Debug test at cursor	command	`go.debug.cursor`
`␣ m languageId:go t f`	Test file	command	`go.test.file`
`␣ m languageId:go t l`	Test previous	command	`go.test.previous`
`␣ m languageId:go t p`	Test package	command	`go.test.package`
`␣ m languageId:go t s`	Subtest at cursor	command	`go.subtest.cursor`
`␣ m languageId:go t t`	Test function at cursor	command	`go.test.cursor`
`␣ m languageId:go t w`	Test packages in workspace	command	`go.test.workspace`
`␣ m languageId:go t P`	Apply cover profile	command	`go.apply.coverprofile`
`␣ m languageId:go t b`	+Benchmarks	bindings	N/A
`␣ m languageId:go t g`	+Generate	bindings	N/A
`␣ m languageId:go t T`	+Toggle	bindings	N/A

+Peek

Key Binding: ␣ m languageId:go G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:go G h`	Peek call hierarchy	command	`editor.showCallHierarchy`
`␣ m languageId:go G i`	Peek implementations	command	`editor.action.peekImplementation`
`␣ m languageId:go G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:java =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:java = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:java = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:java = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:java = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:java = B`	Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:java = S`	Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Code actions

Key Binding: ␣ m languageId:java a

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:java a a`	Execute code action	command	`editor.action.codeAction`
`␣ m languageId:java a f`	Execute fix action	command	`editor.action.quickFix`
`␣ m languageId:java a r`	Refactor action	command	`editor.action.refactor`
`␣ m languageId:java a s`	Source action	command	`editor.action.sourceAction`

+Go to

Key Binding: ␣ m languageId:java g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:java g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:java g e`	Go to error list	command	`workbench.action.showErrorsWarnings`
`␣ m languageId:java g h`	Show call hierarchy	command	`references-view.showCallHierarchy`
`␣ m languageId:java g i`	Go to implementations	command	`editor.action.goToImplementation`
`␣ m languageId:java g o`	Go to super implementation	command	`java.action.navigateToSuperImplementation`
`␣ m languageId:java g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:java g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:java g t`	Go to type definition	command	`editor.action.goToTypeDefinition`
`␣ m languageId:java g u`	Go to subtype hierarchy	command	`java.action.showSubtypeHierarchy`
`␣ m languageId:java g H`	Go to type hierarchy	command	`java.action.showTypeHierarchy`
`␣ m languageId:java g I`	Find implementations	command	`references-view.findImplementations`
`␣ m languageId:java g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:java g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`
`␣ m languageId:java g T`	Go to test	command	`java.test.goToTest`
`␣ m languageId:java g U`	Go to supertype hierarchy	command	`java.action.showSupertypeHierarchy`

+Refactor

Key Binding: ␣ m languageId:java r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:java r a`	Execute code actions	command	`editor.action.codeAction`
`␣ m languageId:java r e`	Extract to function or variable	command	`editor.action.codeAction`
`␣ m languageId:java r o`	Organize imports	command	`editor.action.organizeImports`
`␣ m languageId:java r r`	Rename symbol	command	`editor.action.rename`
`␣ m languageId:java r R`	Refactor actions	command	`editor.action.refactor`

+Test

Key Binding: ␣ m languageId:java t

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:java t a`	Run all tests	command	`testing.runAll`
`␣ m languageId:java t b`	Run current test file	command	`testing.runCurrentFile`
`␣ m languageId:java t r`	Re-run failed tests	command	`testing.reRunFailTests`
`␣ m languageId:java t t`	Select and run test	command	`testing.runSelected`
`␣ m languageId:java t A`	Debug all tests	command	`testing.debugAll`
`␣ m languageId:java t T`	Select and debug test	command	`testing.debugSelected`

+Peek

Key Binding: ␣ m languageId:java G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:java G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:java G h`	Peek call hierarchy	command	`editor.showCallHierarchy`
`␣ m languageId:java G i`	Peek implementations	command	`editor.action.peekImplementation`
`␣ m languageId:java G r`	Peek references	command	`editor.action.referenceSearch.trigger`
`␣ m languageId:java G t`	Peek type definition	command	`editor.action.peekTypeDefinition`

+Format

Key Binding: ␣ m languageId:javascript =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:javascript = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:javascript = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:javascript = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:javascript = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:javascript = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:javascript = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Go to

Key Binding: ␣ m languageId:javascript g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:javascript g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:javascript g h`	Show call hierarchy	command	`references-view.showCallHierarchy`
`␣ m languageId:javascript g r`	Go to reference	command	`editor.action.goToReferences`
`␣ m languageId:javascript g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:javascript g t`	Go to type definition	command	`editor.action.goToTypeDefinition`
`␣ m languageId:javascript g I`	Find implementations	command	`references-view.findImplementations`
`␣ m languageId:javascript g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:javascript g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Peek

Key Binding: ␣ m languageId:javascript G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:javascript G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:javascript G h`	Peek call hierarchy	command	`editor.showCallHierarchy`
`␣ m languageId:javascript G i`	Peek implementations	command	`editor.action.peekImplementation`
`␣ m languageId:javascript G r`	Peek references	command	`editor.action.referenceSearch.trigger`
`␣ m languageId:javascript G t`	Peek type definition	command	`editor.action.peekTypeDefinition`

+Format

Key Binding: ␣ m languageId:julia =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:julia = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:julia = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:julia = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:julia = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:julia = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:julia = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Backend

Key Binding: ␣ m languageId:julia b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:julia b i`	Re-index language server cache	command	`language-julia.refreshLanguageServer`
`␣ m languageId:julia b l`	Toggle linter	command	`language-julia.toggleLinter`
`␣ m languageId:julia b r`	Restart language server	command	`language-julia.restartLanguageServer`

+Compile/debug

Key Binding: ␣ m languageId:julia c

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:julia c a`	Add to compiled modules/functions	command	`language-julia.switchToCompiled`
`␣ m languageId:julia c c`	Switch all to compiled	command	`language-julia.switchAllToCompiled`
`␣ m languageId:julia c d`	Debug file in new process	command	`language-julia.debugEditorContents`
`␣ m languageId:julia c i`	Switch all to interpreted	command	`language-julia.switchAllToInterpreted`
`␣ m languageId:julia c m`	Enable compiled mode for the debugger	command	`language-julia.enable-compiled-mode`
`␣ m languageId:julia c r`	Refresh compiled/interpreted pane	command	`language-julia.refreshCompiled`
`␣ m languageId:julia c x`	Remove from compiled modules/functions	command	`language-julia.switchToInterpreted`
`␣ m languageId:julia c A`	Apply default compiled modules/functions	command	`language-julia.apply-compiled-defaults`
`␣ m languageId:julia c D`	Clear compiled modules/functions	command	`language-julia.reset-compiled`
`␣ m languageId:julia c F`	Set current compiled modules/functions as default	command	`language-julia.set-current-as-default-compiled`
`␣ m languageId:julia c M`	Disable compiled mode for the debugger	command	`language-julia.disable-compiled-mode`
`␣ m languageId:julia c R`	Restart kernel	command	`language-julia.restartKernel`
`␣ m languageId:julia c S`	Stop kernel	command	`language-julia.stopKernel`
`␣ m languageId:julia c Y`	Add symbol to compiled modules/functions	command	`language-julia.set-compiled-for-name`

+Clear

Key Binding: ␣ m languageId:julia c

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:julia c c`	Clear current inline results	command	`language-julia.clearCurrentInlineResult`
`␣ m languageId:julia c C`	Clear all inline results	command	`language-julia.clearAllInlineResults`
`␣ m languageId:julia c K`	Clear all inline results in editor	command	`language-julia.clearAllInlineResultsInEditor`

+Environment/package

Key Binding: ␣ m languageId:julia e

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:julia e a`	Activate this environment	command	`language-julia.changeCurrentEnvironment`
`␣ m languageId:julia e c`	Change current environment	command	`language-julia.changeCurrentEnvironment`
`␣ m languageId:julia e m`	Choose module	command	`language-julia.chooseModule`
`␣ m languageId:julia e p`	Activate parent environment	command	`language-julia.changeCurrentEnvironment`
`␣ m languageId:julia e t`	Tag new package version	command	`language-julia.tagNewPackageVersion`
`␣ m languageId:julia e P`	Open package directory	command	`language-julia.openPackageDirectory`

+Go to

Key Binding: ␣ m languageId:julia g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:julia g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:julia g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:julia g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:julia g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:julia g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:julia g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:julia g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Send/REPL

Key Binding: ␣ m languageId:julia s

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:julia s b`	Execute block or selection in REPL	command	`language-julia.executeCodeBlockOrSelection`
`␣ m languageId:julia s c`	Execute code cell in REPL and move	command	`language-julia.executeCellAndMove`
`␣ m languageId:julia s d`	Change directory here	command	`language-julia.cdHere`
`␣ m languageId:julia s f`	Execute file in REPL	command	`language-julia.executeFile`
`␣ m languageId:julia s i`	Start REPL	command	`language-julia.startREPL`
`␣ m languageId:julia s m`	Execute code in REPL and move	command	`language-julia.executeCodeBlockOrSelectionAndMove`
`␣ m languageId:julia s s`	Execute code in REPL	command	`language-julia.executeJuliaCodeInREPL`
`␣ m languageId:julia s C`	Connect external REPL	command	`language-julia.connectREPL`
`␣ m languageId:julia s D`	Stop REPL	command	`language-julia.stopREPL`
`␣ m languageId:julia s F`	Execute active file in REPL	command	`language-julia.executeActiveFile`

+Format

Key Binding: ␣ m languageId:latex =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:latex = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:latex = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:latex = s`	Format selection	command	`editor.action.formatSelection`

+Backend

Key Binding: ␣ m languageId:latex b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex b l`	View Workshop Messages	command	`latex-workshop.log`
`␣ m languageId:latex b m`	Insert root magic comment	command	`latex-workshop.addtexroot`
`␣ m languageId:latex b s`	Select the current environment name	command	`latex-workshop.select-envname`
`␣ m languageId:latex b S`	Select the current environment content	command	`latex-workshop.select-envcontent`

+Build

Key Binding: ␣ m languageId:latex c

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex c c`	Build Project	command	`latex-workshop.build`
`␣ m languageId:latex c i`	Show compilation info	command	`latex-workshop.showCompilationPanel`
`␣ m languageId:latex c k`	Kill compiler process	command	`latex-workshop.kill`
`␣ m languageId:latex c l`	Clean up auxiliary files	command	`latex-workshop.clean`
`␣ m languageId:latex c l`	View compiler logs	command	`latex-workshop.compilerlog`
`␣ m languageId:latex c r`	Build with recipe	command	`latex-workshop.recipes`

+Go to

Key Binding: ␣ m languageId:latex g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex g e`	Navigate to matching begin/end pair	command	`latex-workshop.navigate-envpair`

+Insert

Key Binding: ␣ m languageId:latex i

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex i e`	Close current environment	command	`latex-workshop.close-env`
`␣ m languageId:latex i i`	item	command	`latex-workshop.shortcut.item`
`␣ m languageId:latex i w`	Surround/wrap selection with begin/end	command	`latex-workshop.wrap-env`

+Bibtex

Key Binding: ␣ m languageId:latex l

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex l a`	Align	command	`latex-workshop.bibalign`
`␣ m languageId:latex l s`	Sort	command	`latex-workshop.bibsort`
`␣ m languageId:latex l S`	Sort & Align	command	`latex-workshop.bibalignsort`

+Preview

Key Binding: ␣ m languageId:latex p

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex p d`	View Document	command	`latex-workshop.view`
`␣ m languageId:latex p m`	Toggle Math Preview Panel	command	`latex-workshop.toggleMathPreviewPanel`
`␣ m languageId:latex p p`	SyncTeX from cursor	command	`latex-workshop.synctex`
`␣ m languageId:latex p r`	Refresh all viewers	command	`latex-workshop.refresh-viewer`

+Text

Key Binding: ␣ m languageId:latex x

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex x b`	Bold	command	`latex-workshop.shortcut.textbf`
`␣ m languageId:latex x c`	Small Caps	command	`latex-workshop.shortcut.textsc`
`␣ m languageId:latex x e`	Emphasis	command	`latex-workshop.shortcut.emph`
`␣ m languageId:latex x f`	Sans Serif	command	`latex-workshop.shortcut.textsf`
`␣ m languageId:latex x i`	Italic	command	`latex-workshop.shortcut.textit`
`␣ m languageId:latex x n`	Normal	command	`latex-workshop.shortcut.textnormal`
`␣ m languageId:latex x r`	Roman	command	`latex-workshop.shortcut.textrm`
`␣ m languageId:latex x t`	Terminal	command	`latex-workshop.shortcut.texttt`
`␣ m languageId:latex x u`	Underline	command	`latex-workshop.shortcut.underline`
`␣ m languageId:latex x m`	+Math Fonts	bindings	N/A

+Buffer commands

Key Binding: ␣ m languageId:markdown c

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:markdown c e`	Export to HTML	command	`markdown.extension.printToHtml`
`␣ m languageId:markdown c p`	Open preview to the side	command	`markdown.showPreviewToSide`
`␣ m languageId:markdown c P`	Open preview in current group	command	`markdown.showPreview`

+Table of Contents

Key Binding: ␣ m languageId:markdown t

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:markdown t c`	Create Table of Contents	command	`markdown.extension.toc.create`
`␣ m languageId:markdown t n`	Add section numbers	command	`markdown.extension.toc.addSecNumbers`
`␣ m languageId:markdown t u`	Update Table of Contents	command	`markdown.extension.toc.update`
`␣ m languageId:markdown t N`	Remove section numbers	command	`markdown.extension.toc.removeSecNumbers`

+Text

Key Binding: ␣ m languageId:markdown x

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:markdown x [`	Decrease Heading level	transient	`markdown.extension.editing.toggleHeadingDown`
`␣ m languageId:markdown x ]`	Increase Heading level	transient	`markdown.extension.editing.toggleHeadingUp`
␣ m languageId:markdown x `	Toggle inline code	command	`markdown.extension.editing.toggleCodeSpan`
`␣ m languageId:markdown x b`	Toggle bold	command	`markdown.extension.editing.toggleBold`
`␣ m languageId:markdown x i`	Toggle italic	command	`markdown.extension.editing.toggleItalic`
`␣ m languageId:markdown x l`	Toggle list	command	`markdown.extension.editing.toggleList`
`␣ m languageId:markdown x m`	Toggle math	command	`markdown.extension.editing.toggleMath`
`␣ m languageId:markdown x s`	Toggle strikethrough	command	`markdown.extension.editing.toggleStrikethrough`
`␣ m languageId:markdown x ~`	Toggle code block	command	`markdown.extension.editing.toggleCodeBlock`

+Format

Key Binding: ␣ m languageId:objectpascal =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:objectpascal = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:objectpascal = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:objectpascal = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:objectpascal = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:objectpascal = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:objectpascal = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Go to

Key Binding: ␣ m languageId:objectpascal g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:objectpascal g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:objectpascal g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:objectpascal g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:objectpascal g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:objectpascal g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:objectpascal g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:objectpascal g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Refactor

Key Binding: ␣ m languageId:objectpascal r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:objectpascal r .`	Quick fix	command	`editor.action.quickFix`
`␣ m languageId:objectpascal r r`	Rename symbol	command	`editor.action.rename`

+Peek

Key Binding: ␣ m languageId:objectpascal G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:objectpascal G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:objectpascal G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:php =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:php = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:php = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:php = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:php = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:php = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:php = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Go to

Key Binding: ␣ m languageId:php g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:php g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:php g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:php g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:php g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:php g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:php g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:php g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Refactor

Key Binding: ␣ m languageId:php r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:php r .`	Quick fix	command	`editor.action.quickFix`
`␣ m languageId:php r r`	Rename symbol	command	`editor.action.rename`

+Peek

Key Binding: ␣ m languageId:php G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:php G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:php G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:python =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:python = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:python = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:python = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:python = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:python = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:python = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Backend

Key Binding: ␣ m languageId:python b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:python b o`	Show LSP output	command	`python.viewLanguageServerOutput`
`␣ m languageId:python b r`	Restart LSP	command	`python.analysis.restartLanguageServer`

+Execute

Key Binding: ␣ m languageId:python c

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:python c c`	Execute file in terminal	command	`python.execInTerminal`
`␣ m languageId:python c C`	Execute file in terminal	command	`python.execInTerminal`

+Go to

Key Binding: ␣ m languageId:python g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:python g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:python g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:python g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:python g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:python g s`	Go to symbol in file	command	`workbench.action.gotoSymbol`
`␣ m languageId:python g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:python g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Refactor

Key Binding: ␣ m languageId:python r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:python r .`	Refactor menu	command	`editor.action.refactor`
`␣ m languageId:python r r`	Rename symbol	command	`editor.action.rename`
`␣ m languageId:python r I`	Sort imports	command	`python.sortImports`

+REPL

Key Binding: ␣ m languageId:python s

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:python s i`	Start REPL	command	`python.startREPL`
`␣ m languageId:python s l`	Send line/selection to REPL	command	`python.execSelectionInTerminal`
`␣ m languageId:python s r`	Send line/selection to REPL	command	`python.execSelectionInTerminal`

+Test

Key Binding: ␣ m languageId:python t

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:python t a`	Run all tests	command	`testing.runAll`
`␣ m languageId:python t b`	Run current test file	command	`testing.runCurrentFile`
`␣ m languageId:python t r`	Re-run failed tests	command	`testing.reRunFailTests`
`␣ m languageId:python t t`	Select and run test	command	`testing.runSelected`
`␣ m languageId:python t A`	Debug all tests	command	`testing.debugAll`
`␣ m languageId:python t T`	Select and debug test	command	`testing.debugSelected`

+Peek

Key Binding: ␣ m languageId:python G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:python G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:python G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:quarto =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:quarto = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:quarto = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:quarto = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:quarto = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:quarto = B`	Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:quarto = S`	Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Code actions

Key Binding: ␣ m languageId:quarto a

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:quarto a a`	Execute code action	command	`editor.action.codeAction`
`␣ m languageId:quarto a f`	Execute fix action	command	`editor.action.quickFix`
`␣ m languageId:quarto a r`	Refactor action	command	`editor.action.refactor`
`␣ m languageId:quarto a s`	Source action	command	`editor.action.sourceAction`

+Fold

Key Binding: ␣ m languageId:quarto f

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:quarto f f`	Fold cell	command	`editor.fold`
`␣ m languageId:quarto f u`	Unfold cell	command	`editor.unfold`
`␣ m languageId:quarto f F`	Fold all cells	command	`editor.foldAll`
`␣ m languageId:quarto f U`	Unfold all cells	command	`editor.unfoldAll`

+Go to

Key Binding: ␣ m languageId:quarto g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:quarto g d`	Go to declaration	command	`editor.action.revealDeclaration`
`␣ m languageId:quarto g e`	Go to errors/problems	command	`workbench.actions.view.problems`
`␣ m languageId:quarto g f`	Go to file in explorer	command	`workbench.files.action.showActiveFileInExplorer`
`␣ m languageId:quarto g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:quarto g r`	Go to reference	command	`editor.action.goToReferences`
`␣ m languageId:quarto g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:quarto g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:quarto g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Refactor

Key Binding: ␣ m languageId:quarto r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:quarto r r`	Rename Symbol	command	`editor.action.rename`

+View R

Key Binding: ␣ m languageId:quarto v

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:quarto v c`	Column numbers	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:quarto v h`	head	command	`r.head`
`␣ m languageId:quarto v l`	length	command	`r.length`
`␣ m languageId:quarto v n`	Names	command	`r.names`
`␣ m languageId:quarto v p`	print	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:quarto v r`	Row numbers	command	`r.nrow`
`␣ m languageId:quarto v s`	str	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:quarto v v`	View	command	`r.view`
`␣ m languageId:quarto v C`	Column names	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:quarto v R`	Row names	command	`r.runCommandWithSelectionOrWord`

+Peek

Key Binding: ␣ m languageId:quarto G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:quarto G d`	Peek declaration	command	`editor.action.peekDeclaration`
`␣ m languageId:quarto G g`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:quarto G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:r =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:r = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:r = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:r = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:r = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:r = B`	Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:r = S`	Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Code actions

Key Binding: ␣ m languageId:r a

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:r a a`	Execute code action	command	`editor.action.codeAction`
`␣ m languageId:r a f`	Execute fix action	command	`editor.action.quickFix`
`␣ m languageId:r a r`	Refactor action	command	`editor.action.refactor`
`␣ m languageId:r a s`	Source action	command	`editor.action.sourceAction`

+Go to

Key Binding: ␣ m languageId:r g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:r g d`	Go to declaration	command	`editor.action.revealDeclaration`
`␣ m languageId:r g e`	Go to errors/problems	command	`workbench.actions.view.problems`
`␣ m languageId:r g f`	Go to file in explorer	command	`workbench.files.action.showActiveFileInExplorer`
`␣ m languageId:r g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:r g r`	Go to reference	command	`editor.action.goToReferences`
`␣ m languageId:r g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:r g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:r g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Refactor

Key Binding: ␣ m languageId:r r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:r r r`	Rename Symbol	command	`editor.action.rename`

+View

Key Binding: ␣ m languageId:r v

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:r v c`	Column numbers	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:r v h`	head	command	`r.head`
`␣ m languageId:r v l`	length	command	`r.length`
`␣ m languageId:r v n`	Names	command	`r.names`
`␣ m languageId:r v p`	print	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:r v r`	Row numbers	command	`r.nrow`
`␣ m languageId:r v s`	str	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:r v v`	View	command	`r.view`
`␣ m languageId:r v C`	Column names	command	`r.runCommandWithSelectionOrWord`
`␣ m languageId:r v R`	Row names	command	`r.runCommandWithSelectionOrWord`

+Peek

Key Binding: ␣ m languageId:r G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:r G d`	Peek declaration	command	`editor.action.peekDeclaration`
`␣ m languageId:r G g`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:r G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:ruby =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:ruby = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:ruby = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:ruby = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:ruby = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:ruby = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:ruby = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Go to

Key Binding: ␣ m languageId:ruby g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:ruby g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:ruby g e`	Go to errors/problems	command	`workbench.action.problems.focus`
`␣ m languageId:ruby g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:ruby g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:ruby g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:ruby g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:ruby g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Refactor

Key Binding: ␣ m languageId:ruby r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:ruby r r`	Rename symbol	command	`editor.action.rename`

+Peek

Key Binding: ␣ m languageId:ruby G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:ruby G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:ruby G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:rust =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:rust = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:rust = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:rust = s`	Format selection	command	`editor.action.format`

+Actions

Key Binding: ␣ m languageId:rust a

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:rust a a`	Execute code action	command	`editor.action.codeAction`
`␣ m languageId:rust a f`	Execute fix action	command	`editor.action.quickFix`
`␣ m languageId:rust a s`	Execute source action	command	`editor.action.sourceAction`
`␣ m languageId:rust a r`	+Refactor	bindings	N/A

+Backend

Key Binding: ␣ m languageId:rust b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:rust b d`	Rust analyzer: describe status	command	`rust-analyzer.analyzerStatus`
`␣ m languageId:rust b r`	Rust analyzer: restart server	command	`rust-analyzer.reload`
`␣ m languageId:rust b v`	Rust analyzer: Show version	command	`rust-analyzer.serverVersion`
`␣ m languageId:rust b R`	Rust analyzer: reload workspace	command	`rust-analyzer.reloadWorkspace`

+Goto

Key Binding: ␣ m languageId:rust g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:rust g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:rust g h`	Show call hierarchy	command	`references-view.showCallHierarchy`
`␣ m languageId:rust g i`	Go to implementations	command	`editor.action.goToImplementation`
`␣ m languageId:rust g r`	Go to references	command	`editor.action.goToReferences`
`␣ m languageId:rust g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:rust g t`	Go to type definition	command	`editor.action.goToTypeDefinition`
`␣ m languageId:rust g I`	Find implementations	command	`references-view.findImplementations`
`␣ m languageId:rust g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:rust g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Refactor

Key Binding: ␣ m languageId:rust r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:rust r .`	Refactor menu	command	`editor.action.refactor`
`␣ m languageId:rust r r`	Rename symbol	command	`editor.action.rename`

+Peek

Key Binding: ␣ m languageId:rust G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:rust G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:rust G h`	Peek call hierarchy	command	`editor.showCallHierarchy`
`␣ m languageId:rust G i`	Peek implementations	command	`editor.action.peekImplementation`
`␣ m languageId:rust G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Format

Key Binding: ␣ m languageId:typescript =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:typescript = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:typescript = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:typescript = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:typescript = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:typescript = B`	+Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:typescript = S`	+Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Go to

Key Binding: ␣ m languageId:typescript g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:typescript g d`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:typescript g h`	Show call hierarchy	command	`references-view.showCallHierarchy`
`␣ m languageId:typescript g r`	Go to reference	command	`editor.action.goToReferences`
`␣ m languageId:typescript g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:typescript g t`	Go to type definition	command	`editor.action.goToTypeDefinition`
`␣ m languageId:typescript g I`	Find implementations	command	`references-view.findImplementations`
`␣ m languageId:typescript g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:typescript g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Peek

Key Binding: ␣ m languageId:typescript G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:typescript G d`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:typescript G h`	Peek call hierarchy	command	`editor.showCallHierarchy`
`␣ m languageId:typescript G i`	Peek implementations	command	`editor.action.peekImplementation`
`␣ m languageId:typescript G r`	Peek references	command	`editor.action.referenceSearch.trigger`
`␣ m languageId:typescript G t`	Peek type definition	command	`editor.action.peekTypeDefinition`

+Format

Key Binding: ␣ m languageId:cuda-cpp =

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cuda-cpp = =`	Format region or buffer	command	`editor.action.format`
`␣ m languageId:cuda-cpp = b`	Format buffer	command	`editor.action.formatDocument`
`␣ m languageId:cuda-cpp = c`	Format changes	command	`editor.action.formatChanges`
`␣ m languageId:cuda-cpp = s`	Format selection	command	`editor.action.formatSelection`
`␣ m languageId:cuda-cpp = B`	Format buffer with formatter	command	`editor.action.formatDocument.multiple`
`␣ m languageId:cuda-cpp = S`	Format selection with formatter	command	`editor.action.formatSelection.multiple`

+Backend

Key Binding: ␣ m languageId:cuda-cpp b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cuda-cpp b d`	Reset Database	command	`C_Cpp.ResetDatabase`
`␣ m languageId:cuda-cpp b w`	Rescan Workspace	command	`C_Cpp.RescanWorkspace`

+Debug

Key Binding: ␣ m languageId:cuda-cpp d

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cuda-cpp d f`	Change debug focus	command	`cuda.changeDebugFocus`

+Go to

Key Binding: ␣ m languageId:cuda-cpp g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cuda-cpp g a`	Switch Header/Source	command	`C_Cpp.SwitchHeaderSource`
`␣ m languageId:cuda-cpp g d`	Go to declaration	command	`editor.action.revealDeclaration`
`␣ m languageId:cuda-cpp g e`	Go to errors/problems	command	`workbench.actions.view.problems`
`␣ m languageId:cuda-cpp g f`	Go to file in explorer	command	`workbench.files.action.showActiveFileInExplorer`
`␣ m languageId:cuda-cpp g g`	Go to definition	command	`editor.action.revealDefinition`
`␣ m languageId:cuda-cpp g r`	Go to reference	command	`editor.action.goToReferences`
`␣ m languageId:cuda-cpp g s`	Go to symbol in buffer	command	`workbench.action.gotoSymbol`
`␣ m languageId:cuda-cpp g R`	Find references	command	`references-view.findReferences`
`␣ m languageId:cuda-cpp g S`	Go to symbol in project	command	`workbench.action.showAllSymbols`

+Refactor

Key Binding: ␣ m languageId:cuda-cpp r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cuda-cpp r r`	Rename Symbol	command	`editor.action.rename`

+Peek

Key Binding: ␣ m languageId:cuda-cpp G

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:cuda-cpp G d`	Peek declaration	command	`editor.action.peekDeclaration`
`␣ m languageId:cuda-cpp G g`	Peek definition	command	`editor.action.peekDefinition`
`␣ m languageId:cuda-cpp G r`	Peek references	command	`editor.action.referenceSearch.trigger`

+Wrap

Key Binding: ␣ m languageId:clojure k w

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure k w "`	Wrap around ""	command	`paredit.wrapAroundQuote`
`␣ m languageId:clojure k w (`	Wrap around ()	command	`paredit.wrapAroundParens`
`␣ m languageId:clojure k w [`	Wrap around []	command	`paredit.wrapAroundSquare`
`␣ m languageId:clojure k w c`	Rewrap {}	command	`paredit.rewrapCurly`
`␣ m languageId:clojure k w p`	Rewrap ()	command	`paredit.rewrapParens`
`␣ m languageId:clojure k w q`	Rewrap ""	command	`paredit.rewrapQuote`
`␣ m languageId:clojure k w s`	Rewrap []	command	`paredit.rewrapSquare`
`␣ m languageId:clojure k w {`	Wrap around {}	command	`paredit.wrapAroundCurly`

+Add

Key Binding: ␣ m languageId:clojure r a

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure r a l`	Add missing library specification	command	`clojureLsp.refactor.addMissingLibspec`

+Cycle clean convert

Key Binding: ␣ m languageId:clojure r c

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure r c n`	Clean namespace definition	command	`clojureLsp.refactor.cleanNs`
`␣ m languageId:clojure r c p`	Cycle privacy	command	`clojureLsp.refactor.cyclePrivacy`

+Extract expand

Key Binding: ␣ m languageId:clojure r e

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure r e f`	Extract function	command	`clojureLsp.refactor.extractFunction`
`␣ m languageId:clojure r e l`	Expand let	command	`clojureLsp.refactor.expandLet`

+Introduce inline

Key Binding: ␣ m languageId:clojure r i

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure r i l`	Introduce let	command	`clojureLsp.refactor.introduceLet`
`␣ m languageId:clojure r i s`	Inline symbol	command	`clojureLsp.refactor.inlineSymbol`

+Move

Key Binding: ␣ m languageId:clojure r m

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure r m l`	Move to let	command	`clojureLsp.refactor.moveToLet`

+Thread macros

Key Binding: ␣ m languageId:clojure r t

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:clojure r t f`	Thread first	command	`clojureLsp.refactor.threadFirst`
`␣ m languageId:clojure r t l`	Thread last	command	`clojureLsp.refactor.threadLast`
`␣ m languageId:clojure r t u`	Unwind thread	command	`clojureLsp.refactor.unwindThread`
`␣ m languageId:clojure r t F`	Thread first all	command	`clojureLsp.refactor.threadFirstAll`
`␣ m languageId:clojure r t L`	Thread last all	command	`clojureLsp.refactor.threadLastAll`
`␣ m languageId:clojure r t U`	Unwind thread all	command	`clojureLsp.refactor.unwindThread`

+Create

Key Binding: ␣ m languageId:dart p c

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:dart p c d`	Dart project	command	N/A
`␣ m languageId:dart p c l`	Flutter plugin project	command	N/A
`␣ m languageId:dart p c m`	Flutter module project	command	N/A
`␣ m languageId:dart p c p`	Flutter project	command	N/A
`␣ m languageId:dart p c D`	Create DartDoc	command	N/A
`␣ m languageId:dart p c P`	Flutter package project	command	N/A

+Package actions

Key Binding: ␣ m languageId:go a p

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go a p b`	Build package	command	`go.build.package`
`␣ m languageId:go a p g`	Get package	command	`go.get.package`
`␣ m languageId:go a p i`	Install current package	command	`go.install.package`
`␣ m languageId:go a p l`	Lint package	command	`go.lint.package`
`␣ m languageId:go a p s`	Browse packages	command	`go.browse.packages`
`␣ m languageId:go a p v`	Vet package	command	`go.vet.package`

+Workspace actions

Key Binding: ␣ m languageId:go a w

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go a w b`	Build workspace	command	`go.build.workspace`
`␣ m languageId:go a w l`	Lint workspace	command	`go.lint.workspace`
`␣ m languageId:go a w p`	Add package to workspace	command	`go.add.package.workspace`
`␣ m languageId:go a w v`	Vet workspace	command	`go.vet.workspace`

+Benchmarks

Key Binding: ␣ m languageId:go t b

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go t b f`	Benchmark function at cursor	command	`go.benchmark.cursor`
`␣ m languageId:go t b p`	Benchmark package	command	`go.benchmark.package`
`␣ m languageId:go t b F`	Benchmark file	command	`go.benchmark.file`

+Generate

Key Binding: ␣ m languageId:go t g

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go t g f`	Generate unit tests for function	command	`go.test.generate.function`
`␣ m languageId:go t g p`	Generate unit tests for package	command	`go.test.generate.package`
`␣ m languageId:go t g F`	Generate unit tests for file	command	`go.test.generate.file`

+Toggle

Key Binding: ␣ m languageId:go t T

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:go t T c`	Toggle test coverage in current package	command	`go.test.coverage`
`␣ m languageId:go t T f`	Toggle open test file	command	`go.toggle.test.file`

+Math Fonts

Key Binding: ␣ m languageId:latex x m

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:latex x m a`	Calligraphic	command	`latex-workshop.shortcut.mathcal`
`␣ m languageId:latex x m b`	Bold	command	`latex-workshop.shortcut.mathbf`
`␣ m languageId:latex x m f`	Sans Serif	command	`latex-workshop.shortcut.mathsf`
`␣ m languageId:latex x m i`	Italic	command	`latex-workshop.shortcut.mathit`
`␣ m languageId:latex x m r`	Roman	command	`latex-workshop.shortcut.mathrm`
`␣ m languageId:latex x m t`	Terminal	command	`latex-workshop.shortcut.mathtt`

Decrease Heading level

Key Binding: ␣ m languageId:markdown x [

Type: transient

Key Binding	Name	Type	Command(s)
`[`	Decrease Heading level	command	`markdown.extension.editing.toggleHeadingDown`
`]`	Increase Heading level	command	`markdown.extension.editing.toggleHeadingUp`

Increase Heading level

Key Binding: ␣ m languageId:markdown x ]

Type: transient

Key Binding	Name	Type	Command(s)
`[`	Decrease Heading level	command	`markdown.extension.editing.toggleHeadingDown`
`]`	Increase Heading level	command	`markdown.extension.editing.toggleHeadingUp`

+Refactor

Key Binding: ␣ m languageId:rust a r

Type: bindings

Key Binding	Name	Type	Command(s)
`␣ m languageId:rust a r .`	Execute refactor action	command	`editor.action.refactor`
`␣ m languageId:rust a r r`	Rename symbol	command	`editor.action.rename`