user.letter

Command Result
aira
batb
capc
drumd
eache
finef
gustg
harph
siti
juryj
crunchk
lookl
madem
nearn
oddo
pitp
quenchq
redr
suns
trapt
urgeu
vestv
whalew
plexx
yanky
zipz

user.number_key

Command Result
zero0
one1
two2
three3
four4
five5
six6
seven7
eight8
nine9

user.modifier_key

Command Result
altalt
controlctrl
shiftshift
supersuper

user.special_key

Command Result
endend
enterenter
escapeescape
homehome
insertinsert
pagedownpagedown
pageuppageup
spacespace
tabtab
deletebackspace
forward deletedelete
page uppageup
page downpagedown
menu keymenu
print screenprintscr

user.symbol_key

Command Result
dot.
point.
quote'
apostrophe'
L square[
left square[
square[
R square]
right square]
slash/
backslash\
minus-
dash-
equals=
plus+
tilde~
bang!
down score_
under score_
paren(
L paren(
left paren(
R paren)
right paren)
brace{
left brace{
R brace}
right brace}
angle<
left angle<
less than<
rangle>
R angle>
right angle>
greater than>
star*
hash#
percent%
caret^
amper&
pipe|
dubquote"
double quote"
dollar$
pound£
``
,,
back tick`
grave`
comma,
period.
full stop.
semicolon;
colon:
forward slash/
question mark?
exclamation mark!
exclamation point!
asterisk*
hash sign#
number sign#
percent sign%
at sign@
and sign&
ampersand&
dollar sign$
pound sign£

user.arrow_key

Command Result
downdown
leftleft
rightright
upup

user.punctuation

Command Result
``
,,
back tick`
grave`
comma,
period.
full stop.
semicolon;
colon:
forward slash/
question mark?
exclamation mark!
exclamation point!
asterisk*
hash sign#
number sign#
percent sign%
at sign@
and sign&
ampersand&
dollar sign$
pound sign£

user.function_key

Command Result
F onef1
F twof2
F threef3
F fourf4
F fivef5
F sixf6
F sevenf7
F eightf8
F ninef9
F tenf10
F elevenf11
F twelvef12

Formatters

Command Result
allcapsEXAMPLE OF FORMATTING WITH ALLCAPS
alldownexample of formatting with alldown
camelexampleOfFormattingWithCamel
dottedexample.of.formatting.with.dotted
dubstring"example of formatting with dubstring"
dunder__example__offormattingwithdunder
hammerExampleOfFormattingWithHammer
kebabexample-of-formatting-with-kebab
packedexample::of::formatting::with::packed
padded example of formatting with padded
slasher/example/of/formatting/with/slasher
smashexampleofformattingwithsmash
snakeexample_of_formatting_with_snake
string'example of formatting with string'
titleExample of Formatting With Title

cheatsheet

Command Result
print cheatsheetuser.cheatsheet()

1password

Command Result
password newuser.password_new()
password dupuser.password_duplicate()
password edituser.password_edit()
password deleteuser.password_delete()

1password global

Command Result
password filluser.password_fill()
password showuser.password_show()

amethyst

Command Result
window nextkey("alt-shift-j")
window previouskey("alt-shift-k")
window fullkey("alt-shift-d")
window tallkey("alt-shift-a")
window middlekey("alt-shift-`")
window move mainkey("alt-shift-enter")
window growkey("alt-shift-l")
window shrinkkey("alt-shift-h")
window reevaluatekey("alt-shift-z")

anaconda

Command Result
anaconda"conda "
anaconda help"conda --help\n"
anaconda version"conda --version\n"
anaconda environment list"conda env list\n"
anaconda environment create"conda env create -f "
anaconda environment remove"conda env remove -n "
anaconda activate"conda activate "
anaconda clean"conda clean "
anaconda compare"conda compare "
anaconda config"conda config "
anaconda create"conda create "
anaconda info"conda info "
anaconda init"conda init "
anaconda install"conda install "
anaconda list"conda list "
anaconda package"conda package "
anaconda remove"conda remove "
anaconda uninstall"conda uninstall "
anaconda run"conda run "
anaconda search"conda search "
anaconda update"conda update "
anaconda upgrade"conda upgrade "
anaconda build"conda build "
anaconda convert"conda convert "
anaconda debug"conda debug "
anaconda develop"conda develop "
anaconda environment"conda env "
anaconda index"conda index "
anaconda inspect"conda inspect "
anaconda metapackage"conda metapackage "
anaconda render"conda render "
anaconda server"conda server "
anaconda skeleton"conda skeleton "
anaconda verify"conda verify "

discord

Command Result
[channel] mentions lastuser.discord_mentions_last()
[channel] mentions nextuser.discord_mentions_next()
oldest unreaduser.discord_oldest_unread()
toggle pinsuser.discord_toggle_pins()
toggle inboxuser.discord_toggle_inbox()
toggle (members | member list)user.discord_toggle_members()
pick emojiuser.discord_emoji_picker()
pick (jif | gif | gift)user.discord_gif_picker()
mark inbox channel readuser.discord_mark_inbox_read()
[toggle] (mute | unmute)user.discord_mute()
[toggle] (deafen | undeafen)user.discord_deafen()
answer calluser.discord_answer_call()
decline calluser.discord_decline_call()

eclipse

Command Result
please []key(ctrl-3) insert(user.text or "") # Sidebar
bar explorekey(alt-shift-w p)
bar outlinekey(alt-shift-q o)
panel outputkey(alt-shift-q) sleep(200ms) key(c)
panel problemskey(alt-shift-q) sleep(200ms) key(x)
panel errorskey(alt-shift-q) sleep(200ms) key(l)
panel breakpointskey(alt-shift-q) sleep(200ms) key(b)
panel searchkey(alt-shift-q) sleep(200ms) key(s)
panel variableskey(alt-shift-q) sleep(200ms) key(v) # panel switch: # panel terminal: # Settings
show settingskey(alt-w p)
show shortcutskey(ctrl-shift-l)
file hunt []key(ctrl-shift-r) sleep(50ms) insert(text or "") # file copy path: # file create sibling:
file createkey(ctrl-n)
file open folderkey(alt-shift-w x)
file renamekey(alt-shift-w p enter f2)
file revealkey(alt-shift-w p enter)
imports fixkey(ctrl-shift-o)
refactor renamekey(alt-shift-r)
refactor thiskey(alt-shift-i)
(go declaration | follow)key(f3)
go backkey(alt-left)
go forwardkey(alt-right)
go markskey(alt-end)
toggle markkey(ctrl-alt-b down enter)
go next markkey(alt-pagedown)
go last markkey(alt-pageup)
break pointkey(ctrl-shift-b)
step overkey(f6)
debug step intokey(f5)
debug step out [of]key(f7)
debug continuekey(f8)
copy line downkey(ctrl-alt-down)
copy line upkey(ctrl-alt-up)

file manager

Command Result
title forceuser.file_manager_refresh_title()
manager showuser.file_manager_toggle_pickers()
manager refreshuser.file_manager_update_lists()
go deskuser.file_manager_open_user_directory("Desktop")
go docksuser.file_manager_open_user_directory("Documents")
go downloadsuser.file_manager_open_user_directory("Downloads")
go picturesuser.file_manager_open_user_directory("Pictures")
go profileuser.file_manager_open_user_directory("")
go talon homeuser.file_manager_open_directory(path.talon_home())
go talon useruser.file_manager_open_directory(path.talon_user())
go useruser.file_manager_open_directory(path.user_home())
go backuser.file_manager_go_back()
go forwarduser.file_manager_go_forward()
(go parent | daddy)user.file_manager_open_parent()
follow numb directory = user.file_manager_get_directory_by_index(number_small - 1) user.file_manager_open_directory(directory)
follow {user.file_manager_directories}user.file_manager_open_directory(file_manager_directories)
(select|cell) folder {user.file_manager_directories}user.file_manager_select_directory(file_manager_directories)
open file = user.file_manager_get_file_by_index(number_small - 1) user.file_manager_open_file(file)
folder numb directory = user.file_manager_get_directory_by_index(number_small - 1) user.file_manager_select_directory(directory)
file numb file = user.file_manager_get_file_by_index(number_small - 1) user.file_manager_select_file(file)
file {user.file_manager_files}user.file_manager_select_file(file_manager_files)
(select|cell) file {user.file_manager_files}user.file_manager_select_file(file_manager_files)
folder new user.file_manager_new_folder(text) #show properties
properties showuser.file_manager_show_properties()
terminal hereuser.file_manager_terminal_here()
folder nextuser.file_manager_next_folder_page()
folder lastuser.file_manager_previous_folder_page()
file nextuser.file_manager_next_file_page()
file lastuser.file_manager_previous_file_page()

firefox

Command Result
tab searchbrowser.focus_address() insert("% ")
tab search browser.focus_address() insert("% {text}") key(down)

gdb

Command Result
until "until {number}"
force clear all break pointsinsert("d br\n") insert("y\n")
break [on] clipboardinsert("break ") key(ctrl-shift-v) key(enter) # information
list [source]"list\n"
info source"info source\n"
print"p "
print [variable] "p {text}"
print hex"p/x "
print hex [variable] "p/x {text}"
print string"p/s "
hex dump bytes"x/{number}bx "
hex dump (half|short) words"x/{number}hx "
hex dump (d|long) words"x/{number}dx "
hex dump quad words"x/{number}gx "
hex dump"x/100gx "
hex dump highlightedinsert("x/100gx ") edit.copy() edit.paste() key(enter)
hex dump clipboardinsert("x/100gx ") edit.paste() key(enter) # execution
source"source \t\t"
(list|show|info) display"info display\n"
display assembly line"display /i $pc\n"
display source"display "
enable display "enable display {number_small}\n"
disable display "disable display {number_small}\n"
undisplay"undisplay\n"
(list|show|info) local"info local "
(list|show|info) local typed"info local -t "
(list|show|info) variable"info variable "
(list|show|info) variable typed"info variable -t "
(list|show|info) locals"info local\n"
(list|show|info) variables"info variables\n"
info threads"info threads\n"
restart [program]"r\n"
continue"c\n"
back trace"bt\n"
debug quit"quit\n"
debug force quit"quit\ny\n"
(show|info) (inf|inferiors)"info inferiors\n"
inferior "inferior {number_small}\n"
inferior"inferior "
resume main (inf|inferior)insert("inferior 1\n") insert("c\n")
resume [from] (inf|inferior) insert("inferior {number_small}\n") insert("c\n") # arguments
set args"set args "
show follow (fork|forks) [mode]"show follow-fork-mode\n"
[set] follow (fork|forks) [mode] child"set follow-fork-mode child\n"
[set] follow (fork|forks) [mode] parent"set follow-fork-mode parent\n"
show detach on fork"show detach-on-fork\n"
set detach on fork"set detach-on-fork on\n"
unset detach on fork"set detach-on-fork off\n"
show list size"show listsize\n"
set list size "set listsize {number_small}\n"
clear screen"shell clear\n"

generic browser

Command Result
(address bar | go address | go url)browser.focus_address()
(address copy | url copy | copy address | copy url)browser.focus_address() sleep(50ms) edit.copy()
go homebrowser.go_home()
[go] forwardbrowser.go_forward()
go (back | backward)browser.go_back()
go to {user.website}browser.go(website)
go privatebrowser.open_private_window()
bookmark showbrowser.bookmarks()
bookmark barbrowser.bookmarks_bar()
bookmark itbrowser.bookmark()
bookmark tabsbrowser.bookmark_tabs()
(refresh | reload) itbrowser.reload()
(refresh | reload) it hardbrowser.reload_hard()
show downloadsbrowser.show_downloads()
show extensionsbrowser.show_extensions()
show historybrowser.show_history()
show cachebrowser.show_clear_cache()
dev toolsbrowser.toggle_dev_tools()

generic debugger

Command Result
step intouser.debugger_step_into()
step overuser.debugger_step_over()
step lineuser.debugger_step_line()
step over lineuser.debugger_step_over_line()
step outuser.debugger_step_out()
continueuser.debugger_continue()
debug startuser.debugger_start()
debug stopuser.debugger_stop()
debug exituser.debugger_exit()
debug detachuser.debugger_detach()
debug restartuser.debugger_restart()
show registersuser.debugger_show_registers()
get registeruser.debugger_get_register()
set registeruser.debugger_set_register()
break nowuser.debugger_break_now()
break hereuser.debugger_break_here()
(list|show) (breaks|break points)user.debugger_show_breakpoints()
(set|add) (break|break point)user.debugger_add_sw_breakpoint()
(set|add) hardware (break|break point)user.debugger_add_hw_breakpoint()
clear all (breaks|break points)user.debugger_clear_all_breakpoints()
clear (break|break point)user.debugger_clear_breakpoint()
clear (break|break point) user.debugger_clear_breakpoint_id(number_small)
disable all (breaks|break points)user.debugger_disable_all_breakpoints()
disable (break|break point)user.debugger_disable_breakpoint()
disable (break|break point) user.debugger_disable_breakpoint_id(number_small)
enable all (breaks|break points)user.debugger_enable_all_breakpoints()
enable (break|break point)user.debugger_enable_breakpoint()
enable (break|break point) user.debugger_enable_breakpoint_id(number_small) # Navigation # Memory Inspection
(stack|back) traceuser.debugger_backtrace()
disassembleuser.debugger_disassemble()
disassemble hereuser.debugger_disassemble_here()
disassemble clipboarduser.debugger_disassemble_clipboard()
jump to addressuser.debugger_goto_address()
jump to clipboarduser.debugger_goto_clipboard()
jump to highlighteduser.debugger_goto_highlighted()
dump stringuser.debugger_dump_ascii_string()
dump unicode [string]user.debugger_dump_unicode_string()
dump pointersuser.debugger_dump_pointers()
list modulesuser.debugger_list_modules()
inspect typeuser.debugger_inspect_type()
clear lineuser.debugger_clear_line()

generic terminal

Command Result
lisauser.terminal_list_directories()
lisa alluser.terminal_list_all_directories()
katie []user.terminal_change_directory(text or "")
katie rootuser.terminal_change_directory_root()
clear screenuser.terminal_clear_screen()
run lastuser.terminal_run_last()
rerun []user.terminal_rerun_search(text or "")
rerun searchuser.terminal_rerun_search("")
kill alluser.terminal_kill_all()

i3wm

Command Result
port user.system_command("i3-msg workspace {number_small}")
port tenuser.system_command("i3-msg workspace 10")
(port flip|flipper)user.system_command("i3-msg workspace back_and_forth")
port rightuser.system_command("i3-msg workspace next")
port leftuser.system_command("i3-msg workspace prev")
(win|window) leftuser.system_command("i3-msg focus left")
(win|window) rightuser.system_command("i3-msg focus right")
(win|window) upuser.system_command("i3-msg focus up")
(win|window) downuser.system_command("i3-msg focus down")
((win|window) kill|murder)user.system_command("i3-msg kill")
(win|window) stackinguser.system_command("i3-msg layout stacking")
(win|window) defaultuser.system_command("i3-msg layout toggle split")
(win|window) tabbeduser.system_command("i3-msg layout tabbed")
reload i three configuser.system_command("i3-msg reload")
restart i threeuser.system_command("i3-msg restart")
(full screen|scuba)user.system_command("i3-msg fullscreen")
toggle floatinguser.system_command("i3-msg floating toggle")
focus floatinguser.system_command("i3-msg focus mode_toggle")
center windowuser.system_command("i3-msg move position center")
resize modeuser.system_command('i3-msg mode "resize"')
focus parentuser.system_command("i3-msg focus parent")
focus childuser.system_command("i3-msg focus child")
grow windowuser.system_command('i3-msg mode "resize"') key(right:10) key(down:10) # escape resize mode key(escape) # center window sleep(200ms) user.system_command("i3-msg move position center") # resize helpers
shrink windowuser.system_command('i3-msg mode "resize"') key(left:10) key(up:10) # escape resize mode key(escape) # center window sleep(200ms) user.system_command("i3-msg move position center")
horizontal (shell|terminal)user.system_command("i3-msg split h") user.i3wm_shell()
vertical (shell|terminal)user.system_command("i3-msg split v") user.i3wm_shell() # XXX - just replace with shuffle eventually? # XXX - like also need to match the generic talon commands
(shuffle|move (win|window) [to] port) user.system_command("i3-msg move container to workspace {number_small}")
(shuffle|move (win|window) [to] port ten)user.system_command("i3-msg move container to workspace 10")
(shuffle|move (win|window) [to] last port)user.system_command("i3-msg move container to workspace back_and_forth")
(shuffle|move (win|window) left)user.system_command("i3-msg move left")
(shuffle|move (win|window) right)user.system_command("i3-msg move right")
(shuffle|move (win|window) up)user.system_command("i3-msg move up")
(shuffle|move (win|window) down)user.system_command("i3-msg move down")
(win|window) horizontaluser.system_command("i3-msg split h")
(win|window) verticaluser.system_command("i3-msg split v")
make scratchuser.system_command("i3-msg move scratchpad")
[(show|hide)] scratchuser.system_command("i3-msg scratchpad show")
next scratchuser.system_command("i3-msg scratchpad show") user.system_command("i3-msg scratchpad show") # these rely on the user settings for the mod key. see i3wm.py Actions class
launchuser.i3wm_launch()
launch user.i3wm_launch() sleep(100ms) insert("{text}")
lock screenuser.i3wm_launch()
(launch shell|koopa)user.i3wm_shell()
new scratch (shell|window)user.i3wm_shell() sleep(200ms) user.system_command("i3-msg move scratchpad") user.system_command("i3-msg scratchpad show")

jetbrains

Command Result
completeuser.idea("action CodeCompletion")
perfectuser.idea("action CodeCompletion,action CodeCompletion")
smartuser.idea("action SmartTypeCompletion")
(done | finish)user.idea("action EditorCompleteStatement")
grab user.idea_grab(number)
(action | please)user.idea("action GotoAction")
(action | please) user.idea("action GotoAction") insert(text) # Refactoring
refactoruser.idea("action Refactorings.QuickListPopupAction")
refactor user.idea("action Refactorings.QuickListPopupAction") insert(text)
extract variableuser.idea("action IntroduceVariable")
extract fielduser.idea("action IntroduceField")
extract constantuser.idea("action IntroduceConstant")
extract parameteruser.idea("action IntroduceParameter")
extract interfaceuser.idea("action ExtractInterface")
extract methoduser.idea("action ExtractMethod")
refactor in lineuser.idea("action Inline")
refactor moveuser.idea("action Move")
refactor renameuser.idea("action RenameElement")
rename fileuser.idea("action RenameFile")
fix (format | formatting)user.idea("action ReformatCode")
fix importsuser.idea("action OptimizeImports")
(go declaration | follow)user.idea("action GotoDeclaration")
go implementationuser.idea("action GotoImplementation")
go usageuser.idea("action FindUsages")
go typeuser.idea("action GotoTypeDeclaration")
go testuser.idea("action GotoTest")
go backuser.idea("action Back")
go forwarduser.idea("action Forward")
find (everywhere | all)user.idea("action SearchEverywhere")
find (everywhere | all) [over]user.idea("action SearchEverywhere") sleep(500ms) insert(text)
(search | find) classuser.idea("action GotoClass")
(search | find) fileuser.idea("action GotoFile")
(search | find) pathuser.idea("action FindInPath")
(search | find) symboluser.idea("action GotoSymbol")
(search | find) symbol user.idea("action GotoSymbol") insert(text) key("enter")
recentuser.idea("action RecentFiles")
surround [this] with [over]idea("action SurroundWith") sleep(500ms) insert(text) # Making these longer to reduce collisions with real code dictation.
insert generated [over]user.idea("action Generate") sleep(500ms) insert(text)
insert template [over]idea("action InsertLiveTemplate") sleep(500ms) insert(text)
create (template|snippet)user.idea("action SaveAsTemplate")
toggle recordinguser.idea("action StartStopMacroRecording")
change (recording | recordings)user.idea("action EditMacros")
play recordinguser.idea("action PlaybackLastMacro")
play recording [over]idea("action PlaySavedMacrosAction") insert(text) sleep(500ms) Key("enter") # Marks
go markuser.idea("action ShowBookmarks")
toggle markuser.idea("action ToggleBookmark")
go next markuser.idea("action GotoNextBookmark")
go last markuser.idea("action GotoPreviousBookmark")
toggle mark user.idea("action ToggleBookmark{number}")
go mark user.idea("action GotoBookmark{number}")
expand deepuser.idea("action ExpandRegionRecursively")
expand alluser.idea("action ExpandAllRegions")
collapse deepuser.idea("action CollapseRegionRecursively")
collapse alluser.idea("action CollapseAllRegions")
go next (method | function)user.idea("action MethodDown")
go last (method | function)user.idea("action MethodUp")
clippingsuser.idea("action PasteMultiple")
copy pathuser.idea("action CopyPaths")
copy referenceuser.idea("action CopyReference")
copy prettyuser.idea("action CopyAsRichText")
create siblinguser.idea("action NewElementSamePlace")
create sibling [over]user.idea("action NewElementSamePlace") sleep(500ms) insert(text)
create fileuser.idea("action NewElement")
create file [over]user.idea("action NewElement") sleep(500ms) insert(text) # Task Management
go taskuser.idea("action tasks.goto")
go browser taskuser.idea("action tasks.open.in.browser")
switch taskuser.idea("action tasks.switch")
clear taskuser.idea("action tasks.close")
configure serversuser.idea("action tasks.configure.servers")
git pulluser.idea("action Vcs.UpdateProject")
git commituser.idea("action CheckinProject")
git pushuser.idea("action CheckinProject")
git loguser.idea("action Vcs.ShowTabbedFileHistory")
git browseuser.idea("action Github.Open.In.Browser")
git (gets | gist)user.idea("action Github.Create.Gist")
git (pull request | request)user.idea("action Github.Create.Pull.Request")
git (view | show | list) (requests | request)user.idea("action Github.View.Pull.Request")
git (annotate | blame)user.idea("action Annotate")
git menuuser.idea("action Vcs.QuickListPopupAction")
toggle projectuser.idea("action ActivateProjectToolWindow")
toggle finduser.idea("action ActivateFindToolWindow")
toggle runuser.idea("action ActivateRunToolWindow")
toggle debuguser.idea("action ActivateDebugToolWindow")
toggle eventsuser.idea("action ActivateEventLogToolWindow")
toggle terminaluser.idea("action ActivateTerminalToolWindow")
toggle gituser.idea("action ActivateVersionControlToolWindow")
toggle structureuser.idea("action ActivateStructureToolWindow")
toggle databaseuser.idea("action ActivateDatabaseToolWindow")
toggle database changesuser.idea("action ActivateDatabaseChangesToolWindow")
toggle makeuser.idea("action ActivatemakeToolWindow")
toggle to douser.idea("action ActivateTODOToolWindow")
toggle dockeruser.idea("action ActivateDockerToolWindow")
toggle favoritesuser.idea("action ActivateFavoritesToolWindow")
toggle lastuser.idea("action JumpToLastWindow")
toggle pinneduser.idea("action TogglePinnedMode")
toggle dockeduser.idea("action ToggleDockMode")
toggle floatinguser.idea("action ToggleFloatingMode")
toggle windoweduser.idea("action ToggleWindowedMode")
toggle splituser.idea("action ToggleSideMode")
toggle tool buttonsuser.idea("action ViewToolButtons")
toggle toolbaruser.idea("action ViewToolBar")
toggle status [bar]user.idea("action ViewStatusBar")
toggle navigation [bar]user.idea("action ViewNavigationBar")
toggle power saveuser.idea("action TogglePowerSave")
toggle whitespaceuser.idea("action EditorToggleShowWhitespaces")
toggle indentsuser.idea("action EditorToggleShowIndentLines")
toggle line numbersuser.idea("action EditorToggleShowLineNumbers")
toggle (bread crumbs | breadcrumbs)user.idea("action EditorToggleShowBreadcrumbs")
toggle gutter iconsuser.idea("action EditorToggleShowGutterIcons")
toggle wrapuser.idea("action EditorToggleUseSoftWraps")
toggle parametersuser.idea("action ToggleInlineHintsAction")
toggle fullscreenuser.idea("action ToggleFullScreen")
toggle distraction [free mode]user.idea("action ToggleDistractionFreeMode")
toggle presentation [mode]user.idea("action TogglePresentationMode")
toggle commentcode.toggle_comment()
change schemeuser.idea("action QuickChangeScheme")
(toggle | pop) (doc | documentation)user.idea("action QuickJavaDoc")
(pop deaf | toggle definition)user.idea("action QuickImplementations")
pop typeuser.idea("action ExpressionTypeInfo")
pop parametersuser.idea("action ParameterInfo")
go breakpointsuser.idea("action ViewBreakpoints")
toggle [line] breakpointuser.idea("action ToggleLineBreakpoint")
toggle method breakpointuser.idea("action ToggleMethodBreakpoint")
run menuuser.idea("action ChooseRunConfiguration")
run testuser.idea("action RunClass")
run test againuser.idea("action Rerun")
debug testuser.idea("action DebugClass")
step overuser.idea("action StepOver")
step intouser.idea("action StepInto")
step smartuser.idea("action SmartStepInto")
step to lineuser.idea("action RunToCursor")
continueuser.idea("action Resume")
(grow | shrink) window rightuser.idea("action ResizeToolWindowRight")
(grow | shrink) window leftuser.idea("action ResizeToolWindowLeft")
(grow | shrink) window upuser.idea("action ResizeToolWindowUp")
(grow | shrink) window downuser.idea("action ResizeToolWindowDown")
go next (error | air)user.idea("action GotoNextError")
go last (error | air)user.idea("action GotoPreviousError")
fix next (error | air)user.idea("action GotoNextError") user.idea("action ShowIntentionActions")
fix last (error | air)user.idea("action GotoPreviousError") user.idea("action ShowIntentionActions") # Special Selects
select lessuser.idea("action EditorUnSelectWord")
select (more|this)user.idea("action EditorSelectWord")
expand until user.select_range(number_1, number_2) user.idea("action ExpandRegion")
collapse until user.select_range(number_1, number_2) user.idea("action CollapseRegion")
paste until user.select_range(number_1, number_2) user.idea("action EditorPaste")
refactor until user.select_range(number_1, number_2) user.idea("action Refactorings.QuickListPopupAction")
clone user.line_clone(number)
clear last [over]user.idea("find prev {text}, action EditorBackSpace")
clear next [over]user.idea("find next {text}, action EditorBackSpace")
comment last [over]user.idea("find prev {text}, action CommentByLineComment")
comment next [over]user.idea("find next {text}, action CommentByLineComment")
go last [over]user.idea("find prev {text}, action EditorRight")
go next [over]user.idea("find next {text}, action EditorRight")
paste last [over]user.idea("find prev {text}, action EditorRight, action EditorPaste")
paste next [over]user.idea("find next {text}, action EditorRight, action EditorPaste")
refactor last [over]user.idea("find prev {text}, action Refactorings.QuickListPopupAction")
refactor next [over]user.idea("find next {text}, action Refactorings.QuickListPopupAction")
replace last [over]user.idea("find prev {text}, action EditorPaste")
replace next [over]user.idea("find next {text}, action EditorPaste")
select last [over]user.idea("find prev {text}")
select next [over]user.idea("find next {text}")
select camel leftuser.extend_camel_left()
select camel rightuser.extend_camel_right()
go camel leftuser.camel_left()
go camel rightuser.camel_right()
blackenuser.idea("action BLACKReformatCode")

kubectl

Command Result
cube [control]"kubectl "
cube create"kubectl create "
cube expose"kubectl expose "
cube run"kubectl run "
cube set"kubectl set "
cube run container"kubectl run-container "
cube explain"kubectl explain "
cube get"kubectl get "
cube edit"kubectl edit "
cube delete"kubectl delete "
cube rollout"kubectl rollout "
cube rolling-update"kubectl rolling-update "
cube scale"kubectl scale "
cube auto scale"kubectl autoscale "
cube certificate"kubectl certificate "
cube top"kubectl top "
cube drain"kubectl drain "
cube taint"kubectl taint "
cube (cord | cordon)"kubectl cordon "
cube (uncord | uncordon)"kubectl uncordon "
cube cluster (info | information)"kubectl cluster-info "
cube describe"kubectl describe "
cube logs"kubectl logs "
cube attach"kubectl attach "
cube exec"kubectl exec "
cube port forward"kubectl port-forward "
cube proxy"kubectl proxy "
cube copy"kubectl cp "
cube auth"kubectl auth "
cube diff"kubectl diff "
cube apply"kubectl apply "
cube patch"kubectl patch "
cube replace"kubectl replace "
cube wait"kubectl wait "
cube convert"kubectl convert "
cube customize"kubectl kustomize "
cube label"kubectl label "
cube annotate"kubectl annotate "
cube completion"kubectl completion "
cube (interface | API)"kubectl api "
cube interface resources"kubectl api-resources "
cube interface versions"kubectl api-versions "
cube config"kubectl config "
cube help"kubectl help "
cube plugin"kubectl plugin "
cube version"kubectl version "
cube {user.kubectl_action} [{user.kubectl_object}]insert("kubectl {kubectl_action} ") insert(kubectl_object or "")
cube detachkey("ctrl-p") key("ctrl-q")
cube shellinsert("kubectl exec -it -- /bin/bash") key("left:13")

linux dunst

Command Result
show notificationskey(ctrl-`)
dismiss [notifications]user.system_command('dunstctl close')
dismiss all [notifications]user.system_command('dunstctl close-all')

linux keepassx

Command Result
open databasekey(ctrl-o)
save databasekey(ctrl-s)
close databasekey(ctrl-w)
lock databasekey(ctrl-l)
quitkey(ctrl-q)
[add] new entrykey(ctrl-n)
clone entrykey(ctrl-k)
(view|edit) entrykey(ctrl-e)
delete entrykey(ctrl-d)
copy user [name]key(ctrl-b)
copy passwordkey(ctrl-c)
open (earl|url|link)key(ctrl-u)
copy (earl|url|link)key(ctrl-alt-u)
findkey(ctrl-f)
find key(ctrl-f) insert("{text}")

linux signal

Command Result
show shortcutskey("ctrl-/")
(next|nav|navigate) [by] (sec|section)key("ctrl-t")
(prev|previous) (chat|conversation)key("alt-down")
next (chat|conversation)key("alt-up")
(prev|previous) unreadkey("alt-shift-down")
next unreadkey("alt-shift-up")
[open] (pref|preferences)key("ctrl-,")
open conversation menukey("ctrl-shift-l")
searchkey("ctrl-f")
search chatkey("ctrl-shift-f")
focus (chat|composer)key("ctrl-shift-t")
open mediakey("ctrl-shift-m")
open emojikey("ctrl-shift-j")
open stickerkey("ctrl-shift-s")
record [voice] messagekey("ctrl-shift-v")
archive chatkey("ctrl-shift-a")
unarchive chatkey("ctrl-shift-u")
(first|top) messagekey("ctrl-up")
(last|bottom) messagekey("ctrl-down")
close chatkey("ctrl-shift-c")
send itkey("enter")
message detailskey("ctrl-d")
reply [message]key("ctrl-shift-r")
react [message]key("ctrl-shift-e")
save attachmentkey("ctrl-s")
delete [message]key("ctrl-shift-d")
send messagekey("ctrl-enter")
expand chatkey("ctrl-shift-x")
attach [file]key("ctrl-u")
remove [link] previewkey("ctrl-p")
remove [link] attachmentkey("ctrl-shift-p")

linux taskwarrior

Command Result
task version"task --version\n"
task commands"task commands\n"
task help"task help\n"
task list"task list\n"
task list orphans"task project: list\n"
task list untagged"task tags.none: list\n"
task list "task list {text}\n"
task list project"task list project: "
task list project "task list project:{text}\n"
task add"task add "
task add "task add {text}\n"
task undo"task undo\n"
(tasks|task next)"task next\n"
task edit"task {number} edit"
task done"task {number} done"
task delete"task {number} delete"

linux termite

Command Result
shell yankkey("y")
shell selectkey("ctrl-shift-space")
shell insertkey("escape")
visual linekey("v")
visual line modekey("V")

linux tmux

Command Result
mux"tmux "
mux new sessioninsert('tmux new ')
mux sessionskey(ctrl-b) key(s)
mux name sessionkey(ctrl-b) key($)
mux kill sessioninsert('tmux kill-session -t ') #window management
mux new windowkey(ctrl-b) key(c)
mux window key(ctrl-b ) key('{number}')
mux previous windowkey(ctrl-b) key(p)
mux next windowkey(ctrl-b) key(n)
mux rename windowkey(ctrl-b) key(,)
mux close windowkey(ctrl-b) key(&) #pane management
mux split horizontalkey(ctrl-b) key(%)
mux split verticalkey(ctrl-b) key(")
mux next panekey(ctrl-b) key(o)
mux move key(ctrl-b) key(arrow_key)
mux close panekey(ctrl-b) key(x) #Say a number right after this command, to switch to pane
mux pane numberskey(ctrl-b) key(q)

mac datagrip

Command Result
runkey(cmd-enter)
run itkey(cmd-enter) sleep(50ms) key(enter)
backkey(alt-left)
fwackkey(alt-right)
erasekey(alt-backspace)
move upkey(cmd-shift-up)
move downkey(cmd-shift-down)

mac desktops

Command Result
desk user.desktop(number)
window move desk user.window_move_desktop(number)
window move desk leftuser.window_move_desktop_left()
window move desk rightuser.window_move_desktop_right()

mac finder

Command Result
preferenceskey(cmd-,)
optionskey(cmd-j)
searchkey(cmd-alt-f)
sort by nonekey(ctrl-alt-cmd-0)
sort by namekey(ctrl-alt-cmd-1)
sort by kindkey(ctrl-alt-cmd-2)
sort by date openedkey(ctrl-alt-cmd-3)
sort by date addedkey(ctrl-alt-cmd-4)
sort by date modifiedkey(ctrl-alt-cmd-5)
sort by sizekey(ctrl-alt-cmd-6)
icon viewkey(cmd-1)
column viewkey(cmd-3)
list viewkey(cmd-2)
gallery viewkey(cmd-4)
copy pathkey(alt-cmd-c)
trash itkey(cmd-backspace)
hide [finder]key(cmd-h)
hide othersapp.window_hide_others()

mac rstudio

Command Result
run thatkey("cmd-enter")
run documentkey("cmd-alt-r")
run from topkey("cmd-alt-b")
run to endkey("cmd-alt-e")
run (function|funk)key("cmd-alt-f")
run sectionkey("cmd-alt-t")
run previous chunkskey("cmd-alt-p")
run chunkkey("cmd-alt-c")
run next chunkkey("cmd-alt-n")
run allkey("cmd-shift-s")
run knitterkey("cmd-shift-k")
run profilerkey("cmd-shift-alt-p")
jump backkey("cmd-f9")
jump forwardkey("cmd-f10")
close all tabskey("cmd-shift-w")
indent lineskey("cmd-i")
toggle commentkey("cmd-shift-c")
reformat commentkey("cmd-shift-/")
reformat R codekey("cmd-shift-a")
line upkey("alt-up")
line downkey("alt-down")
duplicate line upkey("cmd-alt-up")
duplicate line [down]key("cmd-alt-down")
select to parenkey("ctrl-shift-e")
select to matching parenkey("ctrl-shift-alt-e")
jump to matchingkey("ctrl-p")
expand selectionkey("shift-alt-cmd-up")
reduce selectionkey("shift-alt-cmd-down")
add cursor upkey("ctrl-alt-up")
add cursor downkey("ctrl-alt-down")
move active cursor upkey("ctrl-alt-shift-up")
move active cursor downkey("ctrl-alt-shift-down")
delete linekey("cmd-d")
delete word leftkey("alt-backspace")
delete word rightkey("alt-delete")
assign thatkey("alt--")
pipe thatkey("cmd-shift-m")
insert knitter chunkkey("cmd-alt-i")
fold thatkey("cmd-alt-l")
unfold thatkey("cmd-shift-alt-l")
fold allkey("cmd-alt-o")
unfold allkey("cmd-shift-alt-o")
find and replacekey("cmd-f")
find nextkey("cmd-g")
find previouskey("cmd-shift-g")
find with selectionkey("cmd-e")
find in fileskey("cmd-shift-f")
run replacekey("cmd-shift-j")
run spell checkkey("f7")
go to sourcekey("ctrl-1")
go to consolekey("ctrl-2")
go to helpkey("ctrl-3")
go to historykey("ctrl-4")
go to fileskey("ctrl-5")
go to (plots|plot)key("ctrl-6")
go to packageskey("ctrl-7")
go to environmentkey("ctrl-8")
go to gitkey("ctrl-9")
go to buildkey("ctrl-0")
go to terminalkey("alt-shift-t")
go to omnikey("ctrl-.")
go to linekey("cmd-shift-alt-g")
go to sectionkey("cmd-shift-alt-j")
go to tabkey("ctrl-shift-.")
go to previous tabkey("ctrl-f11")
go to next tabkey("ctrl-f12")
go to first tabkey("ctrl-shift-f11")
go to last tabkey("ctrl-shift-f12")
zoom sourcekey("ctrl-shift-1")
(zoom|show) allkey("ctrl-shift-0")
help thatkey("f1")
define thatkey("f2")
previous plotkey("cmd-alt-f11")
next plotkey("cmd-alt-f12")
restart R sessionkey("cmd-shift-f10")
dev tools buildkey("cmd-shift-b")
dev tools load allkey("cmd-shift-l")
dev tools testkey("cmd-shift-t")
dev tools checkkey("cmd-shift-e")
dev tools documentkey("cmd-shift-d")
toggle breakpointkey("shift-f9")
debug nextkey("f10")
debug step into (function|funk)key("shift-f4")
debug finish (function|funk)key("shift-f6")
debug continuekey("shift-f5")
debug stopkey("shift-f8")
run git diffkey("ctrl-alt-d")
run git commitkey("ctrl-alt-m")

mac terminal

Command Result
suspendkey(ctrl-z)
resumeinsert("fg") key(enter)

win explorer

Command Result
go user.file_manager_open_volume("{letter}:")
go app datauser.file_manager_open_directory("%AppData%")
go program filesuser.file_manager_open_directory("%programfiles%")

win outlook

Command Result
archivekey(alt h o 1)
new e-mailkey(ctrl-n)
calendarkey(ctrl-2)
inboxkey(ctrl-1)
Replykey(ctrl-r)
Reply allkey(ctrl-shift-r)
Forwardkey(ctrl-f)
acceptkey(shift-f10 c c enter)

win windows terminal

Command Result
settings openkey(ctrl-,)
focus leftkey(ctrl-alt-shift-left)
focus rightkey(ctrl-alt-shift-right)
focus upkey(ctrl-alt-shift-up)
focus downkey(ctrl-alt-shift-down)
split rightkey(ctrl-shift-h)
split downkey(ctrl-h)
term menukey(ctrl-shift-f1)
run lastkey(up enter)
kill allkey(ctrl-c) insert("y") key(enter)

win ubuntu

Command Result
go user.file_manager_open_volume("/mnt/{letter}")

mac slack mac

Command Result
workspace key("cmd-{number}")
(slack | lack) [channel] infokey(cmd-shift-i)
(move | next) focuskey(ctrl-`)
[next] (section | zone)key(f6)
(previous | last) (section | zone)key(shift-f6)
(slack | lack) [direct] messageskey(cmd-shift-k)
(slack | lack) threadskey(cmd-shift-t)
(slack | lack) (history [next] | back | backward)key(cmd-[)
(slack | lack) forwardkey(cmd-])
[next] (element | bit)key(tab)
(previous | last) (element | bit)key(shift-tab)
(slack | lack) (my stuff | activity)key(cmd-shift-m)
(slack | lack) directorykey(cmd-shift-e)
(slack | lack) (starred [items] | stars)key(cmd-shift-s)
(slack | lack) unread [messages]key(cmd-j)
(go | undo | toggle) fullkey(ctrl-cmd-f)
grab leftkey(shift-up)
grab rightkey(shift-down)
add linekey(shift-enter)
(slack | lack) (slap | slaw | slapper)key(cmd-right shift-enter)
(slack | lack) (react | reaction)key(cmd-shift-\\)
(insert command | commandify)key(cmd-shift-c)
insert codeinsert("``````") key(left left left) key(shift-enter) key(shift-enter) key(up)
(slack | lack) (bull | bullet | bulleted) [list]key(cmd-shift-8)
(slack | lack) (number | numbered) [list]key(cmd-shift-7)
(slack | lack) (quotes | quotation)key(cmd-shift->)
boldkey(cmd-b)
(italic | italicize)key(cmd-i)
(strike | strikethrough)key(cmd-shift-x)
(clear | scrap | scratch)key(cmd-a backspace)
(slack | lack) snippetkey(cmd-shift-enter)
([toggle] mute | unmute)key(m)
(slack | lack) ([toggle] video)key(v)
(slack | lack) invitekey(a)
(slack | lack) shortcutskey(cmd-/)
emote "{text}"
toggle left sidebarkey(cmd-shift-d)
toggle right sidebarkey(cmd-.)

win slack win

Command Result
workspace key("ctrl-{number}")
(slack | lack) [channel] infokey(ctrl-shift-i)
(move | next) focuskey(ctrl-`)
[next] (section | zone)key(f6)
(previous | last) (section | zone)key(shift-f6)
(slack | lack) [direct] messageskey(ctrl-shift-k)
(slack | lack) threadskey(ctrl-shift-t)
(slack | lack) (history [next] | back | backward)key(alt-left)
(slack | lack) forwardkey(alt-right)
[next] (element | bit)key(tab)
(previous | last) (element | bit)key(shift-tab)
(slack | lack) (my stuff | activity)key(ctrl-shift-m)
(slack | lack) directorykey(ctrl-shift-e)
(slack | lack) (starred [items] | stars)key(ctrl-shift-s)
(slack | lack) unread [messages]key(ctrl-shift-a)
grab leftkey(shift-up)
grab rightkey(shift-down)
add linekey(shift-enter)
(slack | lack) (react | reaction)key(ctrl-shift-\\)
(insert command | commandify)key(ctrl-shift-c)
insert codeinsert("``````") key(left left left) key(shift-enter) key(shift-enter) key(up)
(slack | lack) (bull | bullet | bulleted) [list]key(ctrl-shift-8)
(slack | lack) (number | numbered) [list]key(ctrl-shift-7)
(slack | lack) (quotes | quotation)key(ctrl-shift-9)
boldkey(ctrl-b)
(italic | italicize)key(ctrl-i)
(strike | strikethrough)key(ctrl-shift-x)
(clear | scrap | scratch)key(ctrl-a backspace)
(slack | lack) snippetkey(ctrl-shift-enter)
([toggle] mute | unmute)key(m)
(slack | lack) ([toggle] video)key(v)
(slack | lack) invitekey(a)
(slack | lack) shortcutskey(ctrl-/)
emote "{text}"
toggle left sidebarkey(ctrl-shift-d)
toggle right sidebarkey(ctrl-.)

talon repl

Command Result
test lastphrase = user.history_get(1) command = "sim('{phrase}')" insert(command) key(enter)
test insert("sim('{phrase}')") key(enter)
test numb phrase = user.history_get(number_small) command = "sim('{phrase}')" #to do: shouldn't this work? #user.paste("sim({phrase})") insert(command) key(enter)
debug action {user.talon_actions}insert("actions.find('{user.talon_actions}')") key(enter)
debug list {user.talon_lists}insert("actions.user.talon_pretty_print(registry.lists['{talon_lists}'])") key(enter)
debug tagsinsert("actions.user.talon_pretty_print(registry.tags)") key(enter)
debug settingsinsert("actions.user.talon_pretty_print(registry.settings)") key(enter)
debug modesinsert("actions.user.talon_pretty_print(scope.get('mode'))") key(enter)
debug scope {user.talon_scopes}insert("actions.user.talon_pretty_print(scope.get('{talon_scopes}'))") key(enter)
debug running appsinsert("actions.user.talon_pretty_print(ui.apps(background=False))") key(enter)
debug all windowsinsert("actions.user.talon_pretty_print(ui.windows())") key(enter)
debug {user.running} windowsinsert("actions.user.talon_debug_app_windows('{running}')") key(enter)

teams

Command Result
show shortcutskey(ctrl-.)
[go] [to] searchkey(ctrl-e)
show commandskey(ctrl-/)
open filterkey(ctrl-shift-f)
go tokey(ctrl-g)
open (apps|applications)key(ctrl-`)
[start] new chatkey(ctrl-n)
open settingskey(ctrl-,)
open helpkey(f1)
closekey(escape)
open activitykey(ctrl-1)
open chatkey(ctrl-2)
open teamskey(ctrl-3)
open calendarkey(ctrl-4)
open plannerkey(ctrl-5)
open callskey(ctrl-6)
open fileskey(ctrl-7)
[go] [to] (prev|previous) [list] itemkey(alt-up)
[go] [to] next [list] itemkey(alt-down)
move [selected] team upkey(ctrl-shift-up)
move [selected] team downkey(ctrl-shift-down)
[go] [to] (prev|previous) sectionkey(ctrl-shift-f6)
[go] [to] next sectionkey(ctrl-f6)
[go] [to] compose [box]key(c)
[expand] compose [box]key(ctrl-shift-x)
sendkey(ctrl-enter)
attach filekey(ctrl-o)
[start] new linekey(shift-enter)
reply [to] [thread]key(r)
accept video callkey(ctrl-shift-a)
accept audio callkey(ctrl-shift-s)
decline callkey(ctrl-shift-d)
start audio callkey(ctrl-shift-c)
start video callkey(ctrl-shift-u)
toggle mutekey(ctrl-shift-m)
starch screen share sessionkey(ctrl-shift-e)
toggle videokey(ctrl-shift-o)
[go] [to] sharing toolbarkey(ctrl-shift-space)
decline screen sharekey(ctrl-shift-d)
accept screen sharekey(ctrl-shift-a)
schedule [a] meetingkey(alt-shift-n)
go to current timekey(alt-.)
go to (prev|previous) (day|week)key(ctrl-alt-left)
go to next (day|week)key(ctrl-alt-right)
view daykey(ctrl-alt-1)
view work weekkey(ctrl-alt-2)
view weekkey(ctrl-alt-3)
(safe|send) meeting requestkey(ctrl-s)
join [from] meeting [details]key(alt-shift-j)
go to suggested timekey(alt-shift-s)

visual studio

Command Result
panel solutionkey(ctrl-alt-l)
panel propertieskey(f4)
panel outputkey(ctrl-alt-o)
panel classkey(ctrl-shift-c)
panel errorskey(ctrl-\ ctrl-e)
panel designkey(shift-f7)
panel markskey(ctrl-k ctrl-w)
panel breakpointskey(ctrl-alt-b)
show settingskey(alt-t o)
fullscreen switchkey(shift-alt-enter)
wrap switchkey(ctrl-e ctrl-w)
file hunt []key(ctrl-shift-t) insert(text or "")
file createkey(ctrl-n)
file renamekey(ctrl-[ s f2)
file revealkey(ctrl-[ s)
hint showkey(ctrl-shift-space)
definition showkey(f12)
definition peekkey(alt-f12)
references findkey(shift-f12)
format thatkey(ctrl-k ctrl-d)
format selectionkey(ctrl-k ctrl-f)
imports fixkey(ctrl-r ctrl-g)
refactor fieldkey(ctrl-r ctrl-e)
refactor interfacekey(ctrl-r ctrl-i)
refactor methodkey(ctrl-r ctrl-m)
refactor reorder parameterskey(ctrl-r ctrl-o)
refactor remove parameterskey(ctrl-r ctrl-v)
refactor thatkey(ctrl-r ctrl-r)
(go declaration | follow)key(ctrl-f12)
go backkey(ctrl--)
go forwardkey(ctrl-shift--)
go implementationkey(f12)
go recent []key(ctrl-1 ctrl-r) sleep(100ms) insert(text or "")
go type []key(ctrl-1 ctrl-t) sleep(100ms) insert(text or "")
go member []key(alt-\) sleep(100ms) insert(text or "")
go usagekey(shift-f12)
go markskey(ctrl-k ctrl-w)
toggle markkey(ctrl-k ctrl-k)
go next markkey(ctrl-k ctrl-n)
go last markkey(ctrl-k ctrl-p)
fold togglekey(ctrl-m ctrl-m)
fold toggle allkey(ctrl-m ctrl-l)
fold definitionskey(ctrl-m ctrl-o)
break pointkey(f9)
step overkey(f10)
debug step intokey(f11)
debug step out [of]key(f10)
debug startkey(f5)
debug stopperkey(shift-f5)
debug continuekey(f5)

vscode

Command Result
window reloaduser.vscode("workbench.action.reloadWindow")
window closeuser.vscode("workbench.action.closeWindow")
please []user.vscode("workbench.action.showCommands") insert(user.text or "") # Sidebar
bar exploreuser.vscode("workbench.view.explorer")
bar extensionsuser.vscode("workbench.view.extensions")
bar outlineuser.vscode("outline.focus")
bar runuser.vscode("workbench.view.debug")
bar searchuser.vscode("workbench.view.search")
bar sourceuser.vscode("workbench.view.scm")
bar switchuser.vscode("workbench.action.toggleSidebarVisibility")
symbol hunt []user.vscode("workbench.action.gotoSymbol") sleep(50ms) insert(text or "") # Panels
panel controluser.vscode("workbench.panel.repl.view.focus")
panel outputuser.vscode("workbench.panel.output.focus")
panel problemsuser.vscode("workbench.panel.markers.view.focus")
panel switchuser.vscode("workbench.action.togglePanel")
panel terminaluser.vscode("workbench.action.terminal.focus")
focus editoruser.vscode("workbench.action.focusActiveEditorGroup")
show settingsuser.vscode("workbench.action.openGlobalSettings")
show shortcutsuser.vscode("workbench.action.openGlobalKeybindings")
show snippetsuser.vscode("workbench.action.openSnippets")
centered switchuser.vscode("workbench.action.toggleCenteredLayout")
fullscreen switchuser.vscode("workbench.action.toggleFullScreen")
theme switchuser.vscode("workbench.action.selectTheme")
wrap switchuser.vscode("editor.action.toggleWordWrap")
zen switchuser.vscode("workbench.action.toggleZenMode")
file hunt []user.vscode("workbench.action.quickOpen") sleep(50ms) insert(text or "")
file copy pathuser.vscode("copyFilePath")
file create siblinguser.vscode_and_wait("explorer.newFile")
file createuser.vscode("workbench.action.files.newUntitledFile")
file renameuser.vscode("fileutils.renameFile") sleep(150ms)
file moveuser.vscode("fileutils.moveFile") sleep(150ms)
file open folderuser.vscode("revealFileInOS")
file revealuser.vscode("workbench.files.action.showActiveFileInExplorer")
save uglyuser.vscode("workbench.action.files.saveWithoutFormatting")
suggest showuser.vscode("editor.action.triggerSuggest")
hint showuser.vscode("editor.action.triggerParameterHints")
definition showuser.vscode("editor.action.revealDefinition")
definition peekuser.vscode("editor.action.peekDefinition")
definition sideuser.vscode("editor.action.revealDefinitionAside")
references showuser.vscode("editor.action.goToReferences")
references finduser.vscode("references-view.find")
format thatuser.vscode("editor.action.formatDocument")
format selectionuser.vscode("editor.action.formatSelection")
imports fixuser.vscode("editor.action.organizeImports")
problem nextuser.vscode("editor.action.marker.nextInFiles")
problem lastuser.vscode("editor.action.marker.prevInFiles")
problem fixuser.vscode("problems.action.showQuickFixes")
rename thatuser.vscode("editor.action.rename")
refactor thatuser.vscode("editor.action.refactor")
whitespace trimuser.vscode("editor.action.trimTrailingWhitespace")
language switchuser.vscode("workbench.action.editor.changeLanguageMode")
refactor renameuser.vscode("editor.action.rename")
refactor thisuser.vscode("editor.action.refactor")
(go declaration | follow)user.vscode("editor.action.revealDefinition")
go backuser.vscode("workbench.action.navigateBack")
go forwarduser.vscode("workbench.action.navigateForward")
go implementationuser.vscode("editor.action.goToImplementation")
go typeuser.vscode("editor.action.goToTypeDefinition")
go usageuser.vscode("references-view.find")
go recent []user.vscode("workbench.action.openRecent") sleep(50ms) insert(text or "") sleep(250ms) # Bookmarks. Requires Bookmarks plugin
go marksuser.vscode("workbench.view.extension.bookmarks")
toggle markuser.vscode("bookmarks.toggle")
go next markuser.vscode("bookmarks.jumpToNext")
go last markuser.vscode("bookmarks.jumpToPrevious")
fold thatuser.vscode("editor.fold")
unfold thatuser.vscode("editor.unfold")
fold thoseuser.vscode("editor.foldAllMarkerRegions")
unfold thoseuser.vscode("editor.unfoldRecursively")
fold alluser.vscode("editor.foldAll")
unfold alluser.vscode("editor.unfoldAll")
fold commentsuser.vscode("editor.foldAllBlockComments")
git branchuser.vscode("git.branchFrom")
git branch thisuser.vscode("git.branch")
git checkout []user.vscode("git.checkout") sleep(50ms) insert(text or "")
git commit []user.vscode("git.commitStaged") sleep(100ms) user.insert_formatted(text or "", "CAPITALIZE_FIRST_WORD")
git commit undouser.vscode("git.undoCommit")
git commit ammenduser.vscode("git.commitStagedAmend")
git diffuser.vscode("git.openChange")
git ignoreuser.vscode("git.ignore")
git mergeuser.vscode("git.merge")
git outputuser.vscode("git.showOutput")
git pulluser.vscode("git.pullRebase")
git pushuser.vscode("git.push")
git push focususer.vscode("git.pushForce")
git rebase abortuser.vscode("git.rebaseAbort")
git revealuser.vscode("git.revealInExplorer")
git revertuser.vscode("git.revertChange")
git stashuser.vscode("git.stash")
git stash popuser.vscode("git.stashPop")
git statususer.vscode("workbench.scm.focus")
git stageuser.vscode("git.stage")
git stage alluser.vscode("git.stageAll")
git unstageuser.vscode("git.unstage")
git unstage alluser.vscode("git.unstageAll")
pull requestuser.vscode("pr.create")
change nextkey(alt-f5)
change lastkey(shift-alt-f5)
break pointuser.vscode("editor.debug.action.toggleBreakpoint")
step overuser.vscode("workbench.action.debug.stepOver")
debug step intouser.vscode("workbench.action.debug.stepInto")
debug step out [of]user.vscode("workbench.action.debug.stepOut")
debug startuser.vscode("workbench.action.debug.start")
debug pauseuser.vscode("workbench.action.debug.pause")
debug stopperuser.vscode("workbench.action.debug.stop")
debug continueuser.vscode("workbench.action.debug.continue")
debug restartuser.vscode("workbench.action.debug.restart")
debug consoleuser.vscode("workbench.debug.action.toggleRepl")
terminal externaluser.vscode("workbench.action.terminal.openNativeConsole")
terminal newuser.vscode("workbench.action.terminal.new")
terminal nextuser.vscode("workbench.action.terminal.focusNext")
terminal lastuser.vscode("workbench.action.terminal.focusPrevious")
terminal splituser.vscode("workbench.action.terminal.split")
terminal zoomuser.vscode("workbench.action.toggleMaximizedPanel")
terminal trashuser.vscode("workbench.action.terminal.kill")
terminal toggleuser.vscode_and_wait("workbench.action.terminal.toggleTerminal")
terminal scroll upuser.vscode("workbench.action.terminal.scrollUp")
terminal scroll downuser.vscode("workbench.action.terminal.scrollDown")
terminal user.vscode_terminal(number_small)
copy line downuser.vscode("editor.action.copyLinesDownAction")
copy line upuser.vscode("editor.action.copyLinesUpAction")
select lessuser.vscode("editor.action.smartSelect.shrink")
select (more|this)user.vscode("editor.action.smartSelect.expand")
minimapuser.vscode("editor.action.toggleMinimap")
maximizeuser.vscode("workbench.action.minimizeOtherEditors")
restoreuser.vscode("workbench.action.evenEditorWidths")
replace hereuser.replace("") key(cmd-alt-l)
hover showuser.vscode("editor.action.showHover")
join linesuser.vscode("editor.action.joinLines")
full screenuser.vscode("workbench.action.toggleFullScreen")
curse undouser.vscode("cursorUndo")
select worduser.vscode("editor.action.addSelectionToNextFindMatch")
skip worduser.vscode("editor.action.moveSelectionToNextFindMatch")
cell nextuser.vscode("jupyter.gotoNextCellInFile")
cell lastuser.vscode("jupyter.gotoPrevCellInFile")
cell run aboveuser.vscode("jupyter.runallcellsabove.palette")
cell runuser.vscode("jupyter.runcurrentcell")
install localuser.vscode("workbench.extensions.action.installVSIX")

github

Command Result
focus searchkey(s)
go to notificationsinsert("gn")
go to dashboardinsert("gd")
show keyboard shortcutskey(?)
move selection downkey(j)
move selection upkey(k)
toggle selectionkey(x)
open selectionkey(o)
go to codeinsert("gc")
go to issuesinsert("gi")
go to pull requestsinsert("gp")
go to wikiinsert("gw")
find filekey(t)
jump to linekey(l)
switch (branch|tag)key(w)
expand urlkey(y)
(show|hide) [all] in line noteskey(i)
create [an] issuekey(c)
search (issues|[pull] requests)key(/)
(filter by|edit) labelskey(l)
(filter by|edit) milestoneskey(m)
(filter by|edit) assigneekey(a)
replykey(r)
submit commentkey(ctrl-enter)
preview commentkey(ctrl-shift-p)
git hub full screenkey(ctrl-shift-l)
close formkey(escape)
parent commitkey(p)
other parent commitkey(o)
mark as readkey(y)
mute threadkey(shift-m)
open issuekey(o)

gitlab

Command Result
show shortcutskey(?)
go to projects [page]key(shift-p)
go to groups [page]key(shift-g)
go to activity [page]key(shift-a)
go to milestones [page]key(shift-l)
go to snippets [page]key(shift-s)
search pagekey(s)
go to issues [page]key(shift-i)
go to merge requests [page]key(shift-m)
go to to do [list] [page]key(shift-t)
(show|hide) performance barkey(p)
edit last commentkey(1)
toggle mark down [preview]key(ctrl-shift-p)
go [to] project home [page]insert("gp")
go [to] project activity [feed]insert("gv")
go [to] project releases [list]insert("gr")
go [to] project files [list]insert("gf")
go [to] project file search [page]key(t)
go [to] project (commit|commits) [list]insert("gc")
go [to] (repository|repo) graph [page]insert("gn")
go [to] (repository|repo) chartsinsert("gd")
go [to] project issues [list]insert("gi")
go [to] new issues [list]insert("i")
go [to] project issues boards [list]insert("gb")
go [to] project merge requests [list]insert("gm")
go [to] jobs [list]insert("gj")
go [to] project metricsinsert("gl")
go [to] project environmentsinsert("ge")
go [to] project cubesinsert("gk")
go [to] project snippets [list]insert("gs")
go [to] project wikiinsert("gw")
edit descriptionkey(e)
change assigneekey(a)
change milestonekey(m)
change labelkey(l)
right commentkey(r)
next [unresolved] discussionkey(n)
previous [unresolved] discussionkey(p)
next filekey(])
previous filekey([)
back to fileskey(escape)
open permalinkkey(y)
edit pagekey(e)

outlook

Command Result
new messagekey(n)
send [this] messagekey(alt-s)
reply [to] [this] messagekey(r)
reply all [to] [this] messagekey(ctrl-shift-r)
forward [this] messagekey(ctrl-shift-f)
save [draft]key(ctrl-s)
discard [draft]key(esc)
insert [a] [hyper] linkkey(ctrl-k)
(select|unselect) [this] messagekey(ctrl-space)
select all [messages]key(ctrl-a)
clear all [messages]key(esc)
select first [message]key(home)
select last [message]key(and)
open [this] messagekey(o)
open [this] message [in] [a] new windowkey(shift-enter)
close [this] messagekey(esc)
[open] [the] next (item|message)key(ctrl-.)
[open] [the] (prev|previous) itemkey(ctrl-,)
next reading [pane] (item|message)key(.)
(prev|previous) [pane] (item|message)key(,)
(expand|collapse) [conversation]key(x)
go [to] mailkey(ctrl-shift-1)
go [to] calendarkey(ctrl-shift-2)
go [to] peoplekey(ctrl-shift-3)
go [to] to dokey(ctrl-shift-4)
go [to] inboxkey(g) key(i)
go to draftskey(g) key(d)
go to sentkey(g) key(s)
search [email]key(alt-q)
show helpkey(?)
undo [last] [action]key(ctrl-z)
delete [this] [message]key(delete)
(perm|permanently) delete [this] [message]key(shift+delete)
new folderkey(shift-e)
mark [this] [(item|message)] as readkey(q)
mark [this] [(item|message)] as unreadkey(u)
flag [this] [(item|message)]key(insert)
archivekey(e)
mark [this] [message] [as] junkkey(j)
moved to [a] folderkey(v)
categorize [this] messagekey(c)

protonmail

Command Result
open helpkey(?)
[focus] searchkey(/)
confirm activekey(enter)
close activekey(escape)
open command [palette]key(shift-space)
new messagekey(c)
send messagekey(ctrl-enter)
save messagekey(ctrl-s)
(go|jump) [to] inboxkey(g) key(i)
(go|jump) [to] draftkey(g) key(d)
(go|jump) [to] sentkey(g) key(s)
(go|jump) [to] starredkey(g) key(.)
(go|jump) [to] archivekey(g) key(a)
(go|jump) [to] spamkey(g) key(x)
(go|jump) [to] trashkey(g) key(t) ## Navigation
(prev|previous) messagekey(up)
next messagekey(down)
exit messagekey(left)
enter messagekey(right)
(show|display) newer [message]key(k)
(show|display) older [message]key(j)
open messagekey(enter)
go backkey(escape)
select allkey(*) key(a)
(deselect|unselect) allkey(*) key(n)
select [the] (message|conversation)key(x)
mark [as] readkey(r)
mark [as] unreadkey(u)
star (message|conversation)key(.)
move to inboxkey(i)
move to trashkey(t)
move to archivekey(a)
move to spamkey(s)
reply to (message|conversation)key(shift-r)
reply all [to] (message|conversation)key(shift-a)
forward (message|conversation)key(shift-f)
(prev|previous) contactkey(up)
next contactkey(down)
enter contactkey(right)
delete contactkey(t)
exit contactkey(left)
save contactkey(ctrl-s)

twitter

Command Result
(show shortcuts|shortcuts help)key(?)
next tweetkey(j)
previous tweetkey(k)
page downkey(space)
load new tweetkey(.)
go homeinsert("gh")
go exploreinsert("ge")
go notificationsinsert("gn")
go mentionsinsert("gr")
go profileinsert("gp")
go likesinsert("gl")
go listsinsert("gi")
go direct messagesinsert("gm")
go settingsinsert("gs")
go book marksinsert("gb")
go to userinsert("gu")
display settingsinsert("gd")
new tweetkey(n)
send tweetkey(ctrl-enter)
new direct messagekey(m)
searchkey(/)
like messagekey(l)
reply messagekey(r)
re tweet [message]key(t)
share tweetkey(s)
bookmarkkey(b)
mute accountkey(urge)
block accountkey(x)
open detailskey(enter)
expand photokey(o)

win windbg

Command Result
register key(@) insert("{registers}")
open helpinsert(".hh\n")
add microsoft symbolsinsert("srv*C:\\symbols*http://msdl.microsoft.com/download/symbols;\n")
force reload symbolsinsert(".reload /f\n")
reload symbolsinsert(".reload\n")
loaded modulesinsert("lm l\n")
display pointersinsert("dps ") # XXX - should be generic
dereference pointerinsert("poi()") edit.left()
show versionkey(ctrl-alt-w)
view commandkey(alt-1)
view watchkey(alt-2)
view localskey(alt-3)
view registerskey(alt-4)
view memorykey(alt-5)
view call stackkey(alt-6)
view disassemblykey(alt-7)
view scratch padkey(alt-8)
view (processes|threads)key(alt-9)
dump function params"r @rcx,@rdx,@r8,@r9\n"
(lib|library) "{windows_dlls}"

draft editor

Command Result
draft thisuser.draft_editor_open()
draft alledit.select_all() user.draft_editor_open()
draft lineedit.select_line() user.draft_editor_open()

draft editor open

Command Result
draft submituser.draft_editor_submit()
draft discarduser.draft_editor_discard()

batch

Command Result
soft exit"exit /B 1\n"
hard exit"exit 1\n"
echo"echo "
echo off"@echo off\n"
call"call "
call shell"call cmd \\c "
if error"if errorlevel 1 "
go to"goto "
delayed expansion"SETLOCAL EnableDelayedExpansion\n"
arg "%{number_small}"

block comment

Command Result
block commentuser.code_block_comment()
block comment line#todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_start() user.code_block_comment_prefix() key(space) edit.line_end() key(space) user.code_block_comment_suffix() #adds comment to the start of the line
block comment line over#todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_start() user.code_block_comment() insert(user.text)
block comment over#todo: this should probably be a single function once #.talon supports implementing actions with parameters? user.code_block_comment() insert(user.text)
block comment #todo: this should probably be a single function once #.talon supports implementing actions with parameters? user.code_block_comment() insert(user.text)
(line | inline) block comment over#todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_end() user.code_block_comment_prefix() key(space) insert(user.text) key(space) user.code_block_comment_suffix()
(line | inline) block comment #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_end() user.code_block_comment_prefix() key(space) insert(user.text) key(space) user.code_block_comment_suffix()
open block commentuser.code_block_comment_prefix()
close block commentuser.code_block_comment_suffix()

c

Command Result
funky user.code_default_function(text)
static funky user.code_private_static_function(text)
state define"#define "
state undefine"#undef "
state if define"#ifdef "
state pre if"#if "
state error"#error "
state pre else if"#elif "
state pre end"#endif "
state pragma"#pragma "
state default"default:\nbreak;"
push bracketsedit.line_end() #insert("{") #key(enter) insert("{}") edit.left() key(enter) key(enter) edit.up() # Declare variables or structs etc. # Ex. * int myList
insert("{c_variable} ") insert(user.formatted_text(phrase, "PRIVATE_CAMEL_CASE,NO_SPACES"))
insert("{c_variable} {letter} ") # Ex. (int *)
cast to "{c_cast}"
standard cast to "{stdint_cast}"
"{c_types}"
"{c_pointers}"
"{c_signed}"
standard "{stdint_types}"
int maininsert("int main()") edit.left()
toggle includesuser.code_toggle_libraries()
include user.code_insert_library(code_libraries, "") key(end enter)

comment

Command Result
commentuser.code_comment()
comment line#todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_start() user.code_comment() #adds comment to the start of the line
comment line over#todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_start() user.code_comment() insert(user.text) insert(" ")
comment over#todo: this should probably be a single function once #.talon supports implementing actions with parameters? user.code_comment() insert(user.text)
comment #todo: this should probably be a single function once #.talon supports implementing actions with parameters? user.code_comment() insert(user.text)
(line | inline) comment over#todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_end() user.code_comment() insert(user.text)
(line | inline) comment #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_end() user.code_comment() insert(user.text)

csharp

Command Result
funky user.code_default_function(text)
pro funky user.code_protected_function(text)
pub funky user.code_public_function(text)
static funky user.code_private_static_function(text)
pro static funky user.code_protected_static_function(text)
pub static funky user.code_public_static_function(text)

go

Command Result
variadic"..."
logical and" && "
logical or" || "
state comment"// "
[line] comment key("cmd-right") insert(" // ") insert(user.formatted_text(text, "sentence")) # "add comment [over]: # key("cmd-right") # text_with_leading(" // ") # ] # "[state] context: insert("ctx")
state (funk | func | fun)"func "
function (Annette | init) [over]"func init() {\n"
function [over]insert("func ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) insert("(") sleep(100ms)
method [over]insert("meth ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) sleep(100ms)
state var"var "
variable [] [over]insert("var ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) # insert(" ") sleep(100ms)
of type [] [over]insert(" ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) # "set [over]: # insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) # insert(" := ") # sleep(100ms) # ]
state break"break"
state (chan | channel)" chan "
state go"go "
state if"if "
if [over]insert("if ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
spawn [over]insert("go ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state else if" else if "
else if [over]insert(" else if ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state else" else "
else [over]insert(" else {") key("enter") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state while"while "
while [over]insert("while ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state for"for "
for [over]insert("for ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state for range"forr "
range [over]insert("forr ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state format"fmt"
format [over]insert("fmt.") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
state switch"switch "
switch [over]insert("switch ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state select"select "
state (const | constant)" const "
constant [over]insert("const ") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
state case" case "
state default" default:"
case [over]insert("case ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state type" type "
type [over]insert("type ") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
state true" true "
state false" false "
state (start | struct | struck)insert(" struct {") key("enter")
(struct | struck) [over]insert(" struct {") key("enter") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
[state] empty interface" interface{} "
state interfaceinsert(" interface {") key("enter")
interface [over]insert(" interface {") key("enter") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
state string" string "
[state] (int | integer | ant)"int"
state slice" []"
slice of"[]"
[state] (no | nil)"nil"
state (int | integer | ant) 64" int64 "
state taginsert(" ``") key("left")
field tag [over]insert(" ``") key("left") sleep(100ms) insert(user.formatted_text(text, "snake")) insert(" ") sleep(100ms)
state return" return "
return [over]insert("return ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
map of string to string" map[string]string "
map of [over]insert("map[") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) key("right") sleep(100ms)
receive" <- "
make"make("
loggers [] [over]insert("logrus.") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
length [over]insert("len(") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
append [over]insert("append(") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state (air | err)"err"
error" err "
loop over [] [over]insert("forr ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
item [over]insert(", ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
value [over]insert(": ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
address of [] [over]insert("&") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
pointer to [] [over]insert("*") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
swipe [] [over]key("right") insert(", ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))

javascript

Command Result
(op | is) strict equal" === "
(op | is) strict not equal" !== "
state const"const "
state let"let "
state var"var "
state async"async "
state await"await "
state mapinsert(".map()") key(left)
state filterinsert(".filter()") key(left)
state reduceinsert(".reduce()") key(left)
state spread"..."
funky user.code_default_function(text)
pro funky user.code_protected_function(text)
pub funky user.code_public_function(text)

operators

Command Result
op dereferenceuser.code_operator_indirection()
op address ofuser.code_operator_address_of()
op arrowuser.code_operator_structure_dereference()
op lambdauser.code_operator_lambda()
op subscriptuser.code_operator_subscript()
op (equals | assign)user.code_operator_assignment()
op (minus | subtract)user.code_operator_subtraction()
op (minus | subtract) equalsuser.code_operator_subtraction_assignment()
op (plus | add)user.code_operator_addition()
op (plus | add) equalsuser.code_operator_addition_assignment()
op (times | multiply)user.code_operator_multiplication()
op (times | multiply) equalsuser.code_operator_multiplication_assignment()
op divideuser.code_operator_division()
op divide equalsuser.code_operator_division_assignment()
op moduser.code_operator_modulo()
op mod equalsuser.code_operator_modulo_assignment()
(op (power | exponent) | to the power [of])user.code_operator_exponent()
(op | is) equaluser.code_operator_equal()
(op | is) not equaluser.code_operator_not_equal()
(op | is) (greater | more)user.code_operator_greater_than()
(op | is) (less | below) [than]user.code_operator_less_than()
(op | is) greater [than] or equaluser.code_operator_greater_than_or_equal_to()
(op | is) less [than] or equaluser.code_operator_less_than_or_equal_to()
(op | is) inuser.code_operator_in()
(op | logical) anduser.code_operator_and()
(op | logical) oruser.code_operator_or()
[op] bitwise anduser.code_operator_bitwise_and()
[op] bitwise oruser.code_operator_bitwise_or()
(op | logical | bitwise) (ex | exclusive) oruser.code_operator_bitwise_exclusive_or()
(op | logical | bitwise) (left shift | shift left)user.code_operator_bitwise_left_shift()
(op | logical | bitwise) (right shift | shift right)user.code_operator_bitwise_right_shift()
(op | logical | bitwise) (ex | exclusive) or equalsuser.code_operator_bitwise_exclusive_or_equals()
[(op | logical | bitwise)] (left shift | shift left) equalsuser.code_operator_bitwise_left_shift_equals()
[(op | logical | bitwise)] (left right | shift right) equalsuser.code_operator_bitwise_right_shift_equals()
(op | pad) colon" : "

programming

Command Result
blockuser.code_block()
is not (none|null)user.code_is_not_null()
is (none|null)user.code_is_null()
state ifuser.code_state_if()
state else ifuser.code_state_else_if()
state elseuser.code_state_else()
state selfuser.code_self()
self dotuser.code_self() insert(".")
state whileuser.code_state_while()
state foruser.code_state_for()
state for inuser.code_state_for_each()
state switchuser.code_state_switch()
state caseuser.code_state_case()
state douser.code_state_do()
state gotouser.code_state_go_to()
state returnuser.code_state_return()
state importuser.code_import()
from importuser.code_from_import()
state classuser.code_type_class()
state includeuser.code_include()
state include systemuser.code_include_system()
state include localuser.code_include_local()
state type deafuser.code_type_definition()
state type deaf structuser.code_typedef_struct()
state (no | nil | null)user.code_null()
state breakuser.code_break()
state nextuser.code_next()
state trueuser.code_true()
state falseuser.code_false()
toggle funkuser.code_toggle_functions()
funk user.code_insert_function(code_functions, "")
funk cell user.code_select_function(number - 1, "")
funk wrap user.code_insert_function(code_functions, edit.selected_text())
funk wrap user.code_select_function(number - 1, edit.selected_text())
dock stringuser.code_document_string()

python

Command Result
dunder in it"__init__"
state (def | deaf | deft)"def "
state try"try:\n"
state except"except "
state raise"raise "
self taught"self."
pie test"pytest"
state past"pass"
funky user.code_default_function(text)
pub funky user.code_public_function(text)
raise {user.python_exception}user.insert_cursor("raise {python_exception}([|])")
except {user.python_exception}"except {python_exception}:"
is type {user.python_type_list}insert(": {python_type_list}")
returns [type] {user.python_type_list}insert(" -> {python_type_list}") # for generic reference of types
type {user.python_type_list}insert("{python_type_list}")
dock {user.python_docstring_fields}insert("{python_docstring_fields}") edit.left()
dock type {user.python_type_list}user.insert_cursor(":type [|]: {python_type_list}")
dock returns type {user.python_type_list}user.insert_cursor(":rtype [|]: {python_type_list}")
toggle importsuser.code_toggle_libraries()
import user.code_insert_library(code_libraries, "") key(end enter)

r

Command Result
toggle libraryuser.code_toggle_libraries()
library user.code_insert_library(code_libraries, "") key(end enter) # R specific commands
(chain|pipe that)key(end) " %>%" key(enter)
state nainsert("NA")
function define user.code_private_function(text)

ruby

Command Result
funky user.code_default_function(text)
args pipeinsert("||") key(left)
state do"do "
state end"end"
state begin"begin"
state rescue"rescue "
state module"module "
instance insert("@") user.code_public_variable_formatter(text)

snippets

Command Result
snip {user.snippets}user.snippet_insert(user.snippets)
snip hunt user.snippet_search(user.text)
snip huntuser.snippet_search("")
snip createuser.snippet_create()
snip showuser.snippet_toggle()

sql

Command Result
select"SELECT "
star"*"
from"FROM "
select star from"SELECT * FROM "
where"WHERE "
order by"ORDER BY "
descending" DESC"
ascending" ASC"
dot i d".id"
is not null" IS NOT NULL"
is null" IS NULL"
inner joininsert("INNER JOIN ON ") key(left) key(left) key(left) key(left)

talon

Command Result
dot taloninsert(".talon")
action blockinsert("action():") edit.left() edit.left()
setting blockinsert("settings():\n\t")
setting {user.talon_settings}user.paste("{talon_settings} = ") #context requirements
win requireinsert("os: windows\n")
mac requireinsert("os: mac\n")
linux requireinsert("os: linux\n")
title requireinsert("win.title: ")
application [require] [{user.talon_apps}]app = talon_apps or "" user.paste("app: {app}")
mode require [{user.talon_modes}]mode = talon_modes or "" user.paste("mode: {mode}")
tag require [{user.talon_tags}]tag = talon_tags or "" user.paste("tag: {tag}")
tag set [{user.talon_tags}]tag = talon_tags or "" user.paste("tag(): {tag}")
list {user.talon_lists}"{{{talon_lists}}}"
capture {user.talon_captures}"<{talon_captures}>"
key over"{keys}"
key over"{modifiers}"
funk {user.talon_actions}user.code_insert_function(talon_actions, edit.selected_text())
funk cell user.code_select_function(number - 1, "")
funk wrap user.code_insert_function(code_functions, edit.selected_text())
funk wrap user.code_select_function(number - 1, edit.selected_text())

typescript

Command Result
(op | is) strict equal" === "
(op | is) strict not equal" !== "
state const"const "
state let"let "
state var"var "
state async"async "
state await"await "
state mapinsert(".map()") key(left)
state filterinsert(".filter()") key(left)
state reduceinsert(".reduce()") key(left)
state spread"..."
funky user.code_default_function(text)
pro funky user.code_protected_function(text)
pub funky user.code_public_function(text)

vimscript

Command Result
assign [] (variable|var) [] [over]insert("let ") insert(vimscript_scope or '') user.code_private_variable_formatter(text)
[] (variable|var) [] [over]insert(vimscript_scope or '') user.code_private_variable_formatter(text) # see lang/vimscript/vimscript.py for list
insert("{vimscript_functions} ") # XXX - possibly overlap with some programming.talon
state command"command! "
state end if"endif"
state end for"endfor"
state end while"endwhile"
state end function"endfunction"
state continue"continue"

abbreviate

Command Result
(abbreviate|abreviate|brief) {user.abbreviation}"{abbreviation}"

cancel

Command Result
cancel cancelskip()
ignore []app.notify("Command ignored")

datetimeinsert

Command Result
date insertinsert(user.time_format("%Y-%m-%d"))
date insert UTCinsert(user.time_format_utc("%Y-%m-%d"))
timestamp insertinsert(user.time_format("%Y-%m-%d %H:%M:%S"))
timestamp insert high resolutioninsert(user.time_format("%Y-%m-%d %H:%M:%S.%f"))
timestamp insert UTCinsert(user.time_format_utc("%Y-%m-%d %H:%M:%S"))
timestamp insert UTC high resolutioninsert(user.time_format_utc("%Y-%m-%d %H:%M:%S.%f"))

extensions

Command Result
{user.file_extension}"{file_extension}"

formatters

Command Result
phrase user.insert_formatted(text, "NOOP")
phrase overuser.insert_formatted(text, "NOOP")
{user.prose_formatter} user.insert_formatted(prose, prose_formatter)
{user.prose_formatter} overuser.insert_formatted(prose, prose_formatter)
+user.insert_many(format_text_list)
+ overuser.insert_many(format_text_list)
thatuser.formatters_reformat_selection(user.formatters)
word user.insert_formatted(user.word, "NOOP")
format help | help formatuser.formatters_help_toggle()
recent listuser.toggle_phrase_history()
recent repeat insert(user.get_recent_phrase(number_small))
recent copy clip.set_text(user.get_recent_phrase(number_small))
select thatuser.select_last_phrase()
before thatuser.before_last_phrase()
nope that | scratch thatuser.clear_last_phrase()
nope that was user.formatters_reformat_last(formatters)

git

Command Result
git add patch"git add . -p\n"
git add"git add "
git add everything"git add -u\n"
git bisect"git bisect "
git blame"git blame "
git branch"git branch "
git remote branches"git branch --remote\n"
git branch "git branch {text}"
git checkout"git checkout "
git checkout master"git checkout master\n"
git checkout main"git checkout main\n"
git checkout "git checkout {text}"
git cherry pick"git cherry-pick "
git cherry pick continue"git cherry-pick --continue "
git cherry pick abort"git cherry-pick --abort "
git cherry pick skip"git cherry-pick --skip "
git clone"git clone "
git clean everything"git clean -dfx"
git commit message "git commit -m '{text}'"
git commit"git commit\n"
git diff (colour|color) words"git diff --color-words "
git diff"git diff "
git diff cached"git diff --cached\n"
git fetch"git fetch\n"
git fetch all"git fetch --all\n"
git fetch "git fetch {text}"
git fetch prune"git fetch --prune\n"
git in it"git init\n"
git log all"git log\n"
git log all changes"git log -c\n"
git log"git log "
git log changes"git log -c "
git merge"git merge "
git merge "git merge {text}"
git move"git mv "
git new branch"git checkout -b "
git pull"git pull\n"
git pull origin"git pull origin "
git pull rebase"git pull --rebase\n"
git pull fast forward"git pull --ff-only\n"
git pull "git pull {text} "
git push"git push\n"
git push origin"git push origin "
git push up stream origin"git push -u origin"
git push "git push {text} "
git push tags"git push --tags\n"
git rebase"git rebase\n"
git rebase continue"git rebase --continue"
git rebase skip"git rebase --skip"
git remove"git rm "
git (remove|delete) branch"git branch -d "
git (remove|delete) remote branch"git push --delete origin "
git reset"git reset "
git reset soft"git reset --soft "
git reset hard"git reset --hard "
git restore"git restore "
git restore staged"git restore --staged "
git remote show origin"git remote show origin\n"
git remote add upstream"git remote add upstream "
git show"git show "
git stash pop"git stash pop\n"
git stash"git stash\n"
git stash apply"git stash apply\n"
git stash list"git stash list\n"
git stash show"git stash show"
git status"git status\n"
git submodule add"git submodule add "
git tag"git tag "
git edit config"git config --local -e\n"
git clone clipboardinsert("git clone ") edit.paste() key(enter)
git diff highlightededit.copy() insert("git diff ") edit.paste() key(enter)
git diff clipboardinsert("git diff ") edit.paste() key(enter)
git add highlightededit.copy() insert("git add ") edit.paste() key(enter)
git add clipboardinsert("git add ") edit.paste() key(enter)
git commit highlightededit.copy() insert("git add ") edit.paste() insert("\ngit commit\n")

git add patch

Command Result
yankkey(y) key(enter)
nearkey(n) key(enter)
quenchkey(q) key(enter)
drumkey(d) key(enter)
airkey(a) key(enter)

help

Command Result
help alphabetuser.help_alphabet(user.get_alphabet())
help contextuser.help_context()
help activeuser.help_context_enabled()
help search user.help_search(text)
help context {user.help_contexts}user.help_selected_context(help_contexts)
help helpuser.help_search("help")

help open

Command Result
help nextuser.help_next()
help previoususer.help_previous()
help user.help_select_index(number - 1)
help returnuser.help_return()
help closeuser.help_hide()

history

Command Result
command historyuser.history_toggle()
command history clearuser.history_clear()
command history lessuser.history_less()
command history moreuser.history_more()

keys

Command Result
go key(arrow_keys)
key(letter)
(ship | uppercase) [(lowercase | sunk)]user.insert_formatted(letters, "ALL_CAPS")
key(symbol_key)
key(function_key)
key(special_key)
key("{modifiers}-{unmodified_key}")

mac macro

Command Result
macro recorduser.macro_record()
macro stopuser.macro_stop()
macro playuser.macro_play()

media

Command Result
volume upkey(volup)
volume downkey(voldown)
set volume user.media_set_volume(number)
(volume|media) mutekey(mute)
[media] play nextkey(next)
[media] play previouskey(prev)
media (play | pause)user.play_pause()

messaging

Command Result
previous (workspace | server)user.messaging_workspace_previous()
next (workspace | server)user.messaging_workspace_next()
channeluser.messaging_open_channel_picker()
channel user.messaging_open_channel_picker() insert(user.formatted_text(user.text, "ALL_LOWERCASE"))
channel upuser.messaging_channel_previous()
channel downuser.messaging_channel_next()
([channel] unread last | gopreev)user.messaging_unread_previous()
([channel] unread next | goneck)user.messaging_unread_next()
go (find | search)user.messaging_open_search()
mark (all | workspace | server) readuser.messaging_mark_workspace_read()
mark channel readuser.messaging_mark_channel_read()
upload fileuser.messaging_upload_file()

microphone selection

Command Result
microphone showuser.microphone_selection_toggle()
microphone pick user.microphone_select(number_small)

mouse

Command Result
control mouseuser.mouse_toggle_control_mouse()
zoom mouseuser.mouse_toggle_zoom_mouse()
camera overlayuser.mouse_toggle_camera_overlay()
run calibrationuser.mouse_calibrate()
touchmouse_click(0) # close the mouse grid if open user.grid_close() # End any open drags # Touch automatically ends left drags so this is for right drags specifically user.mouse_drag_end()
rightymouse_click(1) # close the mouse grid if open user.grid_close()
midclickmouse_click(2) # close the mouse grid user.grid_close() #see keys.py for modifiers. #defaults #command #control #option = alt #shift #super = windows key
touchkey("{modifiers}:down") mouse_click(0) key("{modifiers}:up") # close the mouse grid user.grid_close()
rightykey("{modifiers}:down") mouse_click(1) key("{modifiers}:up") # close the mouse grid user.grid_close()
(dubclick | duke)mouse_click() mouse_click() # close the mouse grid user.grid_close()
(tripclick | triplick)mouse_click() mouse_click() mouse_click() # close the mouse grid user.grid_close()
left drag | draguser.mouse_drag(0) # close the mouse grid user.grid_close()
right drag | righty draguser.mouse_drag(1) # close the mouse grid user.grid_close()
end drag | drag enduser.mouse_drag_end()
wheel downuser.mouse_scroll_down()
wheel down hereuser.mouse_move_center_active_window() user.mouse_scroll_down()
wheel tiny [down]mouse_scroll(20)
wheel tiny [down] hereuser.mouse_move_center_active_window() mouse_scroll(20)
wheel downeruser.mouse_scroll_down_continuous()
wheel downer hereuser.mouse_move_center_active_window() user.mouse_scroll_down_continuous()
wheel upuser.mouse_scroll_up()
wheel up hereuser.mouse_scroll_up()
wheel tiny upmouse_scroll(-20)
wheel tiny up hereuser.mouse_move_center_active_window() mouse_scroll(-20)
wheel upperuser.mouse_scroll_up_continuous()
wheel upper hereuser.mouse_move_center_active_window() user.mouse_scroll_up_continuous()
wheel gazeuser.mouse_gaze_scroll()
wheel gaze hereuser.mouse_move_center_active_window() user.mouse_gaze_scroll()
wheel stopuser.mouse_scroll_stop()
wheel stop hereuser.mouse_move_center_active_window() user.mouse_scroll_stop()
wheel leftmouse_scroll(0, -40)
wheel left hereuser.mouse_move_center_active_window() mouse_scroll(0, -40)
wheel tiny leftmouse_scroll(0, -20)
wheel tiny left hereuser.mouse_move_center_active_window() mouse_scroll(0, -20)
wheel rightmouse_scroll(0, 40)
wheel right hereuser.mouse_move_center_active_window() mouse_scroll(0, 40)
wheel tiny rightmouse_scroll(0, 20)
wheel tiny right hereuser.mouse_move_center_active_window() mouse_scroll(0, 20)
curse yesuser.mouse_show_cursor()
curse nouser.mouse_hide_cursor()
copy mouse positionuser.copy_mouse_position()

multiple cursors

Command Result
cursor multipleuser.multi_cursor_enable()
cursor stopuser.multi_cursor_disable()
cursor upuser.multi_cursor_add_above()
cursor downuser.multi_cursor_add_below()
cursor lessuser.multi_cursor_select_fewer_occurrences()
cursor moreuser.multi_cursor_select_more_occurrences()
cursor alluser.multi_cursor_select_all_occurrences()
cursor linesuser.multi_cursor_add_to_line_ends()

repeater

Command Result
core.repeat_command(ordinals-1)
timescore.repeat_command(number_small-1)
(repeat that|twice)core.repeat_command(1)
repeat that [times]core.repeat_command(number_small)

screens

Command Result
screen numbersuser.screens_show_numbering()

screenshot

Command Result
grab screenuser.screenshot()
grab screen user.screenshot(number_small)
grab windowuser.screenshot_window()
grab selectionuser.screenshot_selection()
grab screen clipuser.screenshot_clipboard()
grab screen clipuser.screenshot_clipboard(number_small)
grab window clipuser.screenshot_window_clipboard()

splits

Command Result
split rightuser.split_window_right()
split leftuser.split_window_left()
split downuser.split_window_down()
split upuser.split_window_up()
split (vertically | vertical)user.split_window_vertically()
split (horizontally | horizontal)user.split_window_horizontally()
split flipuser.split_flip()
split windowuser.split_window()
split clearuser.split_clear()
split clear alluser.split_clear_all()
split nextuser.split_next()
split lastuser.split_last()
go split user.split_number(number)

standard

Command Result
zoom inedit.zoom_in()
zoom outedit.zoom_out()
scroll upedit.page_up()
scroll downedit.page_down()
copy thatedit.copy()
cut thatedit.cut()
paste thatedit.paste()
undo thatedit.undo()
redo thatedit.redo()
paste matchedit.paste_match_style()
file saveedit.save()
wipekey(backspace)
(pad | padding)insert(" ") key(left)
slapedit.line_insert_down()

tabs

Command Result
tab (open | new)app.tab_open()
tab (last | previous)app.tab_previous()
tab nextapp.tab_next()
tab closeuser.tab_close_wrapper()
tab (reopen|restore)app.tab_reopen()
go tab user.tab_jump(number)
go tab finaluser.tab_final()

talon helpers

Command Result
talon check updatesmenu.check_for_updates()
talon open logmenu.open_log()
talon open rebelmenu.open_repl()
talon homemenu.open_talon_home()
talon copy context pieuser.talon_add_context_clipboard_python()
talon copy contextuser.talon_add_context_clipboard()
talon copy namename = app.name() clip.set_text(name)
talon copy executableexecutable = app.executable() clip.set_text(executable)
talon copy bundlebundle = app.bundle() clip.set_text(bundle)
talon copy titletitle = win.title() clip.set_text(title)
talon dump versionresult = user.talon_version_info() print(result)
talon insert versionresult = user.talon_version_info() user.paste(result)
talon dump contextresult = user.talon_get_active_context() print(result)
talon test lastphrase = user.history_get(1) user.talon_sim_phrase(phrase)
talon test numb phrase = user.history_get(number_small) user.talon_sim_phrase(phrase)
talon test user.talon_sim_phrase(phrase)
talon debug action {user.talon_actions}user.talon_action_find("{user.talon_actions}")
talon debug list {user.talon_lists}user.talon_debug_list(talon_lists)
talon copy list {user.talon_lists}user.talon_copy_list(talon_lists)
talon debug tagsuser.talon_debug_tags()
talon debug modesuser.talon_debug_modes()
talon debug scope {user.talon_scopes}user.talon_debug_scope(talon_scopes)
talon debug setting {user.talon_settings}user.talon_debug_setting(talon_settings)
talon debug all settingsuser.talon_debug_all_settings()
talon debug active appresult = user.talon_get_active_application_info() print("**** Dumping active application **** ") print(result) print("***********************")
talon copy active appresult = user.talon_get_active_application_info() clip.set_text(result)

websites and search engines

Command Result
open {user.website}user.open_url(website)
{user.search_engine} hunt user.search_with_search_engine(search_engine, user.text)
{user.search_engine} (that|this)text = edit.selected_text() user.search_with_search_engine(search_engine, text)

win window management

Command Result
window (new|open)app.window_open()
window nextapp.window_next()
window lastapp.window_previous()
window closeapp.window_close()
focus user.switcher_focus(running_applications)
running listuser.switcher_toggle_running()
launch user.switcher_launch(launch_applications)
snap user.snap_window(window_snap_position)
snap next [screen]user.move_window_next_screen()
snap last [screen]user.move_window_previous_screen()
snap screen user.move_window_to_screen(number)
snap user.snap_app(running_applications, window_snap_position)
snap [screen] user.move_app_to_screen(running_applications, number)

dictation mode

Command Result
press key("{keys}")
auto_insert(prose)
new line"\n"
new paragraph"\n\n"
cap result = user.formatted_text(word, "CAPITALIZE_FIRST_WORD") auto_insert(result) # Navigation
go up (line|lines)edit.up() repeat(number_small - 1)
go down (line|lines)edit.down() repeat(number_small - 1)
go left (word|words)edit.word_left() repeat(number_small - 1)
go right (word|words)edit.word_right() repeat(number_small - 1)
go line startedit.line_start()
go line endedit.line_end()
select left (word|words)edit.extend_word_left() repeat(number_small - 1)
select right (word|words)edit.extend_word_right() repeat(number_small - 1)
select left (character|characters)edit.extend_left() repeat(number_small - 1)
select right (character|characters)edit.extend_right() repeat(number_small - 1)
clear left (word|words)edit.extend_word_left() repeat(number_small - 1) edit.delete()
clear right (word|words)edit.extend_word_right() repeat(number_small - 1) edit.delete()
clear left (character|characters)edit.extend_left() repeat(number_small - 1) edit.delete()
clear right (character|characters)edit.extend_right() repeat(number_small - 1) edit.delete() # Formatting
formatted user.dictation_insert_raw(format_text)
format selection user.formatters_reformat_selection(formatters) # Corrections
scratch thatuser.clear_last_phrase()
scratch selectionedit.delete()
select thatuser.select_last_phrase()
spell that auto_insert(letters)
spell that result = user.formatted_text(letters, formatters) user.dictation_insert_raw(result) # Escape, type things that would otherwise be commands
escape auto_insert(user.text)

dragon modes

Command Result
dragon modeuser.dragon_mode()
talon modeuser.talon_mode()

language modes

Command Result
force see sharpuser.code_set_language_mode("csharp")
force see plus plususer.code_set_language_mode("cplusplus")
force go (lang|language)user.code_set_language_mode("go")
force javauser.code_set_language_mode("java")
force java scriptuser.code_set_language_mode("javascript")
force type scriptuser.code_set_language_mode("typescript")
force markdownuser.code_set_language_mode("markdown")
force pythonuser.code_set_language_mode("python")
force are languageuser.code_set_language_mode("r")
force talon [language]user.code_set_language_mode("talon")
clear language modesuser.code_clear_language_mode()
[enable] debug modemode.enable("user.gdb")
disable debug modemode.disable("user.gdb")

modes

Command Result
dictation modemode.disable("sleep") mode.disable("command") mode.enable("dictation") user.code_clear_language_mode() mode.disable("user.gdb")
command modemode.disable("sleep") mode.disable("dictation") mode.enable("command")

sleep mode wav2letter

Command Result
skip()

wake up

Command Result
welcome backuser.mouse_wake() user.history_enable() user.talon_mode()
sleep all []user.switcher_hide_running() user.history_disable() user.homophones_hide() user.help_hide() user.mouse_sleep() speech.disable() user.engine_sleep()
talon sleep []speech.disable()
talon wakespeech.enable()

mouse grid

Command Result
M griduser.grid_select_screen(1) user.grid_activate()
grid winuser.grid_place_window() user.grid_activate()
grid +user.grid_activate() user.grid_narrow_list(number_key_list)
grid screen []user.grid_select_screen(number or 1) user.grid_activate()

mouse grid open

Command Result
user.grid_narrow(number_key)
grid offuser.grid_close()
grid resetuser.grid_reset()
grid backuser.grid_go_back()

win draft global

Command Result
draft show# Do this toggle so we can have focus when saying 'draft show' user.draft_hide() user.draft_show()
draft show # Do this toggle so we can have focus when saying 'draft show' user.draft_hide() user.draft_show() user.draft_named_move(draft_window_position)
draft show small# Do this toggle so we can have focus when saying 'draft show' user.draft_hide() user.draft_show() user.draft_resize(600, 200)
draft show large# Do this toggle so we can have focus when saying 'draft show' user.draft_hide() user.draft_show() user.draft_resize(800, 500)
draft emptyuser.draft_show("")
draft edittext = edit.selected_text() key(backspace) user.draft_show(text)
draft edit alledit.select_all() text = edit.selected_text() key(backspace) user.draft_show(text)

win draft window

Command Result
replace with user.draft_select("{draft_anchor}") result = user.formatted_text(text, "NOOP") insert(result) # Position cursor before word
cursor user.draft_position_caret("{draft_anchor}")
cursor before user.draft_position_caret("{draft_anchor}") # Position cursor after word
cursor after user.draft_position_caret("{draft_anchor}", 1) # Select a whole word
select user.draft_select("{draft_anchor}") # Select a range of words
select through user.draft_select("{draft_anchor_1}", "{draft_anchor_2}") # Delete a word
clear user.draft_select("{draft_anchor}", "", 1) key(backspace) # Delete a range of words
clear through user.draft_select(draft_anchor_1, draft_anchor_2, 1) key(backspace) # reformat word
word user.draft_select("{draft_anchor}", "", 1) user.formatters_reformat_selection(user.formatters) # reformat range
through user.draft_select(draft_anchor_1, draft_anchor_2, 1) user.formatters_reformat_selection(user.formatters)

win draft window open

Command Result
draft hideuser.draft_hide()
draft submitcontent = user.draft_get_text() user.draft_hide() insert(content) # user.paste may be somewhat faster, but seems to be unreliable on MacOSX, see # https://github.com/talonvoice/talon/issues/254#issuecomment-789355238 # user.paste(content)

find and replace

Command Result
hunt thisuser.find("")
hunt this user.find(text)
hunt alluser.find_everywhere("")
hunt all user.find_everywhere(text)
hunt caseuser.find_toggle_match_by_case()
hunt worduser.find_toggle_match_by_word()
hunt expressionuser.find_toggle_match_by_regex()
hunt nextuser.find_next()
hunt previoususer.find_previous()
replace this []user.replace(text or "")
replace alluser.replace_everywhere("")
replace alluser.replace_everywhere(text)
replace confirm thatuser.replace_confirm()
replace confirm alluser.replace_confirm_all()
clear last [over]user.select_previous_occurrence(text) sleep(100ms) edit.delete()
clear next [over]user.select_next_occurrence(text) sleep(100ms) edit.delete()
clear last clipuser.select_previous_occurrence(clip.text()) edit.delete()
clear next clipuser.select_next_occurrence(clip.text()) sleep(100ms) edit.delete()
comment last [over]user.select_previous_occurrence(text) sleep(100ms) code.toggle_comment()
comment last clipuser.select_previous_occurrence(clip.text()) sleep(100ms) code.toggle_comment()
comment next [over]user.select_next_occurrence(text) sleep(100ms) code.toggle_comment()
comment next clipuser.select_next_occurrence(clip.text()) sleep(100ms) code.toggle_comment()
go last [over]user.select_previous_occurrence(text) sleep(100ms) edit.right()
go last clipuser.select_previous_occurrence(clip.text()) sleep(100ms) edit.right()
go next [over]user.select_next_occurrence(text) edit.right()
go next clipuser.select_next_occurrence(clip.text()) edit.right()
paste last [over]user.select_previous_occurrence(text) sleep(100ms) edit.right() edit.paste()
paste next [over]user.select_next_occurrence(text) sleep(100ms) edit.right() edit.paste()
replace last [over]user.select_previous_occurrence(text) sleep(100ms) edit.paste()
replace next [over]user.select_next_occurrence(text) sleep(100ms) edit.paste()
select last [over]user.select_previous_occurrence(text)
select next [over]user.select_next_occurrence(text)
select last clipuser.select_previous_occurrence(clip.text())
select next clipuser.select_next_occurrence(clip.text())

generic editor

Command Result
find itedit.find()
next oneedit.find_next()
go word leftedit.word_left()
go word rightedit.word_right()
go leftedit.left()
go rightedit.right()
go upedit.up()
go downedit.down()
go line startedit.line_start()
go line endedit.line_end()
go way leftedit.line_start() edit.line_start()
go way rightedit.line_end()
go way downedit.file_end()
go way upedit.file_start()
go bottomedit.file_end()
go topedit.file_start()
go page downedit.page_down()
go page upedit.page_up() # selecting
select lineedit.select_line()
select alledit.select_all()
select leftedit.extend_left()
select rightedit.extend_right()
select upedit.extend_line_up()
select downedit.extend_line_down()
select wordedit.select_word()
select word leftedit.extend_word_left()
select word rightedit.extend_word_right()
select way leftedit.extend_line_start()
select way rightedit.extend_line_end()
select way upedit.extend_file_start()
select way downedit.extend_file_end() # editing
indent [more]edit.indent_more()
(indent less | out dent)edit.indent_less() # deleting
clear lineedit.delete_line()
clear leftkey(backspace)
clear rightkey(delete)
clear upedit.extend_line_up() edit.delete()
clear downedit.extend_line_down() edit.delete()
clear wordedit.delete_word()
clear word leftedit.extend_word_left() edit.delete()
clear word rightedit.extend_word_right() edit.delete()
clear way leftedit.extend_line_start() edit.delete()
clear way rightedit.extend_line_end() edit.delete()
clear way upedit.extend_file_start() edit.delete()
clear way downedit.extend_file_end() edit.delete()
clear alledit.select_all() edit.delete() #copy commands
copy alledit.select_all() edit.copy() #to do: do we want these variants, seem to conflict # copy left: # edit.extend_left() # edit.copy() # copy right: # edit.extend_right() # edit.copy() # copy up: # edit.extend_up() # edit.copy() # copy down: # edit.extend_down() # edit.copy()
copy wordedit.select_word() edit.copy()
copy word leftedit.extend_word_left() edit.copy()
copy word rightedit.extend_word_right() edit.copy()
copy lineedit.select_line() edit.copy() #cut commands
cut alledit.select_all() edit.cut() #to do: do we want these variants # cut left: # edit.select_all() # edit.cut() # cut right: # edit.select_all() # edit.cut() # cut up: # edit.select_all() # edit.cut() # cut down: # edit.select_all() # edit.cut()
cut wordedit.select_word() edit.cut()
cut word leftedit.extend_word_left() edit.cut()
cut word rightedit.extend_word_right() edit.cut()
cut lineedit.select_line() edit.cut()

homophones

Command Result
phones user.homophones_show(homophones_canonical)
phones thatuser.homophones_show_selection()
phones force user.homophones_force_show(homophones_canonical)
phones forceuser.homophones_force_show_selection()
phones hideuser.homophones_hide()
phones wordedit.select_word() user.homophones_show_selection()
phones [] word leftn = ordinals or 1 user.words_left(n - 1) edit.extend_word_left() user.homophones_show_selection()
phones [] word rightn = ordinals or 1 user.words_right(n - 1) edit.extend_word_right() user.homophones_show_selection()

homophones open

Command Result
choose result = user.homophones_select(number_small) insert(result) user.homophones_hide()
choose result = user.homophones_select(number_small) insert(user.formatted_text(result, formatters)) user.homophones_hide()

line commands

Command Result
lendedit.line_end()
bendedit.line_start()
go edit.jump_line(number)
go endedit.jump_line(number) edit.line_end()
comment [line] user.select_range(number, number) code.toggle_comment()
comment until user.select_range(number_1, number_2) code.toggle_comment()
clear [line] edit.jump_line(number) user.select_range(number, number) edit.delete()
clear until user.select_range(number_1, number_2) edit.delete()
copy [line] user.select_range(number, number) edit.copy()
copy until user.select_range(number_1, number_2) edit.copy()
cut [line] user.select_range(number, number) edit.cut()
cut [line] until user.select_range(number_1, number_2) edit.cut()
(paste | replace) until user.select_range(number_1, number_2) edit.paste()
(select | cell | sell) [line] user.select_range(number, number)
(select | cell | sell) until user.select_range(number_1, number_2)
tab thatedit.indent_more()
tab [line] edit.jump_line(number) edit.indent_more()
tab until user.select_range(number_1, number_2) edit.indent_more()
retab thatedit.indent_less()
retab [line] user.select_range(number, number) edit.indent_less()
retab until user.select_range(number_1, number_2) edit.indent_less()
drag [line] downedit.line_swap_down()
drag [line] upedit.line_swap_up()
drag up [line] user.select_range(number, number) edit.line_swap_up()
drag up until user.select_range(number_1, number_2) edit.line_swap_up()
drag down [line] user.select_range(number, number) edit.line_swap_down()
drag down until user.select_range(number_1, number_2) edit.line_swap_down()
clone (line|that)edit.line_clone()

numbers

Command Result
"{number_string}"

symbols

Command Result
question [mark]"?"
(downscore | underscore)"_"
double dash"--"
(bracket | brack | left bracket)"{"
(rbrack | are bracket | right bracket)"}"
triple quote"'''"
(triple grave | triple back tick | gravy)insert("```")
(dot dot | dotdot)".."
ellipses"..."
(comma and | spamma)", "
plus"+"
arrow"->"
dub arrow"=>"
new line"\\n"
carriage return"\\r"
line feed"\\r\\n"
empty dubstring'""' key(left)
empty escaped (dubstring|dub quotes)'\\"\\"' key(left) key(left)
empty string"''" key(left)
empty escaped string"\\'\\'" key(left) key(left)
(inside parens | args)insert("()") key(left)
inside (squares | square brackets | list)insert("[]") key(left)
inside (bracket | braces)insert("{}") key(left)
inside percentinsert("%%") key(left)
inside (quotes | string)insert("''") key(left)
inside (double quotes | dubquotes)insert('""') key(left)
inside (graves | back ticks)insert("``") key(left)
angle thattext = edit.selected_text() user.paste("<{text}>")
(square | square bracket) thattext = edit.selected_text() user.paste("[{text}]")
(bracket | brace) thattext = edit.selected_text() user.paste("{{{text}}}")
(parens | args) thattext = edit.selected_text() user.paste("({text})")
percent thattext = edit.selected_text() user.paste("%{text}%")
quote thattext = edit.selected_text() user.paste("'{text}'")
(double quote | dubquote) thattext = edit.selected_text() user.paste('"{text}"')
(grave | back tick) thattext = edit.selected_text() user.paste('`{text}`')

text navigation

Command Result
navigate [{user.arrow_key}] [{user.navigation_action}] [{user.navigation_target_name}] [{user.before_or_after}] [] ## If you use this command a lot, you may wish to have a shorter syntax that omits the navigate keyword. Note that you then at least have to say either a navigation_action or before_or_after: #({user.navigation_action} [{user.arrow_key}] [{user.navigation_target_name}] [{user.before_or_after}] | [{user.arrow_key}] {user.before_or_after}) [] : user.navigation(navigation_action or "GO", arrow_key or "RIGHT", navigation_target_name or "DEFAULT", before_or_after or "DEFAULT", navigation_target, ordinals or 1) # ===== Examples of use ===== # # navigate comma: moves after the next "," on the line. # navigate before five: moves before the next "5" on the line. # navigate left underscore: moves before the previous "_" on the line. # navigate left after second plex: moves after the second-previous "x" on the line. # # Besides characters, we can find phrases or move in predetermined units: # # navigate phrase hello world: moves after the next "hello world" on the line. # navigate left third word: moves left over three words. # navigate before second big: moves before the second-next 'big' word (a chunk of anything except white space). # navigate left second small: moves left over two 'small' words (chunks of a camelCase name). # # We can search several lines (default 10) above or below the cursor: # # navigate up phrase john: moves before the previous "john" (case-insensitive) on the preceding lines. # navigate down third period: moves after the third period on the following lines. # # Besides movement, we can cut, copy, select, clear (delete), or extend the current selection: # # navigate cut after comma: cut the word following the next comma on the line. # navigate left copy third word: copy the third word to the left. # navigate extend third big: extend the selection three big words right. # navigate down clear phrase I think: delete the next occurrence of "I think" on the following lines. # navigate up select colon: select the closest colon on the preceeding lines. # # We can specify what gets selected before or after the given input: # # navigate select parens after equals: Select the first "(" and everything until the first ")" after the "=" # navigate left copy all before equals: Copy everything from the start of the line until the first "=" you encounter while moving left # navigate clear constant before semicolon: Delete the last word consisting of only uppercase characters or underscores before a ";" # # ===== Explanation of the grammar ===== # # [{user.arrow_key}]: left, right, up, down (default: right) # Which direction to navigate in. # left/right work on the current line. # up/down work on the closest lines (default: 10) above or below. # # [{user.navigation_action}]: move, extend, select, clear, cut, copy (default: move) # What action to perform. # # [{user.navigation_target_name}]: word, small, big, parens, squares, braces, quotes, angles, all, method, constant (default: word) # The predetermined unit to select if before_or_after was specified. # Defaults to "word" # # [{user.before_or_after}]: before, after (default: special behavior) # For move/extend: where to leave the cursor, before or after the target. # Defaults to "after" for right/down and "before" for left/up. # # For select/copy/cut: if absent, select/copy/cut the target iself. If # present, the navigation_target_name before/after the target. # # []: an english ordinal, like "second" (default: first) # Which occurrence of the target to navigate to. # # : one of the following: # - a character name, like "comma" or "five". # - "word" or "big" or "small" # - "phrase " # Specifies the target to search for/navigate to. # The functionality for all these commands is covered in the lines above, but these commands are kept here for convenience. Originally from word_selection.talon.
word neck []user.navigation_by_name("SELECT", "RIGHT", "DEFAULT", "word", number_small or 1)
word pre []user.navigation_by_name("SELECT", "LEFT", "DEFAULT", "word", number_small or 1)
small word neck []user.navigation_by_name("SELECT", "RIGHT", "DEFAULT", "small", number_small or 1)
small word pre []user.navigation_by_name("SELECT", "LEFT", "DEFAULT", "small", number_small or 1)
big word neck []user.navigation_by_name("SELECT", "RIGHT", "DEFAULT", "big", number_small or 1)
big word pre []user.navigation_by_name("SELECT", "LEFT", "DEFAULT", "big", number_small or 1)