Talon Settings

Spoken	Backend
dictate.punctuation	`[` `".,-!?"` `]`
dictate.word_map	`[` `{` `"january": "January",` `"february": "February",` `"april": "April",` `"june": "June",` `"july": "July",` `"august": "August",` `"september": "September",` `"october": "October",` `"november": "November",` `"december": "December",` `"Yamal": "YAML",` `"Nicol": "Nico",` `"martin": "Martin",` `"lucas": "Lucas",` `"zeno": "Zeno",` `"chen": "Cem",` `"marcus": "Markus",` `"ralph": "Ralf",` `"Natalie": "Nathalie",` `"ariane": "Ariane"` `}` `]`
hotkey_wait	`[` `0.0` `]`
imgui.dark_mode	`[` `false` `]`
imgui.scale	`[` `1.0,` `1.3` `]`
insert_wait	`[` `0.0` `]`
key_hold	`[` `0.0` `]`
key_wait	`[` `1.0` `]`
speech._engine_id	`[` `null,` `"88a5060045cba0aa6a04c26de2b6407081d78844556f4ab7f2535b4415880adf"` `]`
speech._subtitles	`[` `true,` `true` `]`
speech.debug	`[` `false` `]`
speech.engine	`[` `null,` `"wav2letter"` `]`
speech.gain	`[` `1.0` `]`
speech.language	`[` `null` `]`
speech.latency	`[` `1.0` `]`
speech.microphone	`[` `null` `]`
speech.normalize	`[` `false` `]`
speech.record_all	`[` `false,` `true` `]`
speech.record_labels	`[` `false` `]`
speech.record_path	`[` `"recordings"` `]`
speech.threshold	`[` `0.75` `]`
speech.timeout	`[` `0.3` `]`
tracking.zoom_height	`[` `300` `]`
tracking.zoom_live	`[` `false` `]`
tracking.zoom_scale	`[` `3` `]`
tracking.zoom_width	`[` `400` `]`
user.command_history_display	`[` `10,` `10` `]`
user.command_history_size	`[` `50,` `50` `]`
user.context_sensitive_dictation	`[` `false` `]`
user.context_sensitive_dictation_peek_character	`[` `" "` `]`
user.cursorless_settings_directory	`[` `"cursorless-settings"` `]`
user.cygpath	`[` `"C:\\cygwin64\\bin\\cygpath.exe"` `]`
user.deprecate_warning_interval_hours	`[` `24` `]`
user.double_pop_speed_maximum	`[` `0.3,` `0.3` `]`
user.double_pop_speed_minimum	`[` `0.1,` `0.1` `]`
user.draft_editor	`[` `null` `]`
user.draft_window_label_color	`[` `null` `]`
user.draft_window_label_size	`[` `20` `]`
user.draft_window_text_size	`[` `20` `]`
user.draft_window_theme	`[` `"dark"` `]`
user.edit_command_line_selection_delay	`[` `75` `]`
user.edit_command_word_selection_delay	`[` `75` `]`
user.emacs_meta	`[` `"esc"` `]`
user.file_manager_auto_show_pickers	`[` `false,` `false` `]`
user.file_manager_file_limit	`[` `1000` `]`
user.file_manager_folder_limit	`[` `1000` `]`
user.file_manager_imgui_limit	`[` `20` `]`
user.file_manager_string_limit	`[` `20` `]`
user.grid_narrow_expansion	`[` `0` `]`
user.grids_put_one_bottom_left	`[` `false,` `true` `]`
user.help_max_command_lines_per_page	`[` `50,` `50` `]`
user.help_max_contexts_per_page	`[` `20,` `20` `]`
user.help_scope_max_length	`[` `50` `]`
user.help_sort_contexts_by_specificity	`[` `true` `]`
user.hiss_scroll_debounce_time	`[` `100,` `100` `]`
user.i3_config_path	`[` `"~/.i3/config"` `]`
user.i3_mod_key	`[` `"super"` `]`
user.listening_timeout_minutes	`[` `-1` `]`
user.listening_timeout_show_notification	`[` `true` `]`
user.lua_version	`[` `5.1` `]`
user.mode_indicator_color_alpha	`[` `0.75` `]`
user.mode_indicator_color_command	`[` `"6495ed"` `]`
user.mode_indicator_color_dictation	`[` `"ffd700"` `]`
user.mode_indicator_color_gradient	`[` `0.5` `]`
user.mode_indicator_color_mixed	`[` `"3cb371"` `]`
user.mode_indicator_color_mute	`[` `"000000"` `]`
user.mode_indicator_color_other	`[` `"f8f8ff"` `]`
user.mode_indicator_color_sleep	`[` `"808080"` `]`
user.mode_indicator_show	`[` `false,` `false` `]`
user.mode_indicator_size	`[` `30` `]`
user.mode_indicator_x	`[` `0.5` `]`
user.mode_indicator_y	`[` `0` `]`
user.model_default	`[` `"gpt-4o-mini"` `]`
user.model_default_destination	`[` `"paste"` `]`
user.model_endpoint	`[` `"https://api.openai.com/v1/chat/completions"` `]`
user.model_llm_path	`[` `"llm"` `]`
user.model_shell_default	`[` `"bash"` `]`
user.model_system_prompt	`[` `"You are an assistant helping an office worker to be more productive. Output just the response to the request and no additional content. Do not generate any markdown formatting such as backticks for programming languages unless it is explicitly requested. If the user requests code generation, output just code and not additional natural language explanation."` `]`
user.model_temperature	`[` `-1.0` `]`
user.model_verbose_notifications	`[` `true` `]`
user.model_window_char_width	`[` `80` `]`
user.mouse_continuous_scroll_acceleration	`[` `1,` `1` `]`
user.mouse_continuous_scroll_amount	`[` `8,` `8,` `0,` `20` `]`
user.mouse_continuous_scroll_speed_quotient	`[` `10.0` `]`
user.mouse_enable_hiss_scroll	`[` `false,` `false` `]`
user.mouse_enable_pop_click	`[` `0,` `1` `]`
user.mouse_enable_pop_stops_drag	`[` `false,` `true` `]`
user.mouse_enable_pop_stops_scroll	`[` `false,` `true` `]`
user.mouse_gaze_scroll_speed_multiplier	`[` `1.0,` `1.0` `]`
user.mouse_hide_mouse_gui	`[` `false,` `false` `]`
user.mouse_wake_hides_cursor	`[` `false,` `false` `]`
user.mouse_wheel_down_amount	`[` `120,` `120` `]`
user.mouse_wheel_horizontal_amount	`[` `40,` `40` `]`
user.openai_model	`[` `"do_not_use"` `]`
user.paste_to_insert_threshold	`[` `-1` `]`
user.powershell_always_refresh_title	`[` `true` `]`
user.private_cursorless_use_preferred_scope	`[` `false` `]`
user.screenshot_folder	`[` `"~/Pictures"` `]`
user.selected_text_timeout	`[` `0.25` `]`
user.snippet_raw_text_paste	`[` `false` `]`
user.snippets_dir	`[` `null,` `"my-overrides/community/snippets"` `]`
user.subtitles_color	`[` `null,` `"ffffff"` `]`
user.subtitles_color_outline	`[` `null,` `"aaaaaa"` `]`
user.subtitles_screens	`[` `null,` `"main"` `]`
user.subtitles_show	`[` `false,` `false` `]`
user.subtitles_size	`[` `null,` `100` `]`
user.subtitles_timeout_max	`[` `null,` `3000` `]`
user.subtitles_timeout_min	`[` `null,` `750` `]`
user.subtitles_timeout_per_char	`[` `null,` `50` `]`
user.subtitles_y	`[` `null,` `0.93` `]`
user.talon_hud_allows_capture	`[` `true` `]`
user.talon_hud_environment	`[` `""` `]`
user.text_navigation_max_line_search	`[` `10` `]`
user.tmux_prefix_key	`[` `"ctrl-b"` `]`
user.window_snap_screen	`[` `"proportional"` `]`

Talon Tags

In alphabetical order:

user.code_comment_line
user.code_functions_common
user.code_operators_assignment
user.code_operators_bitwise
user.code_operators_math
user.command_client
user.command_search
user.cursorless
user.draft_editor_app_focused
user.draft_editor_app_running
user.emoji
user.find
user.find_and_replace
user.help_open
user.line_commands
user.mouse_cursor_commands_enable
user.multiple_cursors
user.splits
user.tabs
user.talon_hud_available
user.talon_hud_choices_visible
user.talon_hud_visible
user.ubuntu

`user.abbreviation`

List: {user.abbreviation}>

Spoken	Backend
c	`C`
j peg	`jpg`
ab	`ab`
abbr	`abbr`
abbreviate	`abbr`
abort	`abrt`
abrt	`abrt`
ack	`ack`
acknowledge	`ack`
addr	`addr`
address	`addr`
addresses	`addrs`
addrs	`addrs`
admin	`admin`
administrator	`admin`
administrators	`admins`
admins	`admins`
adv	`adv`
advance	`adv`
advanced	`adv`
afaict	`afaict`
afaik	`afaik`
afk	`afk`
alberta	`ab`
algo	`algo`
algorithm	`algo`
alloc	`alloc`
allocate	`alloc`
alt	`alt`
alternative	`alt`
app	`app`
appl	`appl`
apple	`appl`
application	`app`
applications	`apps`
apps	`apps`
arg	`arg`
args	`args`
argument	`arg`
arguments	`args`
as far as i can tell	`afaict`
as far as i know	`afaik`
asm	`asm`
assembly	`asm`
async	`async`
asynchronous	`async`
at the moment	`atm`
atm	`atm`
attr	`attr`
attribute	`attr`
attributes	`attrs`
attrs	`attrs`
augroup	`augroup`
auth	`auth`
authenticate	`auth`
authentication	`authn`
authn	`authn`
authorization	`authz`
authz	`authz`
auto group	`augroup`
average	`avg`
avg	`avg`
away from keyboard	`afk`
backup	`bkp`
bc	`bc`
be right back	`brb`
bin	`bin`
binary	`bin`
bkp	`bkp`
blk	`blk`
block	`blk`
bool	`bool`
boolean	`bool`
bot	`bot`
bottom	`bot`
bp	`bp`
bps	`bps`
brb	`brb`
break point	`bp`
break points	`bps`
british columbia	`bc`
btn	`btn`
btw	`btw`
buf	`buf`
buffer	`buf`
button	`btn`
by the way	`btw`
ca	`ca`
calc	`calc`
calculate	`calc`
calculator	`calc`
cam	`cam`
camera	`cam`
canada	`ca`
centimeter	`cm`
cfg	`cfg`
char	`chr`
character	`char`
check	`chk`
child	`chld`
china	`cn`
chk	`chk`
chld	`chld`
chr	`chr`
class	`cls`
cli	`cli`
client	`cli`
cls	`cls`
cm	`cm`
cmd	`cmd`
cmds	`cmds`
cmp	`cmp`
cmt	`cmt`
cn	`cn`
cnt	`cnt`
col	`col`
column	`col`
comm	`comm`
command	`cmd`
commands	`cmds`
comment	`cmt`
comms	`comms`
communication	`comm`
communications	`comms`
compare	`cmp`
cond	`cond`
condition	`cond`
conf	`conf`
conference	`conf`
config	`cfg`
configs	`configs`
configuration	`config`
configurations	`configs`
conn	`conn`
connection	`conn`
const	`const`
constant	`const`
constructor	`ctor`
context	`ctx`
contrib	`contrib`
contribute	`contrib`
control	`ctrl`
control flow graph	`cfg`
coord	`coord`
coordinate	`coord`
coordinates	`coords`
coords	`coords`
copy	`cpy`
count	`cnt`
counter	`ctr`
cpu	`cpu`
cpy	`cpy`
cred	`cred`
credential	`cred`
credentials	`creds`
creds	`creds`
cross reference	`xref`
cross references	`xrefs`
ctl	`ctl`
ctor	`ctor`
ctr	`ctr`
ctrl	`ctrl`
ctx	`ctx`
cuddle	`ctl`
cur	`cur`
current	`cur`
cute	`qt`
database	`db`
date format	`yyyy-mm-dd`
db	`db`
dbg	`dbg`
dbl	`dbl`
deb	`deb`
debian	`deb`
debug	`dbg`
dec	`dec`
decimal	`dec`
decl	`decl`
declaration	`decl`
declare	`decl`
decode	`dec`
decrement	`dec`
def	`def`
define	`def`
definition	`def`
deg	`deg`
degree	`deg`
del	`del`
delete	`del`
dep	`dep`
depend	`dep`
depends	`deps`
deps	`deps`
deque	`deque`
desc	`desc`
description	`desc`
dest	`dst`
destination	`dest`
dev	`dev`
develop	`dev`
development	`dev`
device	`dev`
diag	`diag`
diagnostic	`diag`
dict	`dict`
dictation	`dict`
dictionary	`dict`
dir	`dir`
direction	`dir`
directories	`dirs`
directory	`dir`
dirs	`dirs`
disp	`disp`
display	`disp`
dist	`dist`
distance	`dist`
distribution	`dist`
doc	`doc`
docs	`docs`
document	`doc`
documents	`docs`
doing	`ing`
double	`dbl`
double ended queue	`deque`
dst	`dst`
dup	`dup`
dupe	`dup`
duplicate	`dup`
dyn	`dyn`
dynamic	`dyn`
elast	`elast`
elastic	`elast`
elem	`elem`
element	`elem`
elements	`elems`
elems	`elems`
enc	`enc`
encode	`enc`
end of day	`eod`
end of month	`eom`
end of quarter	`eoq`
end of week	`eow`
end of year	`eoy`
ent	`ent`
entry	`ent`
enum	`enum`
enumerate	`enum`
env	`env`
environment	`env`
eod	`eod`
eom	`eom`
eoq	`eoq`
eow	`eow`
eoy	`eoy`
err	`err`
error	`err`
esc	`esc`
escape	`esc`
etc	`etc`
etcetera	`etc`
eth	`eth`
ethernet	`eth`
eval	`eval`
evaluate	`eval`
ex	`ex`
example	`ex`
exc	`exc`
exception	`exc`
exe	`exe`
exec	`exec`
executable	`exe`
executables	`exes`
execute	`exec`
exes	`exes`
exp	`exp`
experience	`exp`
exponent	`exp`
expr	`expr`
expression	`expr`
expressions	`exprs`
exprs	`exprs`
ext	`ext`
extend	`ext`
extension	`ext`
extern	`extern`
external	`extern`
eye dent	`id`
eye octal	`ioctl`
eye three	`i3`
feat	`feat`
feature	`feat`
fgt	`fgt`
file system	`fs`
fingerprint	`fp`
fmt	`fmt`
for what	`fwiw`
format	`fmt`
fortigate	`fgt`
fp	`fp`
framework	`fw`
freq	`freq`
frequency	`freq`
fs	`fs`
func	`func`
funcs	`funcs`
function	`func`
functions	`funcs`
funny	`lol`
fuzzy	`fzy`
fw	`fw`
fwiw	`fwiw`
fzy	`fzy`
gen	`gen`
generate	`gen`
generic	`gen`
gif	`gif`
hardware	`hw`
hdr	`hdr`
header	`hdr`
hello	`helo`
helo	`helo`
hist	`hist`
history	`hist`
http	`http`
hw	`hw`
hypertext	`http`
iat	`iat`
id	`id`
identity	`id`
idx	`idx`
ign	`ign`
ignore	`ign`
image	`img`
img	`img`
impl	`impl`
implement	`impl`
import address table	`iat`
import table	`iat`
in real life	`irl`
inc	`inc`
increment	`inc`
index	`idx`
info	`info`
information	`info`
infra	`infra`
infrastructure	`infra`
ing	`ing`
init	`init`
initialize	`init`
initializer	`init`
ino	`ino`
inode	`ino`
ins	`ins`
insert	`ins`
insn	`insn`
inst	`inst`
instance	`inst`
instruction	`insn`
int	`int`
integer	`int`
interp	`interp`
interpreter	`interp`
interrupt	`int`
ioctl	`ioctl`
irl	`irl`
iter	`iter`
iterate	`iter`
jar	`jar`
jason	`json`
jason five	`json5`
java archive	`jar`
javascript	`js`
jiff	`gif`
jit	`jit`
jmp	`jmp`
journal cuttle	`journalctl`
journalctl	`journalctl`
jpg	`jpg`
js	`js`
json	`json`
jump	`jmp`
just in time	`jit`
kay	`kk`
kbd	`kbd`
kernel	`krnl`
key cuttle	`keyctl`
keyboard	`kbd`
keyctl	`keyctl`
keyword	`kw`
keyword arguments	`kwargs`
kg	`kg`
kilogram	`kg`
kilometer	`km`
kk	`kk`
km	`km`
krnl	`krnl`
kw	`kw`
kwargs	`kwargs`
lang	`lang`
language	`lang`
laugh out loud	`lol`
len	`len`
length	`len`
lgtm	`lgtm`
lib	`lib`
lib see	`libc`
libc	`libc`
library	`lib`
lisp	`lsp`
lol	`lol`
looks good to me	`lgtm`
lsp	`lsp`
mail	`smtp`
make	`mk`
management	`mgmt`
manager	`mgr`
manitoba	`mb`
markdown	`md`
max	`max`
maximum	`max`
mb	`mb`
md	`md`
mem	`mem`
memory	`mem`
message	`msg`
meta sploit	`msf`
meta sploit framework	`msf`
mg	`mg`
mgmt	`mgmt`
mgr	`mgr`
mic	`mic`
microphone	`mic`
mid	`mid`
middle	`mid`
milligram	`mg`
millisecond	`ms`
min	`min`
minimum	`min`
minimum viable product	`mvp`
misc	`misc`
miscellaneous	`misc`
miss	`Ms.`
misses	`Mrs.`
mister	`Mr.`
mk	`mk`
mnt	`mnt`
mod	`mod`
modify	`mod`
mods	`mods`
module	`mod`
modules	`mods`
mon	`mon`
monitor	`mon`
mount	`mnt`
ms	`ms`
msf	`msf`
msg	`msg`
msvc	`msvc`
multi	`multi`
multiple	`multi`
muscle	`musl`
musl	`musl`
mut	`mut`
mutate	`mut`
mvp	`mvp`
nano second	`ns`
nb	`nb`
neo vim	`nvim`
new brunswick	`nb`
nova scotia	`ns`
ns	`ns`
ntoskrnl	`ntoskrnl`
num	`num`
number	`num`
numbers	`nums`
nums	`nums`
nvim	`nvim`
obj	`obj`
object	`obj`
objects	`objs`
objs	`objs`
off	`off`
offs	`offs`
offset	`off`
offsets	`offs`
ok	`ok`
okay	`ok`
on	`on`
ontario	`on`
oob	`oob`
op	`op`
operating system	`os`
operation	`op`
operations	`ops`
ops	`ops`
opt	`opt`
option	`opt`
options	`opts`
opts	`opts`
orig	`orig`
original	`orig`
os	`os`
out of bounds	`oob`
package	`pkg`
package build	`pkgbuild`
packages	`pkgs`
packet	`pkt`
packets	`pkts`
paddr	`paddr`
param	`param`
parameter	`param`
parameters	`params`
params	`params`
passwd	`passwd`
password	`passwd`
perf	`perf`
performance	`perf`
phys	`phys`
physical	`phys`
physical address	`paddr`
pic	`pic`
pick	`pic`
pico second	`ps`
pie	`py`
ping	`png`
pixel	`px`
pkg	`pkg`
pkgbuild	`pkgbuild`
pkgs	`pkgs`
pkt	`pkt`
pkts	`pkts`
png	`png`
point	`pt`
pointer	`ptr`
pointers	`ptrs`
pone	`pwn`
pos	`pos`
position	`pos`
position independent code	`pic`
position independent executable	`pie`
pound bag	`pwndbg`
pref	`pref`
preference	`pref`
preferences	`prefs`
prefs	`prefs`
prev	`prev`
previous	`prev`
priv	`priv`
private	`priv`
proc	`proc`
process	`proc`
processor	`cpu`
prod	`prod`
production	`prod`
prog	`prog`
program	`prog`
programs	`progs`
progs	`progs`
prop	`prop`
properties	`props`
property	`prop`
props	`props`
proto	`proto`
protobuf	`protobuf`
protocol	`proto`
protocol buffers	`protobuf`
ps	`ps`
pt	`pt`
ptr	`ptr`
ptrs	`ptrs`
pub	`pub`
public	`pub`
pwn	`pwn`
pwndbg	`pwndbg`
px	`px`
py	`py`
python	`py`
qc	`qc`
qs	`qs`
qt	`qt`
quebec	`qc`
query string	`qs`
rad	`rad`
radian	`rad`
rand	`rand`
random	`rand`
rb	`rb`
rcpt	`rcpt`
read right ex	`rwx`
rec	`rec`
receipt	`rcpt`
receive	`recv`
record	`rec`
recording	`rec`
rect	`rect`
rectangle	`rect`
recv	`recv`
ref	`ref`
ref count	`refcnt`
refcnt	`refcnt`
reference	`ref`
references	`refs`
refs	`refs`
reg	`reg`
regex	`regex`
register	`reg`
registers	`regs`
registery	`reg`
regs	`regs`
regular expression	`regex`
regular expressions	`regex`
remove	`rm`
repel	`repl`
repetitive strain injury	`rsi`
repl	`repl`
repo	`repo`
repository	`repo`
repr	`repr`
represent	`repr`
representation	`repr`
req	`req`
reqs	`reqs`
request	`req`
requests	`reqs`
res	`res`
resources	`rsrcs`
resp	`resp`
response	`resp`
result	`res`
ret	`ret`
return	`ret`
rev	`rev`
revision	`rev`
rm	`rm`
rnd	`rnd`
round	`rnd`
rs	`rs`
rsi	`rsi`
rsrcs	`rsrcs`
ruby	`rb`
rust	`rs`
rwx	`rwx`
samba	`smb`
samba d	`smbd`
saskatchewan	`sk`
sc	`sc`
sched	`sched`
schedule	`sched`
scheduler	`sched`
scr	`scr`
screen	`scr`
scsi	`scsi`
scuzzy	`scsi`
see	`C`
seg	`seg`
segment	`seg`
sel	`sel`
select	`sel`
sem	`sem`
semaphore	`sem`
send	`snd`
seq	`seq`
sequel	`sql`
sequence	`seq`
service pack	`sp`
session id	`sid`
sh	`sh`
shell	`sh`
shellcode	`sc`
sid	`sid`
sig	`sig`
signal	`sig`
size	`sz`
sk	`sk`
smb	`smb`
smbd	`smbd`
smtp	`smtp`
snd	`snd`
snipped	`[...]`
sod	`sod`
som	`som`
some	`sum`
soq	`soq`
source	`src`
sources	`srcs`
sow	`sow`
soy	`soy`
sp	`sp`
spec	`spec`
special	`spec`
specific	`spec`
specification	`spec`
specify	`spec`
sql	`sql`
src	`src`
srcs	`srcs`
standard	`std`
standard error	`stderr`
standard in	`stdin`
standard out	`stdout`
start of day	`sod`
start of month	`som`
start of quarter	`soq`
start of week	`sow`
start of year	`soy`
stat	`stat`
statement	`stmt`
statistic	`stat`
statistics	`stats`
stats	`stats`
std	`std`
stderr	`stderr`
stdin	`stdin`
stdout	`stdout`
stmt	`stmt`
str	`str`
string	`str`
struct	`struct`
structs	`structs`
structure	`struct`
structures	`structs`
sum	`sum`
sym	`sym`
symbol	`sym`
symbolic link	`symlink`
symbols	`syms`
symlink	`symlink`
syms	`syms`
sync	`sync`
synchronize	`sync`
synchronous	`sync`
sys	`sys`
sys cuttle	`sysctl`
syscall	`syscall`
sysctl	`sysctl`
system	`sys`
system call	`syscall`
system cuddle	`systemctl`
systemctl	`systemctl`
sz	`sz`
table	`tbl`
table of contents	`toc`
taiwan	`tw`
talk	`toc`
tbl	`tbl`
tech	`tech`
technology	`tech`
temp	`tmp`
temperature	`temp`
temporary	`tmp`
term	`term`
terminal	`term`
text	`txt`
time format	`hh:mm:ss`
time of check time of use	`toctou`
time to live	`ttl`
tmp	`tmp`
toc	`toc`
toctou	`toctou`
tok	`tok`
token	`tok`
transaction	`txn`
ts	`ts`
ttl	`ttl`
tw	`tw`
txn	`txn`
txt	`txt`
typescript	`ts`
uid	`uid`
ulti	`ulti`
ultimate	`ulti`
unique id	`uuid`
unk	`unk`
unknown	`unk`
user	`usr`
user id	`uid`
usr	`usr`
util	`util`
utilities	`utils`
utility	`util`
utils	`utils`
uuid	`uuid`
vaddr	`vaddr`
val	`val`
vals	`vals`
value	`val`
values	`vals`
var	`var`
variable	`var`
variables	`vars`
vars	`vars`
vec	`vec`
vector	`vec`
ver	`ver`
verify	`vrfy`
version	`ver`
versus	`vs`
vid	`vid`
video	`vid`
videos	`vids`
vids	`vids`
virt	`virt`
virtual	`virt`
virtual address	`vaddr`
virtual machine	`vm`
vis	`vis`
visual	`vis`
visual studio	`msvc`
vm	`vm`
vol	`vol`
volume	`vol`
vrfy	`vrfy`
vs	`vs`
vuln	`vuln`
vulnerable	`vuln`
wav	`wav`
wave	`wav`
web	`www`
what the fuck	`wtf`
win	`win`
wind	`wnd`
window	`win`
windows kernel	`ntoskrnl`
wip	`wip`
wnd	`wnd`
work in progress	`wip`
wtf	`wtf`
www	`www`
xref	`xref`
xrefs	`xrefs`

`user.arrow_key`

List: {user.arrow_key}>

Spoken	Backend
down	`down`
left	`left`
right	`right`
up	`up`

`user.before_or_after`

List: {user.before_or_after}>

Spoken	Backend
after	`AFTER`
before	`BEFORE`

`user.code_common_function`

List: {user.code_common_function}>

Spoken	Backend
insert	`insert`
key	`key`
print	`print`
repeat	`repeat`

`user.code_formatter`

List: {user.code_formatter}>

Spoken	Backend
all cap	`ALL_CAPS`
all down	`ALL_LOWERCASE`
camel	`PRIVATE_CAMEL_CASE`
conga	`SLASH_SEPARATED`
constant	`ALL_CAPS,SNAKE_CASE`
dotted	`DOT_SEPARATED`
dub string	`DOUBLE_QUOTED_STRING`
dunder	`DOUBLE_UNDERSCORE`
hammer	`PUBLIC_CAMEL_CASE`
kebab	`DASH_SEPARATED`
list	`COMMA_SEPARATED`
packed	`DOUBLE_COLON_SEPARATED`
padded	`SPACE_SURROUNDED_STRING`
slasher	`ALL_SLASHES`
smash	`NO_SPACES`
snake	`SNAKE_CASE`
string	`SINGLE_QUOTED_STRING`

`user.code_function_modifier`

List: {user.code_function_modifier}>

Spoken	Backend
private	`private`
pro	`protected`
pub	`public`
static	`static`

`user.code_operators_assignment`

List: {user.code_operators_assignment}>

Spoken	Backend
bitwise and equals	`ASSIGNMENT_BITWISE_AND`
bitwise exclusive or equals	`ASSIGNMENT_BITWISE_EXCLUSIVE_OR`
bitwise or equals	`ASSIGNMENT_BITWISE_OR`
divide equals	`ASSIGNMENT_DIVISION`
equals	`ASSIGNMENT`
increment	`ASSIGNMENT_INCREMENT`
left shift equals	`ASSIGNMENT_BITWISE_LEFT_SHIFT`
minus equals	`ASSIGNMENT_SUBTRACTION`
mod equals	`ASSIGNMENT_MODULO`
or equals	`ASSIGNMENT_OR`
plus equals	`ASSIGNMENT_ADDITION`
right shift equals	`ASSIGNMENT_BITWISE_RIGHT_SHIFT`
times equals	`ASSIGNMENT_MULTIPLICATION`

`user.code_operators_bitwise`

List: {user.code_operators_bitwise}>

Spoken	Backend
bitwise and	`BITWISE_AND`
bitwise ex or	`BITWISE_EXCLUSIVE_OR`
bitwise left shift	`BITWISE_LEFT_SHIFT`
bitwise not	`BITWISE_NOT`
bitwise or	`BITWISE_OR`
bitwise right shift	`BITWISE_RIGHT_SHIFT`

`user.code_operators_math`

List: {user.code_operators_math}>

Spoken	Backend
and	`MATH_AND`
divide	`MATH_DIVIDE`
int divide	`MATH_INTEGER_DIVIDE`
minus	`MATH_SUBTRACT`
mod	`MATH_MODULO`
not	`MATH_NOT`
or	`MATH_OR`
plus	`MATH_ADD`
power	`MATH_EXPONENT`
times	`MATH_MULTIPLY`
weak and	`MATH_WEAK_AND`
weak not	`MATH_WEAK_NOT`
weak or	`MATH_WEAK_OR`

`user.code_operators_math_comparison`

List: {user.code_operators_math_comparison}>

Spoken	Backend
equal	`MATH_EQUAL`
greater	`MATH_GREATER_THAN`
greater or equal	`MATH_GREATER_THAN_OR_EQUAL`
in	`MATH_IN`
less	`MATH_LESS_THAN`
less or equal	`MATH_LESS_THAN_OR_EQUAL`
not equal	`MATH_NOT_EQUAL`
not in	`MATH_NOT_IN`
weak equal	`MATH_WEAK_EQUAL`
weak not equal	`MATH_WEAK_NOT_EQUAL`

`user.continuous_scrolling_direction`

List: {user.continuous_scrolling_direction}>

Spoken	Backend
downer	`DOWN`
lefter	`LEFT`
righter	`RIGHT`
upper	`UP`

`user.copilot_slash_command`

List: {user.copilot_slash_command}>

Spoken	Backend
change	````
dock	`doc`
explain	`explain`
fix	`fix`
test	`tests`

`user.css_at_rule`

List: {user.css_at_rule}>

Spoken	Backend
charset	`charset`
font face	`font-face`
import	`import`
keyframes	`keyframes`
media	`media`
namespace	`namespace`
page	`page`
supports	`supports`
value	`value`

`user.css_global_value`

List: {user.css_global_value}>

Spoken	Backend
inherit	`inherit`
initial	`initial`
revert	`revert`
unset	`unset`

`user.css_unit`

List: {user.css_unit}>

Spoken	Backend
char	`ch`
degrees	`deg`
dots per pixel	`dppx`
em	`em`
fraction	`fr`
millis	`ms`
pixels	`px`
points	`pt`
radians	`rad`
rem	`rem`
seconds	`s`
turn	`turn`
view height	`vh`
view width	`vw`

`user.currency`

List: {user.currency}>

Spoken	Backend
dollar	`$`
dollars	`$`
euro	`€`
euros	`€`
pound	`£`
pounds	`£`

`user.delimiter_pair`

List: {user.delimiter_pair}>

Spoken	Backend
box	`[ ]`
curly	`{ }`
diamond	`< >`
escaped box	`\[ \]`
escaped quad	`\" \"`
escaped round	``
escaped twin	`\' \'`
pad	`space space`
percentages	`% %`
quad	`" "`
round	`( )`
skis
twin	`' '`

`user.edit_action`

List: {user.edit_action}>

Spoken	Backend
clear	`delete`
copy	`copyToClipboard`
cut	`cutToClipboard`
go after	`goAfter`
go before	`goBefore`
paste	`pasteFromClipboard`
paste to	`pasteFromClipboard`
select	`select`

`user.edit_modifier`

List: {user.edit_modifier}>

Spoken	Backend
all	`document`
file end	`fileEnd`
file start	`fileStart`
line	`line`
line end	`lineEnd`
line start	`lineStart`
paragraph	`paragraph`
way down	`fileEnd`
way left	`lineStart`
way right	`lineEnd`
way up	`fileStart`

`user.edit_modifier_repeatable`

List: {user.edit_modifier_repeatable}>

Spoken	Backend
down	`lineDown`
left	`left`
right	`right`
up	`lineUp`
word	`word`
word left	`wordLeft`
word right	`wordRight`

`user.edit_text_file`

List: {user.edit_text_file}>

Spoken	Backend
abbreviations	`settings/abbreviations.csv`
additional words	`core/vocabulary/vocabulary.talon-list`
alphabet	`core/keys/letter.talon-list`
contacts csv	`private/contacts.csv`
contacts json	`private/contacts.json`
file extensions	`settings/file_extensions.csv`
homophones	`core/homophones/homophones.csv`
search engines	`core/websites_and_search_engines/search_engine.talon-list`
unix utilities	`tags/terminal/unix_utility.talon-list`
vocabulary	`core/vocabulary/vocabulary.talon-list`
websites	`core/websites_and_search_engines/website.talon-list`
words to replace	`settings/words_to_replace.csv`

`user.emacs_command`

List: {user.emacs_command}>

Spoken	Backend
abort recursive edit	`abort-recursive-edit`
auto fill mode	`auto-fill-mode`
backward paragraph	`backward-paragraph`
backward sentence	`backward-sentence`
backward sexp	`backward-sexp`
backward up list	`backward-up-list`
backward word	`backward-word`
balance windows	`balance-windows`
beginning of buffer	`beginning-of-buffer`
browse kill ring	`browse-kill-ring`
buffer menu	`buffer-menu`
bury buffer	`bury-buffer`
byte compile file	`byte-compile-file`
byte recompile directory	`byte-recompile-directory`
byte recompile file	`byte-recompile-file`
clear rectangle	`clear-rectangle`
clone indirect buffer	`clone-indirect-buffer`
comment dwim	`comment-dwim`
comment line	`comment-line`
comment region	`comment-region`
compile	`compile`
compile defun	`compile-defun`
copy rectangle as kill	`copy-rectangle-as-kill`
copy rectangle to register	`copy-rectangle-to-register`
copy to register	`copy-to-register`
custom theme visit theme	`custom-theme-visit-theme`
customize face	`customize-face`
customize group	`customize-group`
customize variable	`customize-variable`
delete other windows	`delete-other-windows`
delete rectangle	`delete-rectangle`
delete window	`delete-window`
describe character	`describe-character`
diff buffer with file	`diff-buffer-with-file`
dired jump	`dired-jump`
dired jump other window	`dired-jump-other-window`
display buffer	`display-buffer`
display line numbers mode	`display-line-numbers-mode`
down list	`down-list`
electric quote local mode	`electric-quote-local-mode`
electric quote mode	`electric-quote-mode`
end of buffer	`end-of-buffer`
enlarge window	`enlarge-window`
enlarge window horizontally	`enlarge-window-horizontally`
eval expression	`eval-expression`
eval print last sexp	`eval-print-last-sexp`
eval region	`eval-region`
exchange point and mark	`exchange-point-and-mark`
execute extended command	`execute-extended-command`
fileloop continue	`fileloop-continue`
fill paragraph	`fill-paragraph`
find file	`find-file`
font lock update	`font-lock-update`
forward paragraph	`forward-paragraph`
forward sentence	`forward-sentence`
forward sexp	`forward-sexp`
forward word	`forward-word`
fundamental mode	`fundamental-mode`
global display line numbers mode	`global-display-line-numbers-mode`
global hl line mode	`global-hl-line-mode`
global visual line mode	`global-visual-line-mode`
goto line	`goto-line`
highlight lines matching regexp	`highlight-lines-matching-regexp`
highlight phrase	`highlight-phrase`
highlight regexp	`highlight-regexp`
hl line mode	`hl-line-mode`
indent region	`indent-region`
indent rigidly	`indent-rigidly`
insert char	`insert-char`
insert register	`insert-register`
isearch backward	`isearch-backward`
isearch backward regexp	`isearch-backward-regexp`
isearch forward	`isearch-forward`
isearch forward regexp	`isearch-forward-regexp`
isearch forward symbol	`isearch-forward-symbol`
isearch forward word	`isearch-forward-word`
jump to register	`jump-to-register`
keyboard quit	`keyboard-quit`
kill buffer	`kill-buffer`
kill line	`kill-line`
kill paragraph	`kill-paragraph`
kill rectangle	`kill-rectangle`
kill region	`kill-region`
kill ring save	`kill-ring-save`
kill sentence	`kill-sentence`
kill sexp	`kill-sexp`
kill word	`kill-word`
kmacro end and call macro	`kmacro-end-and-call-macro`
kmacro end macro	`kmacro-end-macro`
kmacro start macro	`kmacro-start-macro`
list packages	`list-packages`
make frame command	`make-frame-command`
mark paragraph	`mark-paragraph`
mark sexp	`mark-sexp`
mark whole buffer	`mark-whole-buffer`
move beginning of line	`move-beginning-of-line`
move end of line	`move-end-of-line`
narrow to region	`narrow-to-region`
next buffer	`next-buffer`
next error	`next-error`
occur	`occur`
open rectangle	`open-rectangle`
other frame	`other-frame`
other window	`other-window`
outline backward same level	`outline-backward-same-level`
outline demote	`outline-demote`
outline forward same level	`outline-forward-same-level`
outline hide body	`outline-hide-body`
outline hide entry	`outline-hide-entry`
outline hide leaves	`outline-hide-leaves`
outline hide other	`outline-hide-other`
outline hide sublevels	`outline-hide-sublevels`
outline hide subtree	`outline-hide-subtree`
outline insert heading	`outline-insert-heading`
outline mark subtree	`outline-mark-subtree`
outline move subtree down	`outline-move-subtree-down`
outline move subtree up	`outline-move-subtree-up`
outline next visible heading	`outline-next-visible-heading`
outline previous visible heading	`outline-previous-visible-heading`
outline promote	`outline-promote`
outline show all	`outline-show-all`
outline show branches	`outline-show-branches`
outline show children	`outline-show-children`
outline show entry	`outline-show-entry`
outline show subtree	`outline-show-subtree`
outline up heading	`outline-up-heading`
overwrite mode	`overwrite-mode`
package autoremove	`package-autoremove`
pop global mark	`pop-global-mark`
pop to mark command	`pop-to-mark-command`
previous buffer	`previous-buffer`
previous error	`previous-error`
project find file	`project-find-file`
project find regexp	`project-find-regexp`
project query replace regexp	`project-query-replace-regexp`
project search	`project-search`
project switch project	`project-switch-project`
project vc dir	`project-vc-dir`
projectile compile project	`projectile-compile-project`
projectile dired	`projectile-dired`
projectile kill buffers	`projectile-kill-buffers`
projectile run async shell command in root	`projectile-run-async-shell-command-in-root`
projectile run eshell	`projectile-run-eshell`
projectile run shell	`projectile-run-shell`
projectile run shell command in root	`projectile-run-shell-command-in-root`
projectile switch to buffer	`projectile-switch-to-buffer`
query replace	`query-replace`
query replace regexp	`query-replace-regexp`
read only mode	`read-only-mode`
recenter top bottom	`recenter-top-bottom`
rectangle number lines	`rectangle-number-lines`
rename buffer	`rename-buffer`
rename uniquely	`rename-uniquely`
reverse region	`reverse-region`
revert buffer	`revert-buffer`
revert buffer quick	`revert-buffer-quick`
save buffer	`save-buffer`
save buffers kill emacs	`save-buffers-kill-emacs`
save some buffers	`save-some-buffers`
scroll other window	`scroll-other-window`
scroll other window down	`scroll-other-window-down`
server edit	`server-edit`
set mark command	`set-mark-command`
sh mode	`sh-mode`
shell command	`shell-command`
shell command on region	`shell-command-on-region`
shell script mode	`shell-script-mode`
shrink window horizontally	`shrink-window-horizontally`
shrink window if larger than buffer	`shrink-window-if-larger-than-buffer`
smerge combine with next	`smerge-combine-with-next`
smerge diff base lower	`smerge-diff-base-lower`
smerge diff base upper	`smerge-diff-base-upper`
smerge diff upper lower	`smerge-diff-upper-lower`
smerge ediff	`smerge-ediff`
smerge keep all	`smerge-keep-all`
smerge keep base	`smerge-keep-base`
smerge keep current	`smerge-keep-current`
smerge keep lower	`smerge-keep-lower`
smerge keep upper	`smerge-keep-upper`
smerge next	`smerge-next`
smerge prev	`smerge-prev`
smerge refine	`smerge-refine`
smerge resolve	`smerge-resolve`
sort lines	`sort-lines`
sort words	`sort-words`
split window below	`split-window-below`
split window right	`split-window-right`
switch to buffer	`switch-to-buffer`
switch to buffer other window	`switch-to-buffer-other-window`
tab bar mode	`tab-bar-mode`
tab close	`tab-close`
tab close other	`tab-close-other`
tab new	`tab-new`
tab next	`tab-next`
tab previous	`tab-previous`
tab undo	`tab-undo`
text mode	`text-mode`
toggle debug on error	`toggle-debug-on-error`
toggle debug on quit	`toggle-debug-on-quit`
toggle input method	`toggle-input-method`
toggle truncate lines	`toggle-truncate-lines`
toggle word wrap	`toggle-word-wrap`
transient mark mode	`transient-mark-mode`
transpose chars	`transpose-chars`
transpose lines	`transpose-lines`
transpose paragraphs	`transpose-paragraphs`
transpose sentences	`transpose-sentences`
transpose sexps	`transpose-sexps`
transpose words	`transpose-words`
undo	`undo`
unhighlight regexp	`unhighlight-regexp`
universal argument	`universal-argument`
vc annotate	`vc-annotate`
view lossage	`view-lossage`
visit tags table	`visit-tags-table`
visual line mode	`visual-line-mode`
whitespace cleanup	`whitespace-cleanup`
whitespace mode	`whitespace-mode`
widen	`widen`
xref find apropos	`xref-find-apropos`
xref find definitions	`xref-find-definitions`
xref find definitions other frame	`xref-find-definitions-other-frame`
xref find definitions other window	`xref-find-definitions-other-window`
xref find references	`xref-find-references`
xref find references and replace	`xref-find-references-and-replace`
xref go back	`xref-go-back`
yank	`yank`
yank rectangle	`yank-rectangle`

`user.emoji`

List: {user.emoji}>

Spoken	Backend
angry	`😠`
blushing	`😊`
broken heart	`💔`
clapping	`👏`
cool	`😎`
crying	`😭`
dancing	`💃`
disappointed	`😞`
eyes	`👀`
grimacing	`😬`
happy	`😀`
heart	`❤`
heart eyes	`😍`
hugging	`🤗`
kissing	`😗`
monocle	`🧐`
party	`🎉`
pleading	`🥺`
poop	`💩`
pray	`🙏`
red flag	`🚩`
rofl	`🤣`
roll eyes	`🙄`
sad	`🙁`
see no evil	`🙈`
shrugging	`🤷`
shushing	`🤫`
star eyes	`🤩`
sweat smile	`😅`
thinking	`🤔`
thumbs down	`👎`
thumbs up	`👍`
warning	`⚠️`
worried	`😟`

`user.emoticon`

List: {user.emoticon}>

Spoken	Backend
broken heart	`</3`
cheeky	`:p`
cheering	`\o/`
crying	`:'(`
happy	`:)`
heart	`<3`
horror	`D:`
laughing	`:D`
sad	`:(`
salute	`o7`
skeptical	`:/`
surprised	`:o`
wink	`;)`

`user.file_extension`

List: {user.file_extension}>

Spoken	Backend
dot j l	`.jl`
dot j s	`.js`
dot ts	`.ts`
dot u s	`.us`
dot bend	`.bin`
dot bin	`.bin`
dot cassie	`.csv`
dot class	`.class`
dot co dot uk	`.co.uk`
dot com	`.com`
dot css	`.css`
dot csv	`.csv`
dot doc	`.doc`
dot doc x	`.docx`
dot exe	`.exe`
dot flack	`.flac`
dot g z	`.gz`
dot g zip	`.gzip`
dot html	`.html`
dot jason	`.json`
dot java	`.java`
dot java script	`.js`
dot jay son	`.json`
dot julia	`.jl`
dot log	`.log`
dot mark down	`.md`
dot net	`.net`
dot nix	`.nix`
dot org	`.org`
dot pdf	`.pdf`
dot pie	`.py`
dot png	`.png`
dot sass	`.sass`
dot see	`.c`
dot see sharp	`.cs`
dot shell	`.sh`
dot svg	`.svg`
dot talon	`.talon`
dot tar	`.tar`
dot text	`.txt`
dot toml	`.toml`
dot type script	`.ts`
dot us	`.us`
dot vim	`.vim`
dot wave	`.wav`
dot zip	`.zip`
tot csv	`.csv`
totssv	`.csv`

`user.function_key`

List: {user.function_key}>

Spoken	Backend
f eight	`f8`
f eighteen	`f18`
f eleven	`f11`
f fifteen	`f15`
f five	`f5`
f four	`f4`
f fourteen	`f14`
f nine	`f9`
f nineteen	`f19`
f one	`f1`
f seven	`f7`
f seventeen	`f17`
f six	`f6`
f sixteen	`f16`
f ten	`f10`
f thirteen	`f13`
f three	`f3`
f twelve	`f12`
f twenty	`f20`
f two	`f2`

`user.git_argument`

List: {user.git_argument}>

Spoken	Backend
head	`HEAD`
abort	`--abort`
all	`--all`
allow empty	`--allow-empty`
amend	`--amend`
branch	`-b`
cached	`--cached`
cashed	`--cached`
color words	`--color-words`
colour words	`--color-words`
combined	`-c`
continue	`--continue`
copy	`--copy`
create	`--create`
deep	`-d`
delete	`--delete`
detach	`--detach`
dir diff	`--dir-diff`
directory diff	`--dir-diff`
dry run	`--dry-run`
edit	`--edit`
fast forward only	`--ff-only`
force	`--force`
force create	`--force-create`
force with lease	`--force-with-lease`
global	`--global`
hard	`--hard`
ignore case	`--ignore-case`
include untracked	`--include-untracked`
interactive	`--interactive`
keep index	`--keep-index`
list	`--list`
local	`--local`
main	`main`
master	`master`
mixed	`--mixed`
move	`--move`
no edit	`--no-edit`
no keep index	`--no-keep-index`
no rebase	`--no-rebase`
no track	`--no-track`
no verify	`--no-verify`
origin	`origin`
origin main	`origin/main`
origin master	`origin/master`
orphan	`--orphan`
patch	`--patch`
prune	`--prune`
quiet	`--quiet`
quit	`--quit`
rebase	`--rebase`
remote	`--remote`
set up stream	`--set-upstream`
set up stream to	`--set-upstream-to`
short	`--short`
short stat	`--shortstat`
skip	`--skip`
soft	`--soft`
staged	`--staged`
stat	`--stat`
system	`--system`
track	`--track`
update	`--update`
upstream	`upstream`
verbose	`--verbose`
very verbose	`-vv`

`user.git_command`

List: {user.git_command}>

Spoken	Backend
add	`add`
archive	`archive`
bisect	`bisect`
blame	`blame`
branch	`branch`
checkout	`checkout`
cherry pick	`cherry-pick`
clean	`clean`
clone	`clone`
commit	`commit`
config	`config`
diff	`diff`
diff tool	`difftool`
fetch	`fetch`
gc	`gc`
grep	`grep`
help	`help`
in it	`init`
log	`log`
ls files	`ls-files`
merge	`merge`
merge tool	`mergetool`
move	`mv`
pull	`pull`
push	`push`
range diff	`range-diff`
rebase	`rebase`
ref log	`reflog`
remote	`remote`
remote add	`remote add`
remote remove	`remote remove`
remote rename	`remote rename`
remote set url	`remote set-url`
remote set you are el	`remote set-url`
remote show	`remote show`
remove	`rm`
rerere	`rerere`
rerere diff	`rerere diff`
rerere status	`rerere status`
reset	`reset`
restore	`restore`
revert	`revert`
short log	`shortlog`
show	`show`
sparse checkout	`sparse-checkout`
stash	`stash`
stash apply	`stash apply`
stash list	`stash list`
stash pop	`stash pop`
stash push	`stash push`
stash save	`stash save`
stash show	`stash show`
status	`status`
submodule	`submodule`
submodule add	`submodule add`
submodule in it	`submodule init`
submodule status	`submodule status`
submodule update	`submodule update`
switch	`switch`
tag	`tag`
worktree	`worktree`
worktree add	`worktree add`
worktree list	`worktree list`
worktree lock	`worktree lock`
worktree move	`worktree move`
worktree prune	`worktree prune`
worktree remove	`worktree remove`
worktree repair	`worktree repair`
worktree unlock	`worktree unlock`

`user.help_contexts`

List: {user.help_contexts}>

Spoken	Backend
c s s	`user.community.lang.css.css.talon`
g i t	`user.community.apps.git.git.talon`
g o	`user.community.lang.go.go.talon`
g p t	`user.talon-ai-tools.GPT.gpt.talon`
l u a	`user.community.lang.lua.lua.talon`
p h p	`user.community.lang.php.php.talon`
s q l	`user.community.lang.sql.sql.talon`
w s l	`user.community.apps.wsl.wsl.talon`
address	`user.community.tags.address.address.talon`
ai images	`user.talon-ai-tools.Images.ai-images.talon`
amethyst	`user.community.apps.amethyst.amethyst.talon`
anaconda	`user.community.apps.anaconda.anaconda.talon`
anki	`user.my-overrides.community.apps.anki.talon`
apple notes	`user.community.apps.apple_notes.apple_notes.talon`
apple terminal	`user.community.apps.apple_terminal.apple_terminal.talon`
are you sure	`user.community.plugin.are_you_sure.are_you_sure.talon`
bash	`user.my-overrides.community.apps.bash.bash.talon`
batch	`user.community.lang.batch.batch.talon`
browser	`user.community.tags.browser.browser.talon`
c	`user.community.lang.c.c.talon`
cancel	`user.community.plugin.cancel.cancel.talon`
chapters	`user.community.tags.chapters.chapters.talon`
cheatsheet	`user.cheatsheet.cheatsheet.talon`
chrome	`user.community.apps.chrome.chrome.talon`
codeium	`user.talon-ai-tools.copilot.codeium.talon`
command and dictation mode	`user.community.core.modes.command_and_dictation_mode.talon`
command history	`user.community.plugin.command_history.command_history.talon`
command mode shortcuts	`user.my-overrides.community.command-mode-shortcuts.talon`
command search	`user.community.tags.command_search.command_search.talon`
comment block	`user.community.lang.tags.comment_block.talon`
comment documentation	`user.community.lang.tags.comment_documentation.talon`
comment line	`user.community.lang.tags.comment_line.talon`
community aliases awake	`user.my-overrides.community.aliases.community-aliases-awake.talon`
community aliases global	`user.my-overrides.community.aliases.community-aliases-global.talon`
continue	`user.talon-ai-tools.copilot.continue.talon`
continuous scrolling	`user.community.plugin.mouse.continuous_scrolling.talon`
copilot	`user.talon-ai-tools.copilot.copilot.talon`
css	`user.community.lang.css.css.talon`
cursorless	`user.cursorless-talon.src.cursorless.talon`
cursorless global	`user.cursorless-talon.src.cursorless_global.talon`
data bool	`user.community.lang.tags.data_bool.talon`
data boolean	`user.community.lang.tags.data_bool.talon`
data null	`user.community.lang.tags.data_null.talon`
datetimeinsert	`user.community.plugin.datetimeinsert.datetimeinsert.talon`
debugger	`user.community.tags.debugger.debugger.talon`
desktops	`user.community.plugin.desktops.desktops.talon`
dictation mode	`user.community.core.modes.dictation_mode.talon`
direct clicking	`user.rango.src.modes.direct_clicking.talon`
discord	`user.community.apps.discord.discord.talon`
dock	`user.community.apps.dock.dock.talon`
draft editor	`user.community.plugin.draft_editor.draft_editor.talon`
draft editor open	`user.community.plugin.draft_editor.draft_editor_open.talon`
draft global	`user.community.plugin.talon_draft_window.draft_global.talon`
draft window	`user.community.plugin.talon_draft_window.draft_window.talon`
draft window open	`user.community.plugin.talon_draft_window.draft_window_open.talon`
dragon mode	`user.community.core.modes.dragon_mode.talon`
dropdown	`user.community.plugin.dropdown.dropdown.talon`
dunst	`user.community.apps.dunst.dunst.talon`
eclipse	`user.community.apps.eclipse.eclipse.talon`
edit	`user.community.core.edit.edit.talon`
edit text file	`user.community.core.edit_text_file.edit_text_file.talon`
edit vocabulary	`user.community.core.vocabulary.edit_vocabulary.talon`
elixir	`user.community.lang.elixir.elixir.talon`
emacs	`user.community.apps.emacs.emacs.talon`
emoji	`user.community.tags.emoji.emoji.talon`
file extension	`user.community.core.file_extension.file_extension.talon`
file manager	`user.community.tags.file_manager.file_manager.talon`
file manager win	`user.community.tags.file_manager.file_manager_win.talon`
file manager window	`user.community.tags.file_manager.file_manager_win.talon`
find	`user.community.tags.find.find.talon`
find and replace	`user.community.tags.find_and_replace.find_and_replace.talon`
finder	`user.community.apps.finder.finder.talon`
firefox	`user.my-overrides.community.apps.firefox.talon`
foxit reader	`user.community.apps.foxit_reader.foxit_reader.talon`
functions	`user.community.lang.tags.functions.talon`
functions common	`user.community.lang.tags.functions_common.talon`
functions common gui active	`user.community.lang.tags.functions_common_gui_active.talon`
gamepad tester	`user.community.plugin.gamepad.gamepad_tester.talon`
gdb active	`user.community.apps.gdb.gdb_active.talon`
gdb global	`user.community.apps.gdb.gdb_global.talon`
git	`user.community.apps.git.git.talon`
git add patch	`user.community.apps.git.git_add_patch.talon`
github web	`user.community.apps.github.github_web.talon`
gitlab	`user.community.apps.gitlab.gitlab.talon`
go	`user.community.lang.go.go.talon`
gpt	`user.talon-ai-tools.GPT.gpt.talon`
gpt confirmation gui	`user.talon-ai-tools.GPT.gpt-confirmation-gui.talon`
gpt cursorless	`user.talon-ai-tools.GPT.gpt-cursorless.talon`
gpt shell	`user.talon-ai-tools.GPT.gpt-shell.talon`
gpt with context	`user.talon-ai-tools.GPT.gpt-with-context.talon`
help	`user.community.core.help.help.talon`
help open	`user.community.core.help.help_open.talon`
help scope open	`user.community.core.help.help_scope_open.talon`
homophones	`user.community.core.homophones.homophones.talon`
homophones open	`user.community.core.homophones.homophones_open.talon`
hud choice commands	`user.talon_hud.hud_choice_commands.talon`
hud commands	`user.talon_hud.hud_commands.talon`
hud content focus	`user.talon_hud.content.hud_content_focus.talon`
hud content toolkit	`user.talon_hud.content.hud_content_toolkit.talon`
hud content walkthrough	`user.talon_hud.content.hud_content_walkthrough.talon`
hud widget quick choices	`user.talon_hud.hud_widget_quick_choices.talon`
i three wm	`user.community.apps.i3wm.i3wm.talon`
imperative	`user.community.lang.tags.imperative.talon`
java	`user.community.lang.java.java.talon`
javascript	`user.community.lang.javascript.javascript.talon`
jetbrains	`user.community.apps.jetbrains.jetbrains.talon`
joplin	`user.my-overrides.community.apps.joplin.talon`
keepass	`user.my-overrides.community.tags.keepass.keepass.talon`
keepassx linux	`user.community.apps.keepassx.keepassx_linux.talon`
keys	`user.community.core.keys.keys.talon`
keywords	`user.community.lang.tags.keywords.talon`
kubectl	`user.community.apps.kubectl.kubectl.talon`
language modes	`user.community.core.modes.language_modes.talon`
libraries	`user.community.lang.tags.libraries.talon`
line commands	`user.community.tags.line_commands.line_commands.talon`
little arc mac	`user.community.apps.arc.little-arc_mac.talon`
lua	`user.community.lang.lua.lua.talon`
macro	`user.community.plugin.macro.macro.talon`
markdown	`user.community.lang.markdown.markdown.talon`
media	`user.community.plugin.media.media.talon`
meld	`user.community.apps.meld.meld.talon`
menu choose	`user.community.core.menu_choose.menu_choose.talon`
messaging	`user.community.tags.messaging.messaging.talon`
microphone selection	`user.community.plugin.microphone_selection.microphone_selection.talon`
mint	`user.my-overrides.distro-specific.mint.talon`
modes dragon	`user.community.core.modes.modes_dragon.talon`
modes not dragon	`user.community.core.modes.modes_not_dragon.talon`
mouse	`user.community.plugin.mouse.mouse.talon`
mouse cursor	`user.community.plugin.mouse.mouse_cursor.talon`
mouse grid	`user.community.core.mouse_grid.mouse_grid.talon`
mouse grid always	`user.community.core.mouse_grid.mouse_grid_always.talon`
mouse grid open	`user.community.core.mouse_grid.mouse_grid_open.talon`
multiple cursors	`user.community.tags.multiple_cursors.multiple_cursors.talon`
navigation	`user.community.core.navigation.navigation.talon`
numbers prefixed	`user.community.core.numbers.numbers_prefixed.talon`
numbers unprefixed	`user.community.core.numbers.numbers_unprefixed.talon`
object oriented	`user.community.lang.tags.object_oriented.talon`
one password	`user.community.apps.1password.1password.talon`
one password global	`user.community.apps.1password.1password_global.talon`
operators	`user.community.lang.tags.operators.talon`
operators assignment deprecations	`user.community.lang.tags.operators_assignment_deprecations.talon`
operators bitwise deprecations	`user.community.lang.tags.operators_bitwise_deprecations.talon`
operators math deprecations	`user.community.lang.tags.operators_math_deprecations.talon`
orion	`user.community.apps.orion.orion.talon`
outlook web	`user.community.apps.outlook.outlook_web.talon`
outlook win	`user.community.apps.outlook.outlook_win.talon`
outlook window	`user.community.apps.outlook.outlook_win.talon`
pages	`user.community.tags.pages.pages.talon`
php	`user.community.lang.php.php.talon`
proto	`user.community.lang.proto.proto.talon`
protocol	`user.community.lang.proto.proto.talon`
protonmail	`user.community.apps.protonmail.protonmail.talon`
python	`user.community.lang.python.python.talon`
r	`user.community.lang.r.r.talon`
rango	`user.rango.src.rango.talon`
repeater	`user.community.plugin.repeater.repeater.talon`
rstudio mac	`user.community.apps.rstudio.rstudio_mac.talon`
ruby	`user.community.lang.ruby.ruby.talon`
rust	`user.community.lang.rust.rust.talon`
scala	`user.community.lang.scala.scala.talon`
screens	`user.community.core.screens.screens.talon`
screenshot	`user.community.plugin.screenshot.screenshot.talon`
see s s	`user.community.lang.css.css.talon`
sequel	`user.community.lang.sql.sql.talon`
signal linux	`user.community.apps.signal.signal_linux.talon`
slack	`user.community.apps.slack.slack.talon`
slack linux	`user.my-overrides.community.apps.slack.slack_linux.talon`
sleep mode	`user.community.core.modes.sleep_mode.talon`
sleep mode wav two letter	`user.community.core.modes.sleep_mode_wav2letter.talon`
sleep mode wave two letter	`user.community.core.modes.sleep_mode_wav2letter.talon`
snippets	`user.community.core.snippets.snippets.talon`
splits	`user.community.tags.splits.splits.talon`
sql	`user.community.lang.sql.sql.talon`
stata	`user.community.lang.stata.stata.talon`
stata do file editor	`user.community.apps.stata.stata_do_file_editor.talon`
stylua	`user.community.lang.lua.stylua.talon`
symbols	`user.community.plugin.symbols.symbols.talon`
symbols deprecated	`user.community.plugin.symbols.symbols_deprecated.talon`
tabs	`user.community.core.windows_and_tabs.tabs.talon`
talon	`user.community.lang.talon.talon.talon`
talon common	`user.community.lang.talon.talon_common.talon`
talon context	`user.community.lang.talon.talon_context.talon`
talon debug window	`user.community.apps.talon.talon_debug_window.talon_debug_window.talon`
talon helpers	`user.rango.src.talon_helpers.talon`
talon list	`user.community.lang.talon.talon-list.talon`
talon repel	`user.community.apps.talon.talon_repl.talon_repl.talon`
talon repl	`user.community.apps.talon.talon_repl.talon_repl.talon`
taskwarrior linux	`user.community.apps.taskwarrior.taskwarrior_linux.talon`
teams	`user.community.apps.teams.teams.talon`
teams mac	`user.community.apps.teams.teams_mac.talon`
term basics	`user.my-overrides.community.tags.terminal.term_basics.talon`
term docker	`user.my-overrides.community.tags.terminal.term_docker.talon`
term git	`user.my-overrides.community.tags.terminal.term_git.talon`
term talon	`user.my-overrides.community.tags.terminal.term_talon.talon`
term utils	`user.my-overrides.community.tags.terminal.term_utils.talon`
terminal	`user.community.tags.terminal.terminal.talon`
terminal basics	`user.my-overrides.community.tags.terminal.term_basics.talon`
terminal docker	`user.my-overrides.community.tags.terminal.term_docker.talon`
terminal git	`user.my-overrides.community.tags.terminal.term_git.talon`
terminal talon	`user.my-overrides.community.tags.terminal.term_talon.talon`
terminal utilities	`user.my-overrides.community.tags.terminal.term_utils.talon`
termite	`user.community.apps.termite.termite.talon`
terraform	`user.community.lang.terraform.terraform.talon`
text	`user.community.core.text.text.talon`
text navigation	`user.community.plugin.text_navigation.text_navigation.talon`
then	`user.community.plugin.then.then.talon`
thunderbird	`user.community.apps.thunderbird.thunderbird.talon`
thunderbird calendar	`user.community.apps.thunderbird.thunderbird_calendar.talon`
thunderbird composer	`user.community.apps.thunderbird.thunderbird_composer.talon`
thunderbird contacts	`user.community.apps.thunderbird.thunderbird_contacts.talon`
thunderbird inbox	`user.community.apps.thunderbird.thunderbird_inbox.talon`
thunderbird tasks	`user.community.apps.thunderbird.thunderbird_tasks.talon`
tmux	`user.my-overrides.community.apps.tmux.tmux.talon`
tmux linux	`user.my-overrides.community.apps.tmux.tmux_linux.talon`
twitter	`user.community.apps.twitter.twitter.talon`
typescript	`user.community.lang.typescript.typescript.talon`
ubuntu	`user.my-overrides.distro-specific.ubuntu.talon`
unix utilities	`user.community.tags.terminal.unix_utilities.talon`
vikunja	`user.my-overrides.community.websites.vikunja.talon`
vimscript	`user.community.lang.vimscript.vimscript.talon`
visual studio	`user.community.apps.visualstudio.visual_studio.talon`
vivaldi	`user.community.apps.vivaldi.vivaldi.talon`
vscode	`user.my-overrides.community.apps.vscode.talon`
websites and search engines	`user.community.core.websites_and_search_engines.websites_and_search_engines.talon`
windbg	`user.community.apps.windbg.windbg.talon`
window layout	`user.community.core.windows_and_tabs.window_layout.talon`
window management	`user.community.core.windows_and_tabs.window_management.talon`
windows explorer	`user.community.apps.windows_explorer.windows_explorer.talon`
windows terminal	`user.community.apps.windows_terminal.windows_terminal.talon`
wsl	`user.community.apps.wsl.wsl.talon`
xournalpp	`user.my-overrides.community.apps.xournalpp.talon`
youtube	`user.my-overrides.community.websites.youtube.talon`

`user.homophones_canonicals`

List: {user.homophones_canonicals}>

Spoken	Backend
aaron	`Aaron`
adam	`Adam`
babel	`Babel`
cain	`Cain`
chile	`Chile`
cyprus	`Cyprus`
dane	`Dane`
greece	`Greece`
hugh	`Hugh`
i	`I`
i'd	`I'd`
i'll	`I'll`
jim	`Jim`
lou	`Lou`
mary	`Mary`
mrs	`Mrs`
nice	`Nice`
paul	`Paul`
pete	`Pete`
phil	`Phil`
rome	`Rome`
russell	`Russell`
sunday	`Sunday`
tigris	`Tigris`
venus	`Venus`
wales	`Wales`
wayne	`Wayne`
able	`able`
acclamation	`acclamation`
acts	`acts`
add	`add`
addition	`addition`
adds	`adds`
adduce	`adduce`
adherence	`adherence`
ado	`ado`
aerial	`aerial`
affected	`affected`
afterward	`afterward`
aid	`aid`
air	`air`
ale	`ale`
align	`align`
all	`all`
allowed	`allowed`
alluded	`alluded`
alter	`alter`
analyst	`analyst`
appetite	`appetite`
apprize	`apprize`
arc	`arc`
ascent	`ascent`
assistance	`assistance`
attendance	`attendance`
augur	`augur`
aunt	`aunt`
away	`away`
axis	`axis`
axle	`axle`
bad	`bad`
bah	`bah`
bail	`bail`
bait	`bait`
baited	`baited`
bald	`bald`
ball	`ball`
band	`band`
baron	`baron`
barred	`barred`
barrel	`barrel`
base	`base`
based	`based`
baseline	`baseline`
basil	`basil`
basis	`basis`
basque	`basque`
be	`be`
beach	`beach`
bear	`bear`
beat	`beat`
been	`been`
beer	`beer`
beetle	`beetle`
bell	`bell`
better	`better`
bib	`bib`
bird	`bird`
birth	`birth`
bite	`bite`
bizarre	`bizarre`
block	`block`
blue	`blue`
board	`board`
bold	`bold`
bomb	`bomb`
booty	`booty`
border	`border`
bore	`bore`
born	`born`
borough	`borough`
bought	`bought`
boulder	`boulder`
bow	`bow`
bowed	`bowed`
boy	`boy`
braid	`braid`
brays	`brays`
breach	`breach`
bread	`bread`
break	`break`
brewed	`brewed`
brews	`brews`
bridal	`bridal`
broach	`broach`
browse	`browse`
brute	`brute`
build	`build`
bullion	`bullion`
burger	`burger`
bury	`bury`
bust	`bust`
but	`but`
by	`by`
cached	`cached`
caches	`caches`
caching	`caching`
caddy	`caddy`
calendar	`calendar`
callous	`callous`
cannon	`cannon`
cantor	`cantor`
canvas	`canvas`
capital	`capital`
carol	`carol`
carrot	`carrot`
cash	`cash`
cast	`cast`
caster	`caster`
cause	`cause`
cedar	`cedar`
ceiling	`ceiling`
chance	`chance`
chased	`chased`
chauffeur	`chauffeur`
cheap	`cheap`
check	`check`
chic	`chic`
choir	`choir`
choose	`choose`
cited	`cited`
clack	`clack`
clammer	`clammer`
clause	`clause`
click	`click`
climb	`climb`
close	`close`
clue	`clue`
coal	`coal`
coarser	`coarser`
coat	`coat`
coax	`coax`
collared	`collared`
complacent	`complacent`
complement	`complement`
conceded	`conceded`
consonants	`consonants`
consul	`consul`
continents	`continents`
cops	`cops`
coral	`coral`
cord	`cord`
core	`core`
coughers	`coughers`
coulee	`coulee`
council	`council`
coup	`coup`
coupe	`coupe`
course	`course`
cousin	`cousin`
coward	`coward`
coy	`coy`
craft	`craft`
crawl	`crawl`
creek	`creek`
crepe	`crepe`
cruel	`cruel`
cruise	`cruise`
current	`current`
cursor	`cursor`
damn	`damn`
days	`days`
dear	`dear`
dense	`dense`
descent	`descent`
die	`die`
diffused	`diffused`
discrete	`discrete`
disperse	`disperse`
do	`do`
doc	`doc`
does	`does`
done	`done`
draft	`draft`
dual	`dual`
ducked	`ducked`
ducks	`ducks`
dying	`dying`
earn	`earn`
effect	`effect`
effects	`effects`
eight	`eight`
eke	`eke`
elude	`elude`
elusive	`elusive`
emend	`emend`
end	`end`
ensure	`ensure`
errant	`errant`
eve	`eve`
exceed	`exceed`
except	`except`
excepting	`excepting`
exercise	`exercise`
eyes	`eyes`
facts	`facts`
faint	`faint`
fair	`fair`
fairy	`fairy`
fawn	`fawn`
feet	`feet`
fens	`fens`
fete	`fete`
few	`few`
find	`find`
finish	`finish`
fish	`fish`
fished	`fished`
fisher	`fisher`
fishing	`fishing`
flare	`flare`
flee	`flee`
flew	`flew`
flocks	`flocks`
flow	`flow`
flower	`flower`
flyer	`flyer`
foe	`foe`
fold	`fold`
for	`for`
foregone	`foregone`
fort	`fort`
forward	`forward`
foul	`foul`
fourth	`fourth`
frank	`frank`
freeze	`freeze`
friar	`friar`
fur	`fur`
gaffe	`gaffe`
gale	`gale`
gamble	`gamble`
gate	`gate`
gator	`gator`
gauge	`gauge`
gel	`gel`
gene	`gene`
gilder	`gilder`
gnome	`gnome`
gopher	`gopher`
gorilla	`gorilla`
gourd	`gourd`
grade	`grade`
graft	`graft`
graham	`graham`
graze	`graze`
great	`great`
greater	`greater`
grill	`grill`
grizzly	`grizzly`
grown	`grown`
guest	`guest`
guild	`guild`
guilt	`guilt`
hail	`hail`
hair	`hair`
hall	`hall`
handmade	`handmade`
handsome	`handsome`
hangar	`hangar`
have	`have`
haze	`haze`
he'd	`he'd`
he'll	`he'll`
heard	`heard`
heart	`heart`
here	`here`
heroin	`heroin`
hey	`hey`
high	`high`
higher	`higher`
him	`him`
ho	`ho`
hold	`hold`
holy	`holy`
hoop	`hoop`
horde	`horde`
horse	`horse`
hose	`hose`
hostile	`hostile`
humorous	`humorous`
hurts	`hurts`
idle	`idle`
illicit	`illicit`
illusion	`illusion`
imminent	`imminent`
impassable	`impassable`
in	`in`
innocence	`innocence`
innumerable	`innumerable`
insight	`insight`
instance	`instance`
intense	`intense`
islet	`islet`
its	`its`
jam	`jam`
jibe	`jibe`
jinx	`jinx`
json	`json`
kernel	`kernel`
knickers	`knickers`
knit	`knit`
knock	`knock`
knows	`knows`
lacks	`lacks`
laid	`laid`
lama	`lama`
lane	`lane`
laps	`laps`
latter	`latter`
lay	`lay`
lays	`lays`
leach	`leach`
lead	`lead`
leak	`leak`
lean	`lean`
least	`least`
lee	`lee`
lens	`lens`
lesson	`lesson`
let's	`let's`
levy	`levy`
liar	`liar`
lie	`lie`
light	`light`
liken	`liken`
links	`links`
literal	`literal`
load	`load`
loan	`loan`
loathe	`loathe`
loch	`loch`
lochs	`lochs`
loot	`loot`
low	`low`
lumber	`lumber`
made	`made`
main	`main`
male	`male`
mall	`mall`
manner	`manner`
mantle	`mantle`
mark	`mark`
martial	`martial`
martin	`martin`
mast	`mast`
mat	`mat`
matter	`matter`
mayor	`mayor`
maze	`maze`
mean	`mean`
meet	`meet`
metal	`metal`
meteor	`meteor`
might	`might`
mill	`mill`
mince	`mince`
mind	`mind`
minor	`minor`
missed	`missed`
missile	`missile`
moan	`moan`
moat	`moat`
mode	`mode`
mood	`mood`
moose	`moose`
morning	`morning`
mourn	`mourn`
mucus	`mucus`
mule	`mule`
muscle	`muscle`
muse	`muse`
must	`must`
mustard	`mustard`
nap	`nap`
naval	`naval`
nave	`nave`
nay	`nay`
need	`need`
new	`new`
nice	`nice`
night	`night`
no	`no`
none	`none`
not	`not`
oh	`oh`
one	`one`
or	`or`
oral	`oral`
oriole	`oriole`
our	`our`
ours	`ours`
outcast	`outcast`
overdue	`overdue`
overseas	`overseas`
owed	`owed`
packed	`packed`
paean	`paean`
pain	`pain`
pair	`pair`
pale	`pale`
palette	`palette`
parish	`parish`
parley	`parley`
past	`past`
paste	`paste`
patients	`patients`
patted	`patted`
pause	`pause`
peak	`peak`
peas	`peas`
pedal	`pedal`
pee	`pee`
peel	`peel`
peer	`peer`
penance	`penance`
per	`per`
perl	`perl`
pervade	`pervade`
petrol	`petrol`
pew	`pew`
phase	`phase`
phrase	`phrase`
picot	`picot`
pie	`pie`
piece	`piece`
pigeon	`pigeon`
pilot	`pilot`
pistol	`pistol`
plane	`plane`
plaque	`plaque`
plate	`plate`
please	`please`
plum	`plum`
poll	`poll`
pour	`pour`
praise	`praise`
pray	`pray`
precedence	`precedence`
premier	`premier`
presence	`presence`
pride	`pride`
primer	`primer`
prince	`prince`
principle	`principle`
profit	`profit`
pros	`pros`
pull	`pull`
quartz	`quartz`
queue	`queue`
queues	`queues`
quince	`quince`
rabbit	`rabbit`
rack	`rack`
rain	`rain`
raise	`raise`
read	`read`
real	`real`
residents	`residents`
rest	`rest`
review	`review`
right	`right`
rights	`rights`
rigor	`rigor`
ring	`ring`
road	`road`
roads	`roads`
role	`role`
room	`room`
rose	`rose`
rot	`rot`
rough	`rough`
route	`route`
row	`row`
rude	`rude`
rue	`rue`
rumor	`rumor`
rung	`rung`
rye	`rye`
sachet	`sachet`
sack	`sack`
sacks	`sacks`
sale	`sale`
sane	`sane`
saver	`saver`
scalar	`scalar`
see	`see`
seed	`seed`
seem	`seem`
seen	`seen`
seer	`seer`
sees	`sees`
sell	`sell`
seller	`seller`
sense	`sense`
sensor	`sensor`
sent	`sent`
serial	`serial`
series	`series`
session	`session`
sewing	`sewing`
sheer	`sheer`
shoe	`shoe`
shoot	`shoot`
shown	`shown`
sick	`sick`
side	`side`
signet	`signet`
sink	`sink`
sinking	`sinking`
site	`site`
size	`size`
skull	`skull`
slay	`slay`
slew	`slew`
slight	`slight`
slow	`slow`
so	`so`
sold	`sold`
some	`some`
son	`son`
sore	`sore`
sorry	`sorry`
soul	`soul`
spade	`spade`
stake	`stake`
stare	`stare`
stationary	`stationary`
stayed	`stayed`
steel	`steel`
step	`step`
straight	`straight`
straightened	`straightened`
style	`style`
sue	`sue`
suit	`suit`
summary	`summary`
surf	`surf`
surge	`surge`
swayed	`swayed`
sweet	`sweet`
sword	`sword`
symbol	`symbol`
tacked	`tacked`
tale	`tale`
talk	`talk`
taper	`taper`
taught	`taught`
taupe	`taupe`
tax	`tax`
tea	`tea`
team	`team`
tear	`tear`
tease	`tease`
tens	`tens`
tense	`tense`
terry	`terry`
than	`than`
the	`the`
their	`their`
there's	`there's`
through	`through`
thrown	`thrown`
throws	`throws`
tick	`tick`
tie	`tie`
tied	`tied`
timber	`timber`
time	`time`
to	`to`
toe	`toe`
told	`told`
tool	`tool`
tort	`tort`
torturous	`torturous`
towed	`towed`
tracked	`tracked`
trader	`trader`
troop	`troop`
trust	`trust`
tucks	`tucks`
turbine	`turbine`
turn	`turn`
tutor	`tutor`
undo	`undo`
use	`use`
utter	`utter`
vain	`vain`
valence	`valence`
variants	`variants`
veil	`veil`
vein	`vein`
versus	`versus`
very	`very`
vice	`vice`
vile	`vile`
wade	`wade`
wait	`wait`
waiter	`waiter`
walk	`walk`
want	`want`
war	`war`
ward	`ward`
waste	`waste`
wave	`wave`
wax	`wax`
way	`way`
ways	`ways`
we	`we`
we'd	`we'd`
we'll	`we'll`
we've	`we've`
wears	`wears`
week	`week`
weekly	`weekly`
were	`were`
wet	`wet`
whale	`whale`
wheeled	`wheeled`
where	`where`
whether	`whether`
which	`which`
while	`while`
whoa	`whoa`
whole	`whole`
whose	`whose`
wind	`wind`
wine	`wine`
with	`with`
word	`word`
world	`world`
worn	`worn`
would	`would`
wrap	`wrap`
wrapped	`wrapped`
wrapper	`wrapper`
wreak	`wreak`
wretch	`wretch`
wrote	`wrote`
yoke	`yoke`
you	`you`
you'll	`you'll`
your	`your`

`user.hours`

List: {user.hours}>

Spoken	Backend
eight	`8`
eighteen	`18`
eleven	`11`
fifteen	`15`
five	`5`
four	`4`
fourteen	`14`
nine	`9`
nineteen	`19`
oh eight	`08`
oh five	`05`
oh four	`04`
oh nine	`09`
oh one	`01`
oh seven	`07`
oh six	`06`
oh three	`03`
oh two	`02`
one	`1`
seven	`7`
seventeen	`17`
six	`6`
sixteen	`16`
ten	`10`
thirteen	`13`
three	`3`
twelve	`12`
twenty	`20`
twenty one	`21`
twenty three	`23`
twenty two	`22`
two	`2`

`user.hours_twelve`

List: {user.hours_twelve}>

Spoken	Backend
eight	`8`
eleven	`11`
five	`5`
four	`4`
nine	`9`
oh eight	`08`
oh five	`05`
oh four	`04`
oh nine	`09`
oh one	`01`
oh seven	`07`
oh six	`06`
oh three	`03`
oh two	`02`
one	`1`
seven	`7`
six	`6`
ten	`10`
three	`3`
twelve	`12`
two	`2`

`user.kaomoji`

List: {user.kaomoji}>

Spoken	Backend
blushing	`(⁄ ⁄•⁄ω⁄•⁄ ⁄)`
cat down	`=^._.^= ∫`
cat up	`ฅ^•ﻌ•^ฅ`
crying	`(╥﹏╥)`
embarrassed	`(⌒_⌒;)`
flower girl	`(◕‿◕✿)`
happy	`(* ^ ω ^)`
kissing	`( ˘ ³˘)♥`
lenny	`( ͡° ͜ʖ ͡°)`
sad	`(｡•́︿•̀｡)`
shrugging	`¯\_(ツ)_/¯`
table flip	`(╯°□°)╯︵ ┻━┻`
table return	`┬─┬ ノ( ゜-゜ノ)`

`user.keypad_key`

List: {user.keypad_key}>

Spoken	Backend
key pad clear	`keypad_clear`
key pad eight	`keypad_8`
key pad enter	`keypad_enter`
key pad equals	`keypad_equals`
key pad five	`keypad_5`
key pad four	`keypad_4`
key pad minus	`keypad_minus`
key pad nine	`keypad_9`
key pad one	`keypad_1`
key pad plus	`keypad_plus`
key pad point	`keypad_decimal`
key pad seven	`keypad_7`
key pad six	`keypad_6`
key pad slash	`keypad_divide`
key pad star	`keypad_multiply`
key pad three	`keypad_3`
key pad two	`keypad_2`
key pad zero	`keypad_0`

`user.language_mode`

List: {user.language_mode}>

Spoken	Backend
are language	`r`
batch	`batch`
c s s	`css`
csv	`csv`
elixir	`elixir`
g d b	`gdb`
go lang	`go`
go language	`go`
html	`html`
java	`java`
java script	`javascript`
java script react	`javascriptreact`
json	`json`
kotlin	`kotlin`
latex	`tex`
lay tech	`tex`
lua	`lua`
mark down	`markdown`
p h p	`php`
proto buf	`protobuf`
python	`python`
ruby	`ruby`
rust	`rust`
scala	`scala`
scss	`scss`
see	`c`
see plus plus	`cpp`
see sharp	`csharp`
shell script	`shellscript`
sql	`sql`
stata	`stata`
talon	`talon`
talon list	`talonlist`
tech	`tex`
terraform	`terraform`
type script	`typescript`
type script react	`typescriptreact`
vim script	`vimscript`
xml	`xml`

`user.launch`

List: {user.launch}>

Spoken	Backend
d beaver c e	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=/app/bin/dbeaver io.dbeaver.DBeaverCommunity`
g n o m e system monitor	`/usr/bin/gnome-system-monitor`
i bus	`/usr/bin/ibus-setup`
i bus preferences	`/usr/bin/ibus-setup`
o b s studio	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=obs com.obsproject.Studio`
v i	`/home/imochoa/.nix-profile/bin/vim`
v i m	`/home/imochoa/.nix-profile/bin/vim`
v l	`/nix/store/03ggic4gwax046a8nyj620j27ynh2ydh-vlc-3.0.21/bin/vlc --started-from-file`
v l c	`/nix/store/03ggic4gwax046a8nyj620j27ynh2ydh-vlc-3.0.21/bin/vlc --started-from-file`
v l c media	`/nix/store/03ggic4gwax046a8nyj620j27ynh2ydh-vlc-3.0.21/bin/vlc --started-from-file`
v l c media player	`/nix/store/03ggic4gwax046a8nyj620j27ynh2ydh-vlc-3.0.21/bin/vlc --started-from-file`
x pipe	`/nix/store/1959l2zcs91pjy1d2z6crzvj76bvx3nk-xpipe-13.4.4/opt/xpipe/cli/bin/xpipe open`
additional	`/usr/bin/software-properties-gtk --open-tab=4`
additional drivers	`/usr/bin/software-properties-gtk --open-tab=4`
analyzer	`/usr/bin/baobab`
app	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/snap-store_snap-store.desktop /snap/bin/snap-store`
app center	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/snap-store_snap-store.desktop /snap/bin/snap-store`
applications	`/usr/bin/gnome-session-properties`
base	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --base @@u @@`
beaver	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=/app/bin/dbeaver io.dbeaver.DBeaverCommunity`
bit	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=bleachbit org.bleachbit.BleachBit`
bleach	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=bleachbit org.bleachbit.BleachBit`
bleach bit	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=bleachbit org.bleachbit.BleachBit`
bottom	`/home/imochoa/.nix-profile/bin/btm`
boxes	`/usr/bin/gnome-boxes`
browser	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/chromium_chromium.desktop /snap/bin/chromium`
bus	`/usr/bin/ibus-setup`
calc	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --calc @@u @@`
calculator	`/usr/bin/gnome-calculator`
ce	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=/app/bin/dbeaver io.dbeaver.DBeaverCommunity`
center	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/snap-store_snap-store.desktop /snap/bin/snap-store`
characters	`/usr/bin/gnome-characters`
cheese	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/cheese_cheese.desktop /snap/bin/cheese`
chromium	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/chromium_chromium.desktop /snap/bin/chromium`
chromium web	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/chromium_chromium.desktop /snap/bin/chromium`
chromium web browser	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/chromium_chromium.desktop /snap/bin/chromium`
clam	`/home/imochoa/.nix-profile/bin/clamtk`
clam tk	`/home/imochoa/.nix-profile/bin/clamtk`
client	`/usr/bin/footclient`
clocks	`/usr/bin/gnome-clocks`
code	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/code_code.desktop /snap/bin/code --force-user-env`
color	`/usr/bin/display-im6.q16 -nostdin`
computer	`/usr/bin/gnome-session-quit --power-off`
controls	`/usr/bin/malcontent-control`
d beaver	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=/app/bin/dbeaver io.dbeaver.DBeaverCommunity`
d beaver ce	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=/app/bin/dbeaver io.dbeaver.DBeaverCommunity`
dconf	`/home/imochoa/.nix-profile/bin/dconf-editor`
dconf editor	`/home/imochoa/.nix-profile/bin/dconf-editor`
depth	`/usr/bin/display-im6.q16 -nostdin`
desktop	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=run.sh --file-forwarding io.podman_desktop.PodmanDesktop @@u @@`
disk	`/usr/bin/baobab`
disk usage	`/usr/bin/baobab`
disk usage analyzer	`/usr/bin/baobab`
disks	`/usr/bin/gnome-disks`
document	`/usr/bin/evince`
document viewer	`/usr/bin/evince`
draw	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --draw @@u @@`
drivers	`/usr/bin/software-properties-gtk --open-tab=4`
editor	`/usr/bin/gnome-text-editor`
eyes	`/usr/bin/env GDK_BACKEND=x11 safeeyes`
files	`/usr/bin/nautilus --new-window`
firefox	`/home/imochoa/.nix-profile/bin/firefox --name firefox`
firmware	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/firmware-updater_firmware-updater.desktop /snap/bin/firmware-updater`
firmware updater	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/firmware-updater_firmware-updater.desktop /snap/bin/firmware-updater`
flameshot	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=/app/bin/flameshot org.flameshot.Flameshot`
flatseal	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=com.github.tchx84.Flatseal com.github.tchx84.Flatseal`
fonts	`/usr/bin/gnome-font-viewer`
foot	`/usr/bin/foot`
foot client	`/usr/bin/footclient`
foot server	`/usr/bin/foot --server`
gnome	`/usr/bin/gnome-system-monitor`
gnome system	`/usr/bin/gnome-system-monitor`
gnome system monitor	`/usr/bin/gnome-system-monitor`
gromit	`/home/imochoa/.nix-profile/bin/gromit-mpx`
gromit m	`/home/imochoa/.nix-profile/bin/gromit-mpx`
gromit m p	`/home/imochoa/.nix-profile/bin/gromit-mpx`
gromit m p x	`/home/imochoa/.nix-profile/bin/gromit-mpx`
gromit mpx	`/home/imochoa/.nix-profile/bin/gromit-mpx`
grsync	`/nix/store/xhhym4d9v7jzsmaaf4mlf6j27xc6ws2i-grsync-1.3.1/bin/grsync -i`
help	`/usr/bin/yelp`
home	`/nix/store/9h83dn0sjyh7b21sn5g2rgass8f04a6q-home-manager-help/bin/home-manager-help`
home manager	`/nix/store/9h83dn0sjyh7b21sn5g2rgass8f04a6q-home-manager-help/bin/home-manager-help`
home manager manual	`/nix/store/9h83dn0sjyh7b21sn5g2rgass8f04a6q-home-manager-help/bin/home-manager-help`
i bus preferences	`/usr/bin/ibus-setup`
image	`/usr/bin/eog`
image magick	`/usr/bin/display-im6.q16 -nostdin`
image magick color	`/usr/bin/display-im6.q16 -nostdin`
image magick color depth	`/usr/bin/display-im6.q16 -nostdin`
image magick color depth q	`/usr/bin/display-im6.q16 -nostdin`
image magick color depth q one	`/usr/bin/display-im6.q16 -nostdin`
image magick color depth q one six	`/usr/bin/display-im6.q16 -nostdin`
image magick color depth q sixteen	`/usr/bin/display-im6.q16 -nostdin`
image viewer	`/usr/bin/eog`
impress	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --impress @@u @@`
info	`/usr/bin/info`
inkscape	`/usr/bin/inkscape`
input	`/usr/bin/im-config`
input method	`/usr/bin/im-config`
joplin	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=joplin-desktop --file-forwarding net.cozic.joplin_desktop @@u @@`
kee	`/home/imochoa/.nix-profile/bin/keepassxc`
kee pass	`/home/imochoa/.nix-profile/bin/keepassxc`
kee pass x c	`/home/imochoa/.nix-profile/bin/keepassxc`
kee pass xc	`/home/imochoa/.nix-profile/bin/keepassxc`
keys	`/usr/bin/seahorse`
ksnip	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=ksnip org.ksnip.ksnip`
language	`/usr/bin/gnome-language-selector`
language support	`/usr/bin/gnome-language-selector`
libre	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --base @@u @@`
libre office	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --base @@u @@`
libre office base	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --base @@u @@`
libre office calc	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --calc @@u @@`
libre office draw	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --draw @@u @@`
libre office impress	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --impress @@u @@`
libre office writer	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --writer @@u @@`
local	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=localsend --file-forwarding org.localsend.localsend_app @@u @@`
local send	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=localsend --file-forwarding org.localsend.localsend_app @@u @@`
logout	`/usr/bin/gnome-session-quit`
logs	`/usr/bin/gnome-logs`
machine	`/usr/bin/virt-manager`
magick	`/usr/bin/display-im6.q16 -nostdin`
manager	`/nix/store/9h83dn0sjyh7b21sn5g2rgass8f04a6q-home-manager-help/bin/home-manager-help`
manual	`/nix/store/9h83dn0sjyh7b21sn5g2rgass8f04a6q-home-manager-help/bin/home-manager-help`
media	`/nix/store/03ggic4gwax046a8nyj620j27ynh2ydh-vlc-3.0.21/bin/vlc --started-from-file`
meld	`/home/imochoa/.nix-profile/bin/meld`
method	`/usr/bin/im-config`
monitor	`/usr/bin/gnome-system-monitor`
neovim	`/home/imochoa/.nix-profile/bin/nvim`
neovim wrapper	`/home/imochoa/.nix-profile/bin/nvim`
obs	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=obs com.obsproject.Studio`
obs studio	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=obs com.obsproject.Studio`
office	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --base @@u @@`
one password	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/1password_1password.desktop /snap/bin/1password`
parental	`/usr/bin/malcontent-control`
parental controls	`/usr/bin/malcontent-control`
pass	`/home/imochoa/.nix-profile/bin/keepassxc`
password	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/1password_1password.desktop /snap/bin/1password`
passwords	`/usr/bin/seahorse`
passwords and	`/usr/bin/seahorse`
passwords and keys	`/usr/bin/seahorse`
pipe	`/nix/store/1959l2zcs91pjy1d2z6crzvj76bvx3nk-xpipe-13.4.4/opt/xpipe/cli/bin/xpipe open`
player	`/nix/store/03ggic4gwax046a8nyj620j27ynh2ydh-vlc-3.0.21/bin/vlc --started-from-file`
podman	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=run.sh --file-forwarding io.podman_desktop.PodmanDesktop @@u @@`
podman desktop	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=run.sh --file-forwarding io.podman_desktop.PodmanDesktop @@u @@`
power	`/usr/bin/gnome-power-statistics`
power statistics	`/usr/bin/gnome-power-statistics`
preferences	`/usr/bin/ibus-setup`
reboot	`/usr/bin/gnome-session-quit --reboot`
regolith	`/usr/bin/regolith-session-x11`
regolith wayland	`/usr/bin/regolith-session-wayland`
regolith x	`/usr/bin/regolith-session-x11`
regolith x eleven	`/usr/bin/regolith-session-x11`
regolith x one	`/usr/bin/regolith-session-x11`
regolith x one one	`/usr/bin/regolith-session-x11`
remote	`/usr/bin/remote-viewer`
remote viewer	`/usr/bin/remote-viewer`
resources	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=resources net.nokyan.Resources`
safe	`/usr/bin/env GDK_BACKEND=x11 safeeyes`
safe eyes	`/usr/bin/env GDK_BACKEND=x11 safeeyes`
send	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=localsend --file-forwarding org.localsend.localsend_app @@u @@`
server	`/usr/bin/foot --server`
settings	`/usr/bin/gnome-control-center`
shotcut	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=shotcut --file-forwarding org.shotcut.Shotcut @@ @@`
shotwell	`/home/imochoa/.nix-profile/bin/shotwell`
shutdown	`/usr/bin/gnome-session-quit --power-off`
shutdown computer	`/usr/bin/gnome-session-quit --power-off`
shutter	`/home/imochoa/.nix-profile/bin/shutter`
slack	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=com.slack.Slack --file-forwarding com.slack.Slack @@u @@`
software	`/usr/bin/gnome-software`
software and updates	`/usr/bin/software-properties-gtk`
software updates	`/usr/bin/software-properties-gtk`
start	`/home/imochoa/.nix-profile/bin/syncthing serve --no-browser --logfile=default`
start syncthing	`/home/imochoa/.nix-profile/bin/syncthing serve --no-browser --logfile=default`
startup	`/usr/bin/gnome-session-properties`
startup applications	`/usr/bin/gnome-session-properties`
statistics	`/usr/bin/gnome-power-statistics`
support	`/usr/bin/gnome-language-selector`
syncthing	`/home/imochoa/.nix-profile/bin/syncthing serve --no-browser --logfile=default`
syncthing web	`/home/imochoa/.nix-profile/bin/syncthing --browser-only`
syncthing web u i	`/home/imochoa/.nix-profile/bin/syncthing --browser-only`
syncthing web ui	`/home/imochoa/.nix-profile/bin/syncthing --browser-only`
system	`/usr/bin/gnome-system-monitor`
system monitor	`/usr/bin/gnome-system-monitor`
te	`/usr/bin/info`
te x	`/usr/bin/info`
te x info	`/usr/bin/info`
te x info	`/usr/bin/info`
te xdoctk	`/usr/bin/texdoctk`
term	`/home/imochoa/.nix-profile/bin/wezterm start --cwd .`
terminal	`/usr/bin/gnome-terminal`
text	`/usr/bin/gnome-text-editor`
text editor	`/usr/bin/gnome-text-editor`
timeshift	`/home/imochoa/.nix-profile/bin/timeshift-launcher`
tk	`/home/imochoa/.nix-profile/bin/clamtk`
ui	`/home/imochoa/.nix-profile/bin/syncthing --browser-only`
updater	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/firmware-updater_firmware-updater.desktop /snap/bin/firmware-updater`
updates	`/usr/bin/software-properties-gtk`
usage	`/usr/bin/baobab`
viewer	`/usr/bin/eog`
vim	`/home/imochoa/.nix-profile/bin/vim`
virtual	`/usr/bin/virt-manager`
virtual machine	`/usr/bin/virt-manager`
virtual machine manager	`/usr/bin/virt-manager`
visual studio	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/code_code.desktop /snap/bin/code --force-user-env`
visual studio code	`/usr/bin/env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/code_code.desktop /snap/bin/code --force-user-env`
vlc media player	`/nix/store/03ggic4gwax046a8nyj620j27ynh2ydh-vlc-3.0.21/bin/vlc --started-from-file`
vorta	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=vorta com.borgbase.Vorta`
wayland	`/usr/bin/regolith-session-wayland`
web	`/home/imochoa/.nix-profile/bin/syncthing --browser-only`
wez	`/home/imochoa/.nix-profile/bin/wezterm start --cwd .`
wez term	`/home/imochoa/.nix-profile/bin/wezterm start --cwd .`
wrapper	`/home/imochoa/.nix-profile/bin/nvim`
writer	`/usr/bin/flatpak run --branch=stable --arch=x86_64 --command=libreoffice --file-forwarding org.libreoffice.LibreOffice --writer @@u @@`
x pipe	`/nix/store/1959l2zcs91pjy1d2z6crzvj76bvx3nk-xpipe-13.4.4/opt/xpipe/cli/bin/xpipe open`
xc	`/home/imochoa/.nix-profile/bin/keepassxc`
xdoctk	`/usr/bin/texdoctk`
xournal	`/home/imochoa/.nix-profile/bin/xournalpp`
xournal plus plus	`/home/imochoa/.nix-profile/bin/xournalpp`

`user.letter`

List: {user.letter}>

Spoken	Backend
air	`a`
bat	`b`
cap	`c`
crunch	`k`
drum	`d`
each	`e`
eat	`e`
fine	`f`
gust	`g`
harp	`h`
ink	`i`
jane	`j`
jury	`j`
kick	`k`
look	`l`
made	`m`
near	`n`
oats	`o`
odd	`o`
pit	`p`
plex	`x`
queen	`q`
quench	`q`
red	`r`
risk	`r`
sit	`i`
spun	`s`
sun	`s`
trap	`t`
urge	`u`
vest	`v`
whale	`w`
yank	`y`
york	`y`
zip	`z`

`user.makeshift_destination`

List: {user.makeshift_destination}>

Spoken	Backend
after	`editNewLineAfter`
before	`editNewLineBefore`
to	`clearAndSetSelection`

`user.minutes`

List: {user.minutes}>

Spoken	Backend
eighteen	`18`
eleven	`11`
fifteen	`15`
fifty	`50`
fifty eight	`58`
fifty five	`55`
fifty four	`54`
fifty nine	`59`
fifty one	`51`
fifty seven	`57`
fifty six	`56`
fifty three	`53`
fifty two	`52`
forty	`40`
forty eight	`48`
forty five	`45`
forty four	`44`
forty nine	`49`
forty one	`41`
forty seven	`47`
forty six	`46`
forty three	`43`
forty two	`42`
fourteen	`14`
nineteen	`19`
oh eight	`08`
oh five	`05`
oh four	`04`
oh nine	`09`
oh one	`01`
oh seven	`07`
oh six	`06`
oh three	`03`
oh two	`02`
seventeen	`17`
sixteen	`16`
ten	`10`
thirteen	`13`
thirty	`30`
thirty eight	`38`
thirty five	`35`
thirty four	`34`
thirty nine	`39`
thirty one	`31`
thirty seven	`37`
thirty six	`36`
thirty three	`33`
thirty two	`32`
twelve	`12`
twenty	`20`
twenty eight	`28`
twenty five	`25`
twenty four	`24`
twenty nine	`29`
twenty one	`21`
twenty seven	`27`
twenty six	`26`
twenty three	`23`
twenty two	`22`

`user.model`

List: {user.model}>

Spoken	Backend
four o	`gpt-4o`
four o mini	`gpt-4o-mini`
model	`model`

`user.modeldestination`

List: {user.modeldestination}>

Spoken	Backend
above	`above`
below	`below`
chain	`chain`
snip	`snip`
to after clip	`appendClipboard`
to browser	`browser`
to clip	`clipboard`
to context	`context`
to new context	`newContext`
to speech	`textToSpeech`
to this	`paste`
to window	`window`

`user.modelsource`

List: {user.modelsource}>

Spoken	Backend
clip	`clipboard`
context	`context`
last	`lastTalonDictation`
response	`gptResponse`
this	`selection`

`user.modelthread`

List: {user.modelthread}>

Spoken	Backend
and	`continueLast`

`user.modifier_key`

List: {user.modifier_key}>

Spoken	Backend
alt	`alt`
command	`ctrl`
control	`ctrl`
option	`alt`
shift	`shift`
super	`super`

`user.navigation_action`

List: {user.navigation_action}>

Spoken	Backend
clear	`DELETE`
copy	`COPY`
cut	`CUT`
extend	`EXTEND`
move	`GO`
select	`SELECT`

`user.navigation_target_name`

List: {user.navigation_target_name}>

Spoken	Backend
all	`(.\+)`
angles	`\<(.*?)\>`
big	`[\S]\+`
braces	`\{(.*?)\}`
constant	`[A-Z_][A-Z_]\+`
method	`\w\+$(.*?)$`
parens	`$(.*?)$`
quotes	`\"(.*?)\"`
small	`[A-Z]?[a-z0-9]\+`
squares	`\[(.*?)\]`
word	`\w\+`

`user.number_key`

List: {user.number_key}>

Spoken	Backend
eight	`8`
five	`5`
four	`4`
nine	`9`
one	`1`
seven	`7`
six	`6`
three	`3`
two	`2`
zero	`0`

`user.number_small`

List: {user.number_small}>

Spoken	Backend
eight	`8`
eight eight	`88`
eight five	`85`
eight four	`84`
eight nine	`89`
eight one	`81`
eight seven	`87`
eight six	`86`
eight three	`83`
eight two	`82`
eight zero	`80`
eighteen	`18`
eighty	`80`
eighty eight	`88`
eighty five	`85`
eighty four	`84`
eighty nine	`89`
eighty one	`81`
eighty seven	`87`
eighty six	`86`
eighty three	`83`
eighty two	`82`
eleven	`11`
fifteen	`15`
fifty	`50`
fifty eight	`58`
fifty five	`55`
fifty four	`54`
fifty nine	`59`
fifty one	`51`
fifty seven	`57`
fifty six	`56`
fifty three	`53`
fifty two	`52`
five	`5`
five eight	`58`
five five	`55`
five four	`54`
five nine	`59`
five one	`51`
five seven	`57`
five six	`56`
five three	`53`
five two	`52`
five zero	`50`
forty	`40`
forty eight	`48`
forty five	`45`
forty four	`44`
forty nine	`49`
forty one	`41`
forty seven	`47`
forty six	`46`
forty three	`43`
forty two	`42`
four	`4`
four eight	`48`
four five	`45`
four four	`44`
four nine	`49`
four one	`41`
four seven	`47`
four six	`46`
four three	`43`
four two	`42`
four zero	`40`
fourteen	`14`
nine	`9`
nine eight	`98`
nine five	`95`
nine four	`94`
nine nine	`99`
nine one	`91`
nine seven	`97`
nine six	`96`
nine three	`93`
nine two	`92`
nine zero	`90`
nineteen	`19`
ninety	`90`
ninety eight	`98`
ninety five	`95`
ninety four	`94`
ninety nine	`99`
ninety one	`91`
ninety seven	`97`
ninety six	`96`
ninety three	`93`
ninety two	`92`
one	`1`
one eight	`18`
one five	`15`
one four	`14`
one nine	`19`
one one	`11`
one seven	`17`
one six	`16`
one three	`13`
one two	`12`
one zero	`10`
seven	`7`
seven eight	`78`
seven five	`75`
seven four	`74`
seven nine	`79`
seven one	`71`
seven seven	`77`
seven six	`76`
seven three	`73`
seven two	`72`
seven zero	`70`
seventeen	`17`
seventy	`70`
seventy eight	`78`
seventy five	`75`
seventy four	`74`
seventy nine	`79`
seventy one	`71`
seventy seven	`77`
seventy six	`76`
seventy three	`73`
seventy two	`72`
six	`6`
six eight	`68`
six five	`65`
six four	`64`
six nine	`69`
six one	`61`
six seven	`67`
six six	`66`
six three	`63`
six two	`62`
six zero	`60`
sixteen	`16`
sixty	`60`
sixty eight	`68`
sixty five	`65`
sixty four	`64`
sixty nine	`69`
sixty one	`61`
sixty seven	`67`
sixty six	`66`
sixty three	`63`
sixty two	`62`
ten	`10`
thirteen	`13`
thirty	`30`
thirty eight	`38`
thirty five	`35`
thirty four	`34`
thirty nine	`39`
thirty one	`31`
thirty seven	`37`
thirty six	`36`
thirty three	`33`
thirty two	`32`
three	`3`
three eight	`38`
three five	`35`
three four	`34`
three nine	`39`
three one	`31`
three seven	`37`
three six	`36`
three three	`33`
three two	`32`
three zero	`30`
twelve	`12`
twenty	`20`
twenty eight	`28`
twenty five	`25`
twenty four	`24`
twenty nine	`29`
twenty one	`21`
twenty seven	`27`
twenty six	`26`
twenty three	`23`
twenty two	`22`
two	`2`
two eight	`28`
two five	`25`
two four	`24`
two nine	`29`
two one	`21`
two seven	`27`
two six	`26`
two three	`23`
two two	`22`
two zero	`20`
zero	`0`

`user.ordinals`

List: {user.ordinals}>

Spoken	Backend
eighteenth	`18`
eighth	`8`
eightieth	`80`
eighty eighth	`88`
eighty fifth	`85`
eighty first	`81`
eighty fourth	`84`
eighty ninth	`89`
eighty second	`82`
eighty seventh	`87`
eighty sixth	`86`
eighty third	`83`
eleventh	`11`
fifteenth	`15`
fifth	`5`
fiftieth	`50`
fifty eighth	`58`
fifty fifth	`55`
fifty first	`51`
fifty fourth	`54`
fifty ninth	`59`
fifty second	`52`
fifty seventh	`57`
fifty sixth	`56`
fifty third	`53`
first	`1`
fortieth	`40`
forty eighth	`48`
forty fifth	`45`
forty first	`41`
forty fourth	`44`
forty ninth	`49`
forty second	`42`
forty seventh	`47`
forty sixth	`46`
forty third	`43`
fourteenth	`14`
fourth	`4`
nineteenth	`19`
ninetieth	`90`
ninety eighth	`98`
ninety fifth	`95`
ninety first	`91`
ninety fourth	`94`
ninety ninth	`99`
ninety second	`92`
ninety seventh	`97`
ninety sixth	`96`
ninety third	`93`
ninth	`9`
second	`2`
seventeenth	`17`
seventh	`7`
seventieth	`70`
seventy eighth	`78`
seventy fifth	`75`
seventy first	`71`
seventy fourth	`74`
seventy ninth	`79`
seventy second	`72`
seventy seventh	`77`
seventy sixth	`76`
seventy third	`73`
sixteenth	`16`
sixth	`6`
sixtieth	`60`
sixty eighth	`68`
sixty fifth	`65`
sixty first	`61`
sixty fourth	`64`
sixty ninth	`69`
sixty second	`62`
sixty seventh	`67`
sixty sixth	`66`
sixty third	`63`
tenth	`10`
third	`3`
thirteenth	`13`
thirtieth	`30`
thirty eighth	`38`
thirty fifth	`35`
thirty first	`31`
thirty fourth	`34`
thirty ninth	`39`
thirty second	`32`
thirty seventh	`37`
thirty sixth	`36`
thirty third	`33`
twelfth	`12`
twentieth	`20`
twenty eighth	`28`
twenty fifth	`25`
twenty first	`21`
twenty fourth	`24`
twenty ninth	`29`
twenty second	`22`
twenty seventh	`27`
twenty sixth	`26`
twenty third	`23`

`user.ordinals_small`

List: {user.ordinals_small}>

Spoken	Backend
eighteenth	`18`
eighth	`8`
eleventh	`11`
fifteenth	`15`
fifth	`5`
first	`1`
fourteenth	`14`
fourth	`4`
nineteenth	`19`
ninth	`9`
second	`2`
seventeenth	`17`
seventh	`7`
sixteenth	`16`
sixth	`6`
tenth	`10`
third	`3`
thirteenth	`13`
twelfth	`12`
twentieth	`20`

`user.phrase_ender`

List: {user.phrase_ender}>

Spoken	Backend
over	````

`user.prose_formatter`

List: {user.prose_formatter}>

Spoken	Backend
say	`NOOP`
sentence	`CAPITALIZE_FIRST_WORD`
speak	`NOOP`
title	`CAPITALIZE_ALL_WORDS`

`user.prose_modifiers`

List: {user.prose_modifiers}>

Spoken	Backend
cap	`cap`
no cap	`no_cap`
no caps	`no_cap`
no space	`no_space`

`user.prose_snippets`

List: {user.prose_snippets}>

Spoken	Backend
close quote	`”`
frowny	`:-(`
new line	````
new paragraph	````
open quote	`“`
smiley	`:-)`
spacebar	````
winky	`;-)`

`user.punctuation`

List: {user.punctuation}>

Spoken	Backend
l paren	`(`
r paren	`)`
ampersand	`&`
and sign	`&`
asterisk	`*`
at sign	`@`
at symbol	`@`
back tick	`````
colon	`:`
coma	`,`
comma	`,`
dollar sign	`$`
exclamation mark	`!`
exclamation point	`!`
forward slash	`/`
full stop	`.`
hash sign	`#`
hyphen	`-`
left paren	`(`
number sign	`#`
paren	`(`
percent sign	`%`
period	`.`
pound sign	`£`
question mark	`?`
right paren	`)`
semicolon	`;`

`user.reformatter`

List: {user.reformatter}>

Spoken	Backend
cap	`CAPITALIZE`
unformat	`REMOVE_FORMATTING`

`user.search_engine`

List: {user.search_engine}>

Spoken	Backend
amazon	`https://www.amazon.com/s/?field-keywords=%s`
google	`https://searxng.imochoa.com/?q=%s`
google map	`https://maps.google.com/maps?q=%s`
home manager	`https://mipmip.github.io/-manager-option-search?query=%s`
kagi	`https://kagi.com/search?q=%s`
kagi gpt	`https://kagi.com/fastgpt?query=%s`
map	`https://maps.google.com/maps?q=%s`
nix packages	`https://search.nixos.org/packages?type=packages&query=%s`
nix wiki	`https://nixos.wiki/index.php?search=%s`
real google	`https://www.google.com/search?q=%s`
scholar	`https://scholar.google.com/scholar?q=%s`
talon github	`https://search.talonvoice.com/search`
talon live grep	`https://search.talonvoice.com/search/?q=%s`
wiki	`https://en.wikipedia.org/w/index.php?search=%s`
woogle	`https://whoogle.imochoa.com/search?q=%s`

`user.snippet`

List: {user.snippet}>

Spoken	Backend
call	`functionCall`
code	`codeQuote`
code lang	`codeQuoteLanguage`
command	`playingAround`
comment	`commentLine`
print	`printStatement`

`user.snippet_with_phrase`

List: {user.snippet_with_phrase}>

Spoken	Backend
command	`playingAround`
comment	`commentLine`

`user.snippet_wrapper`

List: {user.snippet_wrapper}>

Spoken	Backend
call	`functionCall.0`
print	`printStatement.0`

`user.special_key`

List: {user.special_key}>

Spoken	Backend
delete	`backspace`
end	`end`
enter	`enter`
escape	`escape`
forward delete	`delete`
home	`home`
insert	`insert`
menu key	`menu`
minus	`minus`
page down	`pagedown`
page up	`pageup`
print screen	`printscr`
space	`space`
tab	`tab`
wipe	`backspace`

`user.staticprompt`

List: {user.staticprompt}>

Spoken	Backend
add context	`Add additional text to the selected text that would be appropriate to the situation and add useful information.`
add emoji	`Return the same exact text verbatim with the same formatting, but add emoji when appropriate in order to make the text fun and easier to understand.`
add questions	`Help me explore this question from multiple perspectives. For each perspective, ask follow-up questions and indicate what perspective is being taken.`
answer	`Generate text that satisfies the question or request given in the input.`
check grammar	`Check the grammar and formatting of the following text. Return a list of all potential errors.`
check spelling	`Check the spelling of the following text. Return a list of all potential errors.`
check structure	`Skim the structure and layout of the following text. Tell me if the structure and order of my writing are correct. If it is not correct or flows poorly, then tell me what might be wrong with it. If it is all correct, then say it looks good.`
clean code	`Act as a software engineer. Reduce any duplication in the selected code and improve it to be more idiomatic and clear for other users. However, do not change the behavior or functionality. Return just the code and not any explanations.`
convert to jason	`Convert the following data into a JSON format.`
convert to markdown	`Convert the following text into a markdown format.`
convert to python	`Convert the following key-value pairs into the syntax for a Python dictionary. So you should serialize the key-value pairs into a native Python format.`
convert to sheet	`Convert the following data into a CSV format.`
convert to yam	`Convert the following data into a YAML format.`
describe code	`Explain what the following code does in natural language at a high level without getting into the specifics of the syntax.`
explain	`Explain this text in a way that is easier to understand for a layman without technical knowledge.`
fit schema	`The given text has a series of responses that need to be categorized. Each response has a key that needs to be mapped to a value. Infer the schema from the text unless it is given at the top of the text with prior examples. Return the key-value pairs in a JSON format unless you infer a different format.`
fix grammar	`Fix any mistakes or irregularities in grammar, spelling, or formatting. The text was created using voice dictation. Thus, there are likely to be issues regarding homophones and other misrecognitions. Do not change the tone. Do not change the original structure of the text.`
fix grammar formally	`Fix any mistakes or irregularities in grammar, spelling, or formatting. Use a professional business tone. The text was created using voice dictation. Thus, there are likely to be issues regarding homophones and other misrecognitions. Do not change the original structure of the text.`
fix syntax	`Fix any syntax errors in this code selection. Do not change any behavior.`
format bullets	Convert each paragraph into a heading with a series of bullet points underneath it. Each paragraph is separated by a new line. Separate paragraphs should not have combined bullet points. This should all be done in markdown syntax. If it is a small paragraph, then you can just leave it as a heading and not add bullet points. Do not reduce content, only reduce things that would be redundant. These bullet points should be in a useful format for notes for those who want to quickly look at it. If there is a citation in the markdown original, then keep the citation just at the top and not within every individual bullet point.
format comment	`Format the following text as a comment for the current programming language. Use the proper comment syntax for the current language. Split the comment into multiple lines if the lines are too long.`
format mermaid	`Convert the following plain text into the text syntax for a mermaid diagram.`
format outline	`Create an outline that encapsulates the text below. Keep the number of sections between three and five to optimize for human working memory. Return just the outline.`
format prose	`As an editor, format the following outline or summarization as prose. You can have headings and paragraphs. Avoid using bullet points. Reorder and add transitions as necessary to make the document flow. Return just the text.`
format table	`The following markdown text is raw data. There is no index. Return the text in a markdown table format. Each row has a new line in the original data.`
generate code	`The following plaintext describes a process in code in the language that is specified by the system prompt. Please output the code necessary to do this. Return just code and not any natural language explanations.`
group	`Act as an organizer. The following text consists of various topics all put together. Please group these items into categories and label each category. Return just the results.`
improve semantics	`The following is an HTML document. Keep the same structure and layout but if it is needed, change any elements to use proper semantic HTML and make sure it is implementing best practices for user accessibility. Output just the HTML and not any extra explanations.`
join	`Act as an editor. The following text is separated into multiple parts. Please group them together into one part maintaining the flow and meaning. Reorder in whatever way makes sense. Remove any redundant information. The result should be only one part with no additional structure. Return just the modified text.`
make softer	`Act as an editor. I want you to make the following text softer in tone. Return just the modified text.`
make stronger	`Act as an editor. I want you to make the following text stronger in tone. Return just the modified text.`
shell	`Generate a shell script that performs the following actions. Output only the command. Do not output any comments or explanations. Default to the bash shell unless otherwise specified.`
summarize	`Summarize this text into a format suitable for project notes.`
translate to english	`Translate the following text into English.`
update comments	`Act as a software engineer. The following code may be missing comments or the comments could be out of date. Please update the comments. If you are unsure how to comment something, ask a question in a comment instead. Return just the code and not any explanations.`

`user.symbol_key`

List: {user.symbol_key}>

Spoken	Backend
l angle	`<`
l brace	`{`
l brack	`[`
l bracket	`[`
l paren	`(`
l square	`[`
r angle	`>`
r brace	`}`
r brack	`]`
r bracket	`]`
r curly bracket	`}`
r paren	`)`
r square	`]`
amper	`&`
ampersand	`&`
and sign	`&`
angle	`<`
apostrophe	`'`
asterisk	`*`
at sign	`@`
at symbol	`@`
back tick	`````
backslash	`\`
bang	`!`
brace	`{`
brack	`[`
bracket	`[`
caret	`^`
colon	`:`
coma	`,`
comma	`,`
curly bracket	`{`
dash	`-`
dollar	`$`
dollar sign	`$`
dot	`.`
double quote	`"`
down score	`_`
dub quote	`"`
equals	`=`
exclamation mark	`!`
exclamation point	`!`
forward slash	`/`
full stop	`.`
grave	`````
greater than	`>`
hash	`#`
hash sign	`#`
hyphen	`-`
left angle	`<`
left brace	`{`
left bracket	`[`
left curly bracket	`{`
left paren	`(`
left square	`[`
less than	`<`
minus	`-`
number sign	`#`
paren	`(`
percent	`%`
percent sign	`%`
period	`.`
pipe	`\|`
plus	`\+`
point	`.`
pound	`£`
pound sign	`£`
question	`?`
question mark	`?`
quote	`'`
rangle	`>`
right angle	`>`
right brace	`}`
right bracket	`]`
right curly bracket	`}`
right paren	`)`
right square	`]`
semicolon	`;`
slash	`/`
square	`[`
star	`*`
tilde	`~`
underscore	`_`

`user.system_paths`

List: {user.system_paths}>

Spoken	Backend
desk	`/home/imochoa/Desktop`
desktop	`/home/imochoa/Desktop`
docks	`/home/imochoa/Documents`
documents	`/home/imochoa/Documents`
downloads	`/home/imochoa/Downloads`
home	`/home/imochoa`
music	`/home/imochoa/Music`
pictures	`/home/imochoa/Pictures`
talon home	`/home/imochoa/.talon`
talon recordings	`/home/imochoa/.talon/recordings`
talon user	`/home/imochoa/.talon/user`
user	`/home/imochoa`
videos	`/home/imochoa/Videos`

`user.talon_hud_choices`

List: {user.talon_hud_choices}>

Spoken	Backend
head up choice empty command	`\|`

`user.talon_hud_quick_choices`

List: {user.talon_hud_quick_choices}>

Spoken	Backend
event log clear logs	`event_log\|1`
event log keep alive	`event_log\|0`
status bar add focus indicator	`status_bar\|5`
status bar add language	`status_bar\|3`
status bar add microphone	`status_bar\|2`
status bar content toolkit	`status_bar\|0`
status bar remove code language	`status_bar\|4`
status bar remove mode indicator	`status_bar\|1`
walkthrough mark as done	`walkthrough\|1`
walkthrough restore current step	`walkthrough\|2`
walkthrough skip this step	`walkthrough\|0`

`user.talon_hud_themes`

List: {user.talon_hud_themes}>

Spoken	Backend
dark	`dark`
light	`light`

`user.talon_hud_widget_names`

List: {user.talon_hud_widget_names}>

Spoken	Backend
ability bar	`ability_bar`
choices	`Choices`
context menu	`context_menu`
cursor tracker	`cursor_tracker`
documentation	`Documentation`
event log	`event_log`
screen overlay	`screen_overlay`
status bar	`status_bar`
text panel	`Text panel`
walkthrough	`walkthrough`

`user.unix_utility`

List: {user.unix_utility}>

Spoken	Backend
i d	`id`
i d user	`id -u`
m d five sum	`md5sum`
s s h	`ssh`
are sync	`rsync`
ark	`awk`
base sixty four	`base64`
base sixty four decode	`base64 -d`
change mode	`chmod`
change mode recurse	`chmod -R`
change owner	`chown`
change owner recurse	`chown -R`
concat	`cat`
curl	`curl`
cut	`cut`
dig	`dig`
disk free	`df`
disk free human	`df -h`
disk usage	`du`
disk usage human	`du -h`
echo	`echo`
false	`false`
find	`find`
grab	`grep`
grab here	`grep -Hirn`
harp top	`htop`
head	`head`
less	`less`
link	`ln`
link soft	`ln -s`
make dear	`mkdir`
paste	`paste`
print format	`printf`
pseudo	`sudo`
reverse	`rev`
said	`sed`
sequence	`seq`
shah two fifty six sum	`sha256sum`
sleep	`sleep`
sort	`sort`
sort human	`sort -h`
sort numeric	`sort -n`
sort reverse	`sort -r`
sort unique	`sort -u`
stat	`stat`
tail	`tail`
tail follow	`tail -f`
tea	`tee`
tea append	`tee -a`
touch	`touch`
translate	`tr`
translate delete	`tr -d`
true	`true`
unique	`uniq`
unique count	`uniq -c`
who	`who`
who am i	`whoami`
word count	`wc`
word count characters	`wc -c`
word count lines	`wc -l`
work dear	`pwd`

`user.vocabulary`

List: {user.vocabulary}>

Spoken	Backend
ci	`CI`
cisco	`Cisco`
citrix	`Citrix`
dns	`DNS`
fyi	`FYI`
i es see two	`ISC2`
jira	`Jira`
minecraft	`Minecraft`
n map	`nmap`
oci	`OCI`
och tree	`octree`
pr	`PR`
personio	`Personio`
qr	`QR`
repl	`REPL`
svg	`SVG`
saskia	`Saskia`
vpn	`VPN`
admin	`admin`
docstring	`docstring`
grep	`grep`
ill dar	`Ildar`
kagi	`kagi`
lk	`Leitungskreis`
mypy	`mypy`
nix	`nix`
nmap	`nmap`
one pass	`1Password`
one password	`1Password`
open v d b	`OpenVDB`
rango	`rango`
see plus plus	`C\+\+`
system dee	`systemd`
tcp	`tcp`
udp	`udp`
under documented	`under-documented`
uv	`uv`

`user.website`

List: {user.website}>

Spoken	Backend
i es see two book	`https://isc2.vitalsource.com`
i es see two learn	`https://learn.isc2.org`
amazon	`https://www.amazon.de/`
atlassian	`https://spanflug.atlassian.net/`
chat gpt	`https://chatgpt.com/auth/login`
dropbox	`https://dropbox.com/`
gist	`https://gist.github.com/`
github	`https://github.com/`
gmail	`https://mail.google.com/`
google	`https://www.google.com/`
google calendar	`https://calendar.google.com`
google maps	`https://maps.google.com/`
google scholar	`https://scholar.google.com/`
learn cantril	`https://learn.cantrill.io/`
linked in	`https://www.linkedin.com/login`
microsoft office	`https://www.office.com/`
my pdfs	`https://pdfs.imochoa.com`
my todos	`https://vikunja.imochoa.com`
outlook	`https://outlook.office.com`
personio	`http://spanflug.personio.de`
proton	`https://proton.me/`
repo community	`https://github.com/talonhub/community`
spend desk	`https://app.spendesk.com`
talon giki	`https://wiki.gpunktschmitz.com/index.php/Talon`
talon home page	`http://talonvoice.com`
talon practice	`https://chaosparrot.github.io/talon_practice/`
talon repository search	`https://search.talonvoice.com/search/`
talon slack	`http://talonvoice.slack.com/messages/help`
talon wiki	`https://talon.wiki/`
try hack me	`https://tryhackme.com`
whatsapp	`https://web.whatsapp.com/`
wikipedia	`https://en.wikipedia.org/`
youtube	`https://www.youtube.com/`

`user.window_snap_positions`

List: {user.window_snap_positions}>

Spoken	Backend
bottom	`BOTTOM`
bottom_center_small	`BOTTOM_CENTER_SMALL`
bottom_center_third	`BOTTOM_CENTER_THIRD`
bottom_left	`BOTTOM_LEFT`
bottom_left_large	`BOTTOM_LEFT_LARGE`
bottom_left_small	`BOTTOM_LEFT_SMALL`
bottom_left_third	`BOTTOM_LEFT_THIRD`
bottom_left_two_thirds	`BOTTOM_LEFT_TWO_THIRDS`
bottom_right	`BOTTOM_RIGHT`
bottom_right_large	`BOTTOM_RIGHT_LARGE`
bottom_right_small	`BOTTOM_RIGHT_SMALL`
bottom_right_third	`BOTTOM_RIGHT_THIRD`
bottom_right_two_thirds	`BOTTOM_RIGHT_TWO_THIRDS`
center	`CENTER`
center_small	`CENTER_SMALL`
center_third	`CENTER_THIRD`
full	`FULL`
fullscreen	`FULLSCREEN`
left	`LEFT`
left_large	`LEFT_LARGE`
left_small	`LEFT_SMALL`
left_third	`LEFT_THIRD`
left_two_thirds	`LEFT_TWO_THIRDS`
right	`RIGHT`
right_large	`RIGHT_LARGE`
right_small	`RIGHT_SMALL`
right_third	`RIGHT_THIRD`
right_two_thirds	`RIGHT_TWO_THIRDS`
top	`TOP`
top_center_small	`TOP_CENTER_SMALL`
top_center_third	`TOP_CENTER_THIRD`
top_left	`TOP_LEFT`
top_left_large	`TOP_LEFT_LARGE`
top_left_small	`TOP_LEFT_SMALL`
top_left_third	`TOP_LEFT_THIRD`
top_left_two_thirds	`TOP_LEFT_TWO_THIRDS`
top_right	`TOP_RIGHT`
top_right_large	`TOP_RIGHT_LARGE`
top_right_small	`TOP_RIGHT_SMALL`
top_right_third	`TOP_RIGHT_THIRD`
top_right_two_thirds	`TOP_RIGHT_TWO_THIRDS`
bottom	`BOTTOM`
bottom center small	`BOTTOM_CENTER_SMALL`
bottom center third	`BOTTOM_CENTER_THIRD`
bottom left	`BOTTOM_LEFT`
bottom left large	`BOTTOM_LEFT_LARGE`
bottom left small	`BOTTOM_LEFT_SMALL`
bottom left third	`BOTTOM_LEFT_THIRD`
bottom left two thirds	`BOTTOM_LEFT_TWO_THIRDS`
bottom right	`BOTTOM_RIGHT`
bottom right large	`BOTTOM_RIGHT_LARGE`
bottom right small	`BOTTOM_RIGHT_SMALL`
bottom right third	`BOTTOM_RIGHT_THIRD`
bottom right two thirds	`BOTTOM_RIGHT_TWO_THIRDS`
center	`CENTER`
center small	`CENTER_SMALL`
center third	`CENTER_THIRD`
full	`FULL`
fullscreen	`FULLSCREEN`
left	`LEFT`
left large	`LEFT_LARGE`
left small	`LEFT_SMALL`
left third	`LEFT_THIRD`
left two thirds	`LEFT_TWO_THIRDS`
right	`RIGHT`
right large	`RIGHT_LARGE`
right small	`RIGHT_SMALL`
right third	`RIGHT_THIRD`
right two thirds	`RIGHT_TWO_THIRDS`
top	`TOP`
top center small	`TOP_CENTER_SMALL`
top center third	`TOP_CENTER_THIRD`
top left	`TOP_LEFT`
top left large	`TOP_LEFT_LARGE`
top left small	`TOP_LEFT_SMALL`
top left third	`TOP_LEFT_THIRD`
top left two thirds	`TOP_LEFT_TWO_THIRDS`
top right	`TOP_RIGHT`
top right large	`TOP_RIGHT_LARGE`
top right small	`TOP_RIGHT_SMALL`
top right third	`TOP_RIGHT_THIRD`
top right two thirds	`TOP_RIGHT_TWO_THIRDS`

`user.window_split_positions`

List: {user.window_split_positions}>

Spoken	Backend
big grid	`BIG_GRID`
clock	`CLOCK`
counterclock	`COUNTERCLOCK`
grid	`GRID`
half	`HALF`
thirds	`THIRDS`

`user.word_formatter`

List: {user.word_formatter}>

Spoken	Backend
leap	`TRAILING_SPACE,CAPITALIZE_FIRST_WORD`
proud	`CAPITALIZE_FIRST_WORD`
trot	`TRAILING_SPACE`
word	`NOOP`

`cheatsheet`

Context: user.cheatsheet.cheatsheet.talon

Spoken	Backend
print cheatsheet	`user.cheatsheet()`

Mindmap

`1password`

Context: user.community.apps.1password.1password.talon

Spoken	Backend
password delete	`user.password_delete()`
password dup	`user.password_duplicate()`
password edit	`user.password_edit()`
password new	`user.password_new()`

Mindmap

`1password_global`

Context: user.community.apps.1password.1password_global.talon

Spoken	Backend
password fill	`user.password_fill()`
password show	`user.password_show()`

Mindmap

`amethyst`

Context: user.community.apps.amethyst.amethyst.talon

Spoken	Backend
window float	`key(alt-shift-t)`
window full	`key("alt-shift-d")`
window grow	`key("alt-shift-l")`
window middle	key("alt-shift-`")
window move main	`key("alt-shift-enter")`
window next	`key("alt-shift-j")`
window previous	`key("alt-shift-k")`
window reevaluate	`key("alt-shift-z")`
window shrink	`key("alt-shift-h")`
window tall	`key("alt-shift-a")`

Mindmap

`anaconda`

Context: user.community.apps.anaconda.anaconda.talon

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

Mindmap

`apple_notes`

Context: user.community.apps.apple_notes.apple_notes.talon

Spoken	Backend
apply body	`key(shift-cmd-b)`
apply bullet	`key(shift-cmd-7)`
apply checklist	`key(shift-cmd-l)`
apply dash	`key(shift-cmd-8)`
apply heading	`key(shift-cmd-h)`
apply mono	`key(shift-cmd-m)`
apply number	`key(shift-cmd-9)`
apply subheading	`key(shift-cmd-j)`
apply title	`key(shift-cmd-t)`
attach file	`key(shift-cmd-a)`
create link	`key(cmd-k)`
decrease font	`key(cmd--)`
drag [line] down	`key('ctrl-cmd-down')`
drag [line] up	`key('ctrl-cmd-up')`
duplicate note	`key(cmd-d)`
find all	`key(alt-cmd-f)`
gallery view	`key(cmd-2)`
increase font	`key(cmd-\+)`
insert table	`key(alt-cmd-t)`
line break	`key(ctrl-enter)`
list view	`key(cmd-1)`
mark	`key(shift-cmd-u)`
new folder	`key(shift-cmd-n)`
new note	`key(cmd-n)`
print note	`key(cmd-p)`
show main	`key(cmd-0)`
toggle attachments	`key(cmd-3)`
toggle folders	`key(alt-cmd-s)`

Mindmap

`apple_terminal`

Context: user.community.apps.apple_terminal.apple_terminal.talon

Spoken	Backend
resume	`insert("fg")` `key(enter)`
suspend	`key(ctrl-z)`

Mindmap

`little-arc_mac`

Context: user.community.apps.arc.little-arc_mac.talon

Spoken	Backend
little arc [<user.text>]	`key("cmd-alt-n")` `sleep(200ms)` `insert(user.text or "")`

Mindmap

`chrome`

Context: user.community.apps.chrome.chrome.talon

Spoken	Backend
profile switch	`user.chrome_mod("shift-m")`
tab search	`user.chrome_mod("shift-a")`
tab search <user.text>	`user.chrome_mod("shift-a")` `sleep(200ms)` `insert("{text}")` `key(down)`

Mindmap

`discord`

Context: user.community.apps.discord.discord.talon

Spoken	Backend
{user.discord_destination} [<user.text>]	`user.discord_quick_switcher(user.discord_destination, user.text or "")`
(mute \| unmute) and sleep	`user.discord_mute()` `speech.disable()`
[channel] mentions last	`user.discord_mentions_last()`
[channel] mentions next	`user.discord_mentions_next()`
[toggle] (deafen \| undeafen)	`user.discord_deafen()`
[toggle] (mute \| unmute)	`user.discord_mute()`
answer call	`user.discord_answer_call()`
current call	`user.discord_go_current_call()`
decline call	`user.discord_decline_call()`
mark inbox channel read	`user.discord_mark_inbox_read()`
oldest unread	`user.discord_oldest_unread()`
pick (jif \| gif \| gift)	`user.discord_gif_picker()`
pick emoji	`user.discord_emoji_picker()`
pick sticker	`user.discord_sticker_picker()`
switcher	`user.discord_quick_switcher("", "")`
toggle (dee ems \| dims)	`user.discord_toggle_dms()`
toggle (members \| member list)	`user.discord_toggle_members()`
toggle inbox	`user.discord_toggle_inbox()`
toggle pins	`user.discord_toggle_pins()`

Mindmap

`dock`

Context: user.community.apps.dock.dock.talon

Spoken	Backend
desktop	`user.dock_send_notification("com.apple.showdesktop.awake")`
launch pad	`user.dock_send_notification("com.apple.launchpad.toggle")`
window	`user.dock_app_expose()`

Mindmap

`dunst`

Context: user.community.apps.dunst.dunst.talon

Spoken	Backend
dismiss [notifications]	`user.system_command("dunstctl close")`
dismiss all [notifications]	`user.system_command("dunstctl close-all")`
show notifications	key(ctrl-`)

Mindmap

`eclipse`

Context: user.community.apps.eclipse.eclipse.talon

Spoken	Backend
(go declaration \| follow)	`key(f3)`
bar explore	`key(alt-shift-w p)`
bar outline	`key(alt-shift-q o)`
break point	`key(ctrl-shift-b)`
copy line down	`key(ctrl-alt-down)`
copy line up	`key(ctrl-alt-up)`
debug continue	`key(f8)`
debug step into	`key(f5)`
debug step out [of]	`key(f7)`
file create	`key(ctrl-n)`
file hunt [<user.text>]	`key(ctrl-shift-r)` `sleep(50ms)` `insert(text or "")`
file open folder	`key(alt-shift-w x)`
file rename	`key(alt-shift-w p enter f2)`
file reveal	`key(alt-shift-w p enter)`
go back	`key(alt-left)`
go forward	`key(alt-right)`
go last mark	`key(alt-pageup)`
go marks	`key(alt-end)`
go next mark	`key(alt-pagedown)`
imports fix	`key(ctrl-shift-o)`
panel breakpoints	`key(alt-shift-q)` `sleep(200ms)` `key(b)`
panel errors	`key(alt-shift-q)` `sleep(200ms)` `key(l)`
panel output	`key(alt-shift-q)` `sleep(200ms)` `key(c)`
panel problems	`key(alt-shift-q)` `sleep(200ms)` `key(x)`
panel search	`key(alt-shift-q)` `sleep(200ms)` `key(s)`
panel variables	`key(alt-shift-q)` `sleep(200ms)` `key(v)`
refactor rename	`key(alt-shift-r)`
refactor this	`key(alt-shift-i)`
show settings	`key(alt-w p)`
show shortcuts	`key(ctrl-shift-l)`
step over	`key(f6)`
toggle mark	`key(ctrl-alt-b down enter)`

Mindmap

`emacs`

Context: user.community.apps.emacs.emacs.talon

Spoken	Backend
(center \| [center] <number_small> from) bottom	`number = number_small or 0` `user.emacs("recenter-top-bottom", -1 - number)`
(center \| [center] <number_small> from) top	`user.emacs("recenter-top-bottom", number_small or 0)`
(customize \| custom) [theme] visit theme	`user.emacs("custom-theme-visit-theme")`
(file \| buffer) close	`user.emacs("kill-buffer")` `key(enter)`
(file open \| find file) at point	`user.emacs("ffap")`
(search regex \| regex search)	`user.emacs("isearch-forward-regexp")`
(search regex \| regex search) back	`user.emacs("isearch-backward-regexp")`
(sentence \| sent) (left \| start)	`edit.sentence_start()`
(sentence \| sent) (right \| end)	`edit.sentence_end()`
(sentence \| sent) kill	`user.emacs("kill-sentence")`
[split] rebalance	`user.emacs("balance-windows")`
[toggle] debug on error	`user.emacs("toggle-debug-on-error")`
[toggle] debug on quit	`user.emacs("toggle-debug-on-quit")`
[toggle] input method	`user.emacs("toggle-input-method")`
[toggle] truncate lines	`user.emacs("toggle-truncate-lines")`
[toggle] word wrap	`user.emacs("toggle-word-wrap")`
[xref] find definition	`user.emacs("xref-find-definitions")`
[xref] find definition other frame	`user.emacs("xref-find-definitions-other-frame")`
[xref] find definition other window	`user.emacs("xref-find-definitions-other-window")`
[xref] find references	`user.emacs("xref-find-references")`
[xref] find references [and] replace	`user.emacs("xref-find-references-and-replace")`
abort recursive [edit]	`user.emacs("abort-recursive-edit")`
apropos	`user.emacs_help("a")`
apropos <user.text>	`user.emacs_help("a")` `user.insert_formatted(text, "DASH_SEPARATED")` `key(enter)`
auto fill mode	`user.emacs("auto-fill-mode")`
auto indent	`user.emacs("indent-region")`
browse kill ring	`user.emacs("browse-kill-ring")`
buffer bury	`user.emacs("bury-buffer")`
buffer finish	`edit.save()` `user.emacs("server-edit")`
buffer kill	`user.emacs("kill-buffer")`
buffer last	`user.emacs("previous-buffer")`
buffer list	`user.emacs("buffer-menu")`
buffer narrow \| [buffer] narrow to region	`user.emacs("narrow-to-region")`
buffer next	`user.emacs("next-buffer")`
buffer rename	`user.emacs("rename-buffer")`
buffer revert \| revert buffer	`user.emacs("revert-buffer")`
buffer widen	`user.emacs("widen")`
cancel	`user.emacs("keyboard-quit")`
customize face	`user.emacs("customize-face")`
customize face <user.text>	`user.emacs("customize-face")` `user.insert_formatted(text, "DASH_SEPARATED")`
customize group	`user.emacs("customize-group")`
customize variable	`user.emacs("customize-variable")`
describe (char \| character)	`user.emacs("describe-character")`
describe (fun \| function)	`user.emacs_help("f")`
describe (fun \| function) <user.text>	`user.emacs_help("f")` `user.insert_formatted(text, "DASH_SEPARATED")` `key(enter)`
describe bindings	`user.emacs_help("b")`
describe face	`user.emacs("describe-face")`
describe key	`user.emacs_help("k")`
describe key briefly	`user.emacs_help("c")`
describe mode	`user.emacs_help("m")`
describe symbol	`user.emacs_help("o")`
describe symbol <user.text>	`user.emacs_help("o")` `user.insert_formatted(text, "DASH_SEPARATED")` `key(enter)`
describe text properties	`user.emacs("describe-text-properties")`
describe variable	`user.emacs_help("v")`
describe variable <user.text>	`user.emacs_help("v")` `user.insert_formatted(text, "DASH_SEPARATED")` `key(enter)`
diff (buffer \| [buffer] with file)	`user.emacs("diff-buffer-with-file")` `key(enter)`
dired omit mode	`user.emacs("dired-omit-mode")`
display	`user.emacs("display-buffer")`
display line numbers mode	`user.emacs("display-line-numbers-mode")`
electric quote local mode	`user.emacs("electric-quote-local-mode")`
emacs lisp mode	`user.emacs("emacs-lisp-mode")`
emacs play	`user.emacs("kmacro-end-and-call-macro")`
emacs record	`user.emacs("kmacro-start-macro")`
emacs stop	`user.emacs("kmacro-end-macro")`
evaluate \| (evaluate \| eval) (exper \| expression)	`user.emacs("eval-expression")`
exchange	`user.emacs("exchange-point-and-mark")`
execute	`user.emacs("execute-extended-command")`
execute {user.emacs_command}	`user.emacs(emacs_command)`
execute <user.text>	`user.emacs("execute-extended-command")` `user.insert_formatted(text, "DASH_SEPARATED")`
file [loop] continue	`user.emacs("fileloop-continue")`
file open	`user.emacs("find-file")`
file rename	`user.emacs("rename-file")`
fill paragraph	`user.emacs("fill-paragraph")`
fundamental mode	`user.emacs("fundamental-mode")`
global [go] back	`user.emacs("pop-global-mark")`
global display line numbers mode	`user.emacs("global-display-line-numbers-mode")`
global highlight line mode	`user.emacs("global-hl-line-mode")`
global visual line mode	`user.emacs("global-visual-line-mode")`
go bottom	`edit.jump_line(number)` `user.emacs("recenter-top-bottom", -2)`
go top	`edit.jump_line(number)` `user.emacs("recenter-top-bottom", 0)`
go back	`user.emacs("pop-to-mark-command")`
go directory	`user.emacs("dired-jump")`
graph copy	`user.emacs("mark-paragraph")` `edit.copy()`
graph cut	`user.emacs("mark-paragraph")` `edit.cut()`
graph down	`edit.paragraph_end()`
graph kill	`user.emacs("kill-paragraph")`
graph mark	`user.emacs("mark-paragraph")`
graph up	`edit.paragraph_start()`
highlight line mode	`user.emacs("hl-line-mode")`
highlight lines matching [regex]	`user.emacs("highlight-lines-matching-regexp")`
highlight phrase	`user.emacs("highlight-phrase")`
highlight regex	`user.emacs("highlight-regexp")`
indent <user.number_signed_small>	`user.emacs("indent-rigidly", number_signed_small)`
insert char	`user.emacs("insert-char")`
last error \| error last	`user.emacs("previous-error")`
lisp interaction mode	`user.emacs("lisp-interaction-mode")`
manual	`user.emacs("man")`
manual <user.text>	`user.emacs("man")` `user.insert_formatted(text, "DASH_SEPARATED")`
mark	`user.emacs("set-mark-command")`
markdown mode	`user.emacs("markdown-mode")`
menu bar mode	`user.emacs("menu-bar-mode")`
merge keep (this \| current)	`user.emacs("smerge-keep-current")`
merge keep base	`user.emacs("smerge-keep-base")`
merge keep lower	`user.emacs("smerge-keep-lower")`
merge keep upper	`user.emacs("smerge-keep-upper")`
merge last	`user.emacs("smerge-prev")`
merge next	`user.emacs("smerge-next")`
merge refine	`user.emacs("smerge-refine")`
merge split	`user.emacs("smerge-resolve")`
next error \| error next	`user.emacs("next-error")`
occurs	`user.emacs("occur")`
other [split] shrink	`user.split_next()` `user.emacs("shrink-window-if-larger-than-buffer")` `user.split_last()`
other file open	`user.emacs("find-file-other-window")`
other go directory	`user.emacs("dired-jump-other-window")`
other scroll [down]	`user.emacs("scroll-other-window")`
other scroll up	`user.emacs("scroll-other-window-down")`
other switch	`user.emacs("switch-to-buffer-other-window")`
outline (backward \| back) [same level]	`user.emacs("outline-backward-same-level")`
outline (hide body \| [show] (overview \| outline))	`user.emacs("outline-hide-body")`
outline (previous \| last) [visible heading]	`user.emacs("outline-previous-visible-heading")`
outline demote	`user.emacs("outline-demote")`
outline forward [same level]	`user.emacs("outline-forward-same-level")`
outline hide [subtree]	`user.emacs("outline-hide-subtree")`
outline hide entry	`user.emacs("outline-hide-entry")`
outline hide leaves	`user.emacs("outline-hide-leaves")`
outline hide other	`user.emacs("outline-hide-other")`
outline hide sublevels	`user.emacs("outline-hide-sublevels")`
outline insert [heading]	`user.emacs("outline-insert-heading")`
outline mark [subtree]	`user.emacs("outline-mark-subtree")`
outline minor mode	`user.emacs("outline-minor-mode")`
outline move [subtree] down	`user.emacs("outline-move-subtree-down")`
outline move [subtree] up	`user.emacs("outline-move-subtree-up")`
outline next [visible heading]	`user.emacs("outline-next-visible-heading")`
outline promote	`user.emacs("outline-promote")`
outline show [subtree]	`user.emacs("outline-show-subtree")`
outline show all	`user.emacs("outline-show-all")`
outline show branches	`user.emacs("outline-show-branches")`
outline show children	`user.emacs("outline-show-children")`
outline show entry	`user.emacs("outline-show-entry")`
outline up [heading]	`user.emacs("outline-up-heading")`
overwrite mode	`user.emacs("overwrite-mode")`
package autoremove	`user.emacs("package-autoremove")`
package list \| [package] list packages	`user.emacs("list-packages")`
paredit mode	`user.emacs("paredit-mode")`
prefix	`user.emacs_prefix()`
prefix <user.number_signed_small>	`user.emacs_prefix(number_signed_small)`
profiler report	`user.emacs("profiler-report")`
profiler start	`user.emacs("profiler-start")`
profiler stop	`user.emacs("profiler-stop")`
project (dired \| directory)	`user.emacs("projectile-dired")`
project (switch [to buffer] \| buffer \| buff)	`user.emacs("projectile-switch-to-buffer")`
project [find] (regex \| grep)	`user.emacs("project-find-regexp")`
project [find] file	`user.emacs("project-find-file")`
project [query] replace regex	`user.emacs("project-query-replace-regexp")`
project [run] async shell command	`user.emacs("projectile-run-async-shell-command-in-root")`
project [run] eshell	`user.emacs("projectile-run-eshell")`
project [run] shell	`user.emacs("projectile-run-shell")`
project [run] shell command	`user.emacs("projectile-run-shell-command-in-root")`
project compile [project]	`user.emacs("projectile-compile-project")`
project kill [buffers]	`user.emacs("projectile-kill-buffers")`
project search	`user.emacs("project-search")`
project switch [project]	`user.emacs("project-switch-project")`
project vc dir	`user.emacs("project-vc-dir")`
python (shell switch \| switch [to] shell)	`user.emacs("python-shell-switch-to-shell")`
python [shell] send (function \| defun)	`user.emacs("python-shell-send-defun")`
python [shell] send buffer	`user.emacs("python-shell-send-buffer")`
python [shell] send file	`user.emacs("python-shell-send-file")`
python [shell] send region	`user.emacs("python-shell-send-region")`
python [shell] send statement	`user.emacs("python-shell-send-statement")`
python mode	`user.emacs("python-mode")`
rainbow mode	`user.emacs("rainbow-mode")`
read only mode	`user.emacs("read-only-mode")`
recenter	`user.emacs_prefix()` `user.emacs("recenter-top-bottom")`
rectangle (copy \| save) [to] register	`user.emacs("copy-rectangle-to-register")`
rectangle (yank \| paste)	`user.emacs("yank-rectangle")`
rectangle clear	`user.emacs("clear-rectangle")`
rectangle copy	`user.emacs("copy-rectangle-as-kill")`
rectangle delete	`user.emacs("delete-rectangle")`
rectangle kill	`user.emacs("kill-rectangle")`
rectangle number lines	`user.emacs("rectangle-number-lines")`
rectangle open	`user.emacs("open-rectangle")`
register (copy \| save)	`user.emacs("copy-to-register")`
register (copy \| save) rectangle	`user.emacs("copy-rectangle-to-register")`
register (paste \| insert)	`user.emacs("insert-register")`
register jump	`user.emacs("jump-to-register")`
replace	`user.emacs("query-replace")`
replace regex \| regex replace	`user.emacs("query-replace-regexp")`
reverse (lines \| region)	`user.emacs("reverse-region")`
run python	`user.emacs("run-python")`
save buffers kill emacs	`user.emacs("save-buffers-kill-emacs")`
save some buffers	`user.emacs("save-some-buffers")`
search [toggle] symbol	`user.emacs("isearch-forward-symbol")`
search [toggle] words	`user.emacs("isearch-forward-word")`
search back	`user.emacs("isearch-backward")`
search edit	`user.emacs_meta("e")`
search toggle case [fold \| sensitive]	`user.emacs_meta("c")`
search toggle regex	`user.emacs_meta("r")`
shell command	`user.emacs("shell-command")`
shell command inserting	`user.emacs_prefix()` `user.emacs("shell-command")`
shell command on region	`user.emacs("shell-command-on-region")`
shell command on region replacing	`user.emacs_prefix()` `user.emacs("shell-command-on-region")`
shell script mode	`user.emacs("sh-mode")`
smerge mode	`user.emacs("smerge-mode")`
sort lines	`user.emacs("sort-lines")`
sort words	`user.emacs("sort-words")`
split grow	`user.emacs("enlarge-window")`
split grow <number_small>	`user.emacs("enlarge-window", number_small)`
split narrow [<number_small>]	`user.emacs("shrink-window-horizontally", number_small or 1)`
split shrink	`user.emacs("shrink-window-if-larger-than-buffer")`
split shrink <number_small>	`amount = number_small or 1` `user.emacs("enlarge-window", 0 - amount)`
split solo	`user.emacs("delete-other-windows")`
split widen [<number_small>]	`user.emacs("enlarge-window-horizontally", number_small or 1)`
sub word mode	`user.emacs("subword-mode")`
switch	`user.emacs("switch-to-buffer")`
tab bar mode	`user.emacs("tab-bar-mode")`
talon script mode	`user.emacs("talonscript-mode")`
term (mark \| select)	`user.emacs("mark-sexp")`
term [auto] indent	`user.emacs("mark-sexp")` `user.emacs("indent-region")`
term copy	`user.emacs("mark-sexp")` `edit.copy()`
term down	`user.emacs("down-list")`
term end	`user.emacs("up-list")`
term freeze	`user.emacs("mark-sexp")` `user.emacs("comment-region")`
term kill	`user.emacs("kill-sexp")`
term left	`user.emacs("backward-sexp")`
term right	`user.emacs("forward-sexp")`
term up	`user.emacs("backward-up-list")`
term wipe	`user.emacs("kill-sexp", -1)`
text mode	`user.emacs("text-mode")`
transient mark mode	`user.emacs("transient-mark-mode")`
transpose (char \| chars)	`user.emacs("transpose-chars")`
transpose (graph \| graphs \| paragraphs)	`user.emacs("transpose-paragraphs")`
transpose (line \| lines)	`user.emacs("transpose-lines")`
transpose (sentence \| sentences)	`user.emacs("transpose-sentences")`
transpose (term \| terms)	`user.emacs("transpose-sexps")`
transpose [word \| words]	`user.emacs("transpose-words")`
unhighlight (regex \| phrase)	`user.emacs("unhighlight-regexp")`
unhighlight all	`user.emacs_prefix()` `user.emacs("unhighlight-regexp")`
vc (annotate \| blame)	`user.emacs("vc-annotate")`
view lossage	`user.emacs_help("l")`
visit tags table	`user.emacs("visit-tags-table")`
visual line mode	`user.emacs("visual-line-mode")`
whitespace mode	`user.emacs("whitespace-mode")`
xref find apropos	`user.emacs("xref-find-apropos")`
xref go back	`user.emacs("xref-go-back")`

Mindmap

`finder`

Context: user.community.apps.finder.finder.talon

Spoken	Backend
column view	`key(cmd-3)`
gallery view	`key(cmd-4)`
hide [finder]	`key(cmd-h)`
hide others	`app.window_hide_others()`
icon view	`key(cmd-1)`
list view	`key(cmd-2)`
options	`key(cmd-j)`
preferences	`key(cmd-,)`
search	`key(cmd-alt-f)`
sort by date added	`key(ctrl-alt-cmd-4)`
sort by date modified	`key(ctrl-alt-cmd-5)`
sort by date opened	`key(ctrl-alt-cmd-3)`
sort by kind	`key(ctrl-alt-cmd-2)`
sort by name	`key(ctrl-alt-cmd-1)`
sort by none	`key(ctrl-alt-cmd-0)`
sort by size	`key(ctrl-alt-cmd-6)`
trash it	`key(cmd-backspace)`

Mindmap

`firefox`

Context: user.community.apps.firefox.firefox.talon

Spoken	Backend
(sidebar \| panel) bookmarks	`user.firefox_bookmarks_sidebar()`
(sidebar \| panel) history	`user.firefox_history_sidebar()`
tab search	`browser.focus_address()` `insert("% ")`
tab search <user.text>	`browser.focus_address()` `insert("% {text}")` `key(down)`

Mindmap

`foxit_reader`

Context: user.community.apps.foxit_reader.foxit_reader.talon

Spoken	Backend
tab close all	`key(ctrl-shift-w)`

Mindmap

`gdb_active`

Context: user.community.apps.gdb.gdb_active.talon

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

Mindmap

`gdb_global`

Context: user.community.apps.gdb.gdb_global.talon

Spoken	Backend
[enable] debug mode	`user.gdb_enable()`
disable debug mode	`user.gdb_disable()`

Mindmap

`git`

Context: user.community.apps.git.git.talon

Spoken	Backend
git {user.git_command} [<user.git_arguments>]	`args = git_arguments or ""` `"git {git_command}{args} "`
git add clipboard	`insert("git add ")` `edit.paste()` `key(enter)`
git add highlighted	`edit.copy()` `insert("git add ")` `edit.paste()` `key(enter)`
git add patch	`"git add --patch\\n"`
git clone clipboard	`insert("git clone ")` `edit.paste()` `key(enter)`
git commit [<user.git_arguments>] message [<user.prose>]	`args = git_arguments or ""` `message = prose or ""` `user.insert_between('git commit{args} --message "{message}', '"')`
git commit highlighted	`edit.copy()` `insert("git add ")` `edit.paste()` `insert("\\ngit commit\\n")`
git diff (cached \| cashed)	`"git diff --cached\\n"`
git diff clipboard	`insert("git diff ")` `edit.paste()` `key(enter)`
git diff highlighted	`edit.copy()` `insert("git diff ")` `edit.paste()` `key(enter)`
git diff	`"git diff\\n"`
git show head	`"git show HEAD\\n"`
git stash [push] [<user.git_arguments>] message [<user.prose>]	`args = git_arguments or ""` `message = prose or ""` `user.insert_between('git stash push{args} --message "{message}', '"')`
git status	`"git status\\n"`

Mindmap

`git_add_patch`

Context: user.community.apps.git.git_add_patch.talon

Spoken	Backend
air	`key(a)` `key(enter)`
drum	`key(d)` `key(enter)`
near	`key(n)` `key(enter)`
quench	`key(q)` `key(enter)`
yank	`key(y)` `key(enter)`

Mindmap

`github_web`

Context: user.community.apps.github.github_web.talon

Spoken	Backend
((branch \| tag) switch \| switch (branch \| tag))	`key(w)`
(comment preview \| preview comment)	`key(ctrl-shift-p)`
(comment submit \| submit comment)	`key(ctrl-enter)`
(file find \| find file)	`key(t)`
(filter by \| edit) assignee	`key(a)`
(filter by \| edit) labels	`key(l)`
(filter by \| edit) milestones	`key(m)`
(form close \| close form)	`key(escape)`
(issue create \| create [an] issue)	`key(c)`
(issue create \| create issue)	`key(c)`
(issue open \| open issue)	`key(o)`
(keyboard shortcuts show \| show keyboard shortcuts)	`key(?)`
(selection move down \| move selection down)	`key(j)`
(selection move up \| move selection up)	`key(k)`
(selection open \| open selection)	`key(o)`
(selection toggle \| toggle selection)	`key(x)`
(show \| hide) annotations	`key(a)`
(show \| hide) comments	`key(i)`
(thread mute \| mute thread)	`key(shift-m)`
(url expand \| expand url)	`key(y)`
[web] editor open	`key(.)`
assignee set	`key(a)`
blame view open	`key(b)`
focus search	`key(s)`
fullscreen toggle	`key(shift-f)`
git hub full screen	`key(ctrl-shift-l)`
go to actions	`insert("ga")`
go to code	`insert("gc")`
go to dashboard	`insert("gd")`
go to discussions	`insert("gg")`
go to issues	`insert("gi")`
go to notifications	`insert("gn")`
go to projects	`insert("gb")`
go to pull requests	`insert("gp")`
go to wiki	`insert("gw")`
go to workflow	`insert("gf")`
jump to line	`key(l)`
label set	`key(l)`
mark as read	`key(y)`
milestone set	`key(m)`
other parent commit	`key(o)`
parent commit	`key(p)`
reply	`key(r)`
reviewer request	`key(q)`
search (issues \| [pull] requests)	`key(/)`
timestamps toggle	`key(shift-t)`

Mindmap

`gitlab`

Context: user.community.apps.gitlab.gitlab.talon

Spoken	Backend
(show \| hide) performance bar	`key(p)`
back to files	`key(escape)`
change assignee	`key(a)`
change label	`key(l)`
change milestone	`key(m)`
edit description	`key(e)`
edit last comment	`key(1)`
edit page	`key(e)`
go [to] (repository \| repo) charts	`insert("gd")`
go [to] (repository \| repo) graph [page]	`insert("gn")`
go [to] jobs [list]	`insert("gj")`
go [to] new issues [list]	`insert("i")`
go [to] project (commit \| commits) [list]	`insert("gc")`
go [to] project activity [feed]	`insert("gv")`
go [to] project cubes	`insert("gk")`
go [to] project environments	`insert("ge")`
go [to] project file search [page]	`key(t)`
go [to] project files [list]	`insert("gf")`
go [to] project home [page]	`insert("gp")`
go [to] project issues [list]	`insert("gi")`
go [to] project issues boards [list]	`insert("gb")`
go [to] project merge requests [list]	`insert("gm")`
go [to] project metrics	`insert("gl")`
go [to] project releases [list]	`insert("gr")`
go [to] project snippets [list]	`insert("gs")`
go [to] project wiki	`insert("gw")`
go to activity [page]	`key(shift-a)`
go to groups [page]	`key(shift-g)`
go to issues [page]	`key(shift-i)`
go to merge requests [page]	`key(shift-m)`
go to milestones [page]	`key(shift-l)`
go to projects [page]	`key(shift-p)`
go to snippets [page]	`key(shift-s)`
go to to do [list] [page]	`key(shift-t)`
next [unresolved] discussion	`key(n)`
next file	`key(])`
open permalink	`key(y)`
previous [unresolved] discussion	`key(p)`
previous file	`key([)`
right comment	`key(r)`
search page	`key(s)`
show shortcuts	`key(?)`
toggle mark down [preview]	`key(ctrl-shift-p)`

Mindmap

`i3wm`

Context: user.community.apps.i3wm.i3wm.talon

Spoken	Backend
(full screen \| scuba)	`user.i3wm_fullscreen()`
(launch shell \| koopa)	`user.i3wm_shell()`
(port flip \| flipper)	`user.i3wm_switch_to_workspace("back_and_forth")`
(shuffle \| move (win \| window) [to] last port)	`user.i3wm_move_to_workspace("back_and_forth")`
(shuffle \| move (win \| window) [to] port) <number_small>	`user.i3wm_move_to_workspace(number_small)`
(shuffle \| move (win \| window) down)	`user.i3wm_move("down")`
(shuffle \| move (win \| window) left)	`user.i3wm_move("left")`
(shuffle \| move (win \| window) right)	`user.i3wm_move("right")`
(shuffle \| move (win \| window) up)	`user.i3wm_move("up")`
(shuffle \| move) flipper	`user.i3wm_move_to_workspace("back_and_forth")`
(win \| window) default	`user.i3wm_layout()`
(win \| window) down	`user.i3wm_focus("down")`
(win \| window) horizontal	`user.i3wm_split("h")`
(win \| window) kill	`app.window_close()`
(win \| window) left	`user.i3wm_focus("left")`
(win \| window) right	`user.i3wm_focus("right")`
(win \| window) stacking	`user.i3wm_layout("stacking")`
(win \| window) tabbed	`user.i3wm_layout("tabbed")`
(win \| window) up	`user.i3wm_focus("up")`
(win \| window) vertical	`user.i3wm_split("v")`
[(show \| hide)] scratch	`user.i3wm_show_scratchpad()`
center window	`user.i3wm_move_position("center")`
focus child	`user.i3wm_focus("child")`
focus floating	`user.i3wm_focus("mode_toggle")`
focus parent	`user.i3wm_focus("parent")`
grow window	`user.i3wm_mode("resize")` `key(right:10)` `key(down:10)` `key(escape)` `sleep(200ms)` `user.i3wm_move_position("center")`
horizontal (shell \| terminal)	`user.i3wm_split("h")` `user.i3wm_shell()`
launch	`user.i3wm_launch()`
launch <user.text>	`user.i3wm_launch()` `sleep(100ms)` `insert("{text}")`
lock screen	`user.i3wm_lock()`
make scratch	`user.i3wm_move("scratchpad")`
murder	`user.deprecate_command("2023-02-04", "murder", "win kill")` `app.window_close()`
new scratch (shell \| window)	`user.i3wm_shell()` `sleep(200ms)` `user.i3wm_move("scratchpad")` `user.i3wm_show_scratchpad()`
next scratch	`user.i3wm_show_scratchpad()` `user.i3wm_show_scratchpad()`
port <number_small>	`user.i3wm_switch_to_workspace(number_small)`
port left	`user.i3wm_switch_to_workspace("prev")`
port right	`user.i3wm_switch_to_workspace("next")`
reload i three config	`user.i3wm_reload()`
resize mode	`user.i3wm_mode("resize")`
restart i three	`user.i3wm_restart()`
shrink window	`user.i3wm_mode("resize")` `key(left:10)` `key(up:10)` `key(escape)` `sleep(200ms)` `user.i3wm_move_position("center")`
toggle floating	`user.i3wm_float()`
vertical (shell \| terminal)	`user.i3wm_split("v")` `user.i3wm_shell()`

Mindmap

`jetbrains`

Context: user.community.apps.jetbrains.jetbrains.talon

Spoken	Backend
(done \| finish)	`user.idea("action EditorCompleteStatement")`
(go declaration \| follow)	`user.idea("action GotoDeclaration")`
(grow \| shrink) window down	`user.idea("action ResizeToolWindowDown")`
(grow \| shrink) window left	`user.idea("action ResizeToolWindowLeft")`
(grow \| shrink) window right	`user.idea("action ResizeToolWindowRight")`
(grow \| shrink) window up	`user.idea("action ResizeToolWindowUp")`
(pop deaf \| toggle definition)	`user.idea("action QuickImplementations")`
(search \| find) class	`user.idea("action GotoClass")`
(search \| find) file	`user.idea("action GotoFile")`
(search \| find) path	`user.idea("action FindInPath")`
(search \| find) symbol	`user.idea("action GotoSymbol")`
(search \| find) symbol <user.text>	`user.idea("action GotoSymbol")` `insert(text)` `key("enter")`
(toggle \| pop) (doc \| documentation)	`user.idea("action QuickJavaDoc")`
action [<user.text>]	`user.deprecate_command("2024-09-02", "action", "please")`
blacken	`user.idea("action BLACKReformatCode")`
change (recording \| recordings)	`user.idea("action EditMacros")`
change scheme	`user.idea("action QuickChangeScheme")`
clear last <user.text> [over]	`user.idea("find prev {text}, action EditorBackSpace")`
clear next <user.text> [over]	`user.idea("find next {text}, action EditorBackSpace")`
clear task	`user.idea("action tasks.close")`
clippings	`user.idea("action PasteMultiple")`
clone	`user.line_clone(number)`
collapse until	`user.select_range(number_1, number_2)` `user.idea("action CollapseRegion")`
collapse all	`user.idea("action CollapseAllRegions")`
collapse deep	`user.idea("action CollapseRegionRecursively")`
comment last <user.text> [over]	`user.idea("find prev {text}, action CommentByLineComment")`
comment next <user.text> [over]	`user.idea("find next {text}, action CommentByLineComment")`
complete	`user.idea("action CodeCompletion")`
complete <user.text> [over]	`user.idea("goto {number} 0,find next {text},action CodeCompletion")`
complete last <user.text> [over]	`user.idea("find prev {text},action CodeCompletion")`
complete next <user.text> [over]	`user.idea("find next {text},action CodeCompletion")`
configure servers	`user.idea("action tasks.configure.servers")`
continue	`user.idea("action Resume")`
copy path	`user.idea("action CopyPaths")`
copy pretty	`user.idea("action CopyAsRichText")`
copy reference	`user.idea("action CopyReference")`
create (template \| snippet)	`user.idea("action SaveAsTemplate")`
create file	`user.idea("action NewElement")`
create file <user.text> [over]	`user.idea("action NewElement")` `sleep(500ms)` `insert(text)`
create sibling	`user.idea("action NewElementSamePlace")`
create sibling <user.text> [over]	`user.idea("action NewElementSamePlace")` `sleep(500ms)` `insert(text)`
debug test	`user.idea("action DebugClass")`
expand until	`user.select_range(number_1, number_2)` `user.idea("action ExpandRegion")`
expand all	`user.idea("action ExpandAllRegions")`
expand deep	`user.idea("action ExpandRegionRecursively")`
extract constant	`user.idea("action IntroduceConstant")`
extract field	`user.idea("action IntroduceField")`
extract interface	`user.idea("action ExtractInterface")`
extract method	`user.idea("action ExtractMethod")`
extract parameter	`user.idea("action IntroduceParameter")`
extract variable	`user.idea("action IntroduceVariable")`
find (everywhere \| all)	`user.idea("action SearchEverywhere")`
find (everywhere \| all) <user.text> [over]	`user.idea("action SearchEverywhere")` `sleep(500ms)` `insert(text)`
fix (format \| formatting)	`user.idea("action ReformatCode")`
fix imports	`user.idea("action OptimizeImports")`
fix last (error \| air)	`user.idea("action GotoPreviousError")` `user.idea("action ShowIntentionActions")`
fix next (error \| air)	`user.idea("action GotoNextError")` `user.idea("action ShowIntentionActions")`
follow <user.text> [over]	`user.idea("goto {number} 0,find next {text},action GotoDeclaration")`
follow last <user.text> [over]	`user.idea("find prev {text},action GotoDeclaration")`
follow next <user.text> [over]	`user.idea("find next {text},action GotoDeclaration")`
git (annotate \| blame)	`user.idea("action Annotate")`
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 browse	`user.idea("action Github.Open.In.Browser")`
git commit	`user.idea("action CheckinProject")`
git log	`user.idea("action Vcs.ShowTabbedFileHistory")`
git menu	`user.idea("action Vcs.QuickListPopupAction")`
git pull	`user.idea("action Vcs.UpdateProject")`
git push	`user.idea("action CheckinProject")`
go <user.text> [over]	`user.idea("goto {number} 0,find next {text}, action EditorRight")`
go back	`user.idea("action Back")`
go breakpoints	`user.idea("action ViewBreakpoints")`
go browser task	`user.idea("action tasks.open.in.browser")`
go camel left	`user.camel_left()`
go camel right	`user.camel_right()`
go forward	`user.idea("action Forward")`
go implementation	`user.idea("action GotoImplementation")`
go last (error \| air)	`user.idea("action GotoPreviousError")`
go last (method \| function)	`user.idea("action MethodUp")`
go last <user.text> [over]	`user.idea("find prev {text}, action EditorRight")`
go last mark	`user.idea("action GotoPreviousBookmark")`
go mark	`user.idea("action ShowBookmarks")`
go mark	`user.idea("action GotoBookmark{number}")`
go next (error \| air)	`user.idea("action GotoNextError")`
go next (method \| function)	`user.idea("action MethodDown")`
go next <user.text> [over]	`user.idea("find next {text}, action EditorRight")`
go next mark	`user.idea("action GotoNextBookmark")`
go task	`user.idea("action tasks.goto")`
go test	`user.idea("action GotoTest")`
go type	`user.idea("action GotoTypeDeclaration")`
go usage	`user.idea("action FindUsages")`
grab	`user.idea_grab(number)`
insert generated <user.text> [over]	`user.idea("action Generate")` `sleep(500ms)` `insert(text)`
insert template <user.text> [over]	`user.idea("action InsertLiveTemplate")` `sleep(500ms)` `insert(text)`
paste until	`user.select_range(number_1, number_2)` `user.idea("action EditorPaste")`
paste last <user.text> [over]	`user.idea("find prev {text}, action EditorRight, action EditorPaste")`
paste next <user.text> [over]	`user.idea("find next {text}, action EditorRight, action EditorPaste")`
perfect	`user.idea("action CodeCompletion,action CodeCompletion")`
play recording	`user.idea("action PlaybackLastMacro")`
play recording <user.text> [over]	`user.idea("action PlaySavedMacrosAction")` `insert(text)` `sleep(500ms)` `Key("enter")`
pop parameters	`user.idea("action ParameterInfo")`
pop type	`user.idea("action ExpressionTypeInfo")`
quick fix <user.text> [over]	`user.idea("goto {number} 0,find next {text},action ShowIntentionActions")`
quick fix last <user.text> [over]	`user.idea("find prev {text},action ShowIntentionActions")`
quick fix next <user.text> [over]	`user.idea("find next {text},action ShowIntentionActions")`
recent	`user.idea("action RecentFiles")`
refactor	`user.idea("action Refactorings.QuickListPopupAction")`
refactor <user.text> [over]	`user.idea("goto {number} 0,find next {text}, action Refactorings.QuickListPopupAction")`
refactor until	`user.select_range(number_1, number_2)` `user.idea("action Refactorings.QuickListPopupAction")`
refactor <user.text>	`user.idea("action Refactorings.QuickListPopupAction")` `insert(text)`
refactor in line	`user.idea("action Inline")`
refactor last <user.text> [over]	`user.idea("find prev {text}, action Refactorings.QuickListPopupAction")`
refactor move	`user.idea("action Move")`
refactor next <user.text> [over]	`user.idea("find next {text}, action Refactorings.QuickListPopupAction")`
refactor rename	`user.idea("action RenameElement")`
reference <user.text> [over]	`user.idea("goto {number} 0,find next {text},action FindUsages")`
reference last <user.text> [over]	`user.idea("find prev {text},action FindUsages")`
reference next <user.text> [over]	`user.idea("find next {text},action FindUsages")`
rename <user.text> [over]	`user.idea("goto {number} 0,find next {text}, action RenameElement")`
rename file	`user.idea("action RenameFile")`
rename last <user.text> [over]	`user.idea("find prev {text}, action RenameElement")`
rename next <user.text> [over]	`user.idea("find next {text}, action RenameElement")`
replace last <user.text> [over]	`user.idea("find prev {text}, action EditorPaste")`
replace next <user.text> [over]	`user.idea("find next {text}, action EditorPaste")`
run menu	`user.idea("action ChooseRunConfiguration")`
run test	`user.idea("action RunClass")`
run test again	`user.idea("action Rerun")`
select (more \| this)	`user.idea("action EditorSelectWord")`
select <user.text> [over]	`user.idea("goto {number} 0,find next {text}")`
select camel left	`user.extend_camel_left()`
select camel right	`user.extend_camel_right()`
select last <user.text> [over]	`user.idea("find prev {text}")`
select less	`user.idea("action EditorUnSelectWord")`
select next <user.text> [over]	`user.idea("find next {text}")`
smart	`user.idea("action SmartTypeCompletion")`
step into	`user.idea("action StepInto")`
step over	`user.idea("action StepOver")`
step smart	`user.idea("action SmartStepInto")`
step to line	`user.idea("action RunToCursor")`
surround [this] with <user.text> [over]	`user.idea("action SurroundWith")` `sleep(500ms)` `insert(text)`
switch task	`user.idea("action tasks.switch")`
toggle (bread crumbs \| breadcrumbs)	`user.idea("action EditorToggleShowBreadcrumbs")`
toggle [line] breakpoint	`user.idea("action ToggleLineBreakpoint")`
toggle comment	`code.toggle_comment()`
toggle database	`user.idea("action ActivateDatabaseToolWindow")`
toggle database changes	`user.idea("action ActivateDatabaseChangesToolWindow")`
toggle debug	`user.idea("action ActivateDebugToolWindow")`
toggle distraction [free mode]	`user.idea("action ToggleDistractionFreeMode")`
toggle docked	`user.idea("action ToggleDockMode")`
toggle docker	`user.idea("action ActivateDockerToolWindow")`
toggle events	`user.idea("action ActivateEventLogToolWindow")`
toggle favorites	`user.idea("action ActivateFavoritesToolWindow")`
toggle find	`user.idea("action ActivateFindToolWindow")`
toggle floating	`user.idea("action ToggleFloatingMode")`
toggle fullscreen	`user.idea("action ToggleFullScreen")`
toggle git	`user.idea("action ActivateVersionControlToolWindow")`
toggle gutter icons	`user.idea("action EditorToggleShowGutterIcons")`
toggle indents	`user.idea("action EditorToggleShowIndentLines")`
toggle last	`user.idea("action JumpToLastWindow")`
toggle line numbers	`user.idea("action EditorToggleShowLineNumbers")`
toggle make	`user.idea("action ActivatemakeToolWindow")`
toggle mark	`user.idea("action ToggleBookmark")`
toggle mark	`user.idea("action ToggleBookmark{number}")`
toggle method breakpoint	`user.idea("action ToggleMethodBreakpoint")`
toggle navigation [bar]	`user.idea("action ViewNavigationBar")`
toggle parameters	`user.idea("action ToggleInlineHintsAction")`
toggle pinned	`user.idea("action TogglePinnedMode")`
toggle power save	`user.idea("action TogglePowerSave")`
toggle presentation [mode]	`user.idea("action TogglePresentationMode")`
toggle project	`user.idea("action ActivateProjectToolWindow")`
toggle recording	`user.idea("action StartStopMacroRecording")`
toggle run	`user.idea("action ActivateRunToolWindow")`
toggle split	`user.idea("action ToggleSideMode")`
toggle status [bar]	`user.idea("action ViewStatusBar")`
toggle structure	`user.idea("action ActivateStructureToolWindow")`
toggle terminal	`user.idea("action ActivateTerminalToolWindow")`
toggle to do	`user.idea("action ActivateTODOToolWindow")`
toggle tool buttons	`user.idea("action ViewToolButtons")`
toggle toolbar	`user.idea("action ViewToolBar")`
toggle whitespace	`user.idea("action EditorToggleShowWhitespaces")`
toggle windowed	`user.idea("action ToggleWindowedMode")`
toggle wrap	`user.idea("action EditorToggleUseSoftWraps")`

Mindmap

`keepassx_linux`

Context: user.community.apps.keepassx.keepassx_linux.talon

Spoken	Backend
(view \| edit) entry	`key(ctrl-e)`
[add] new entry	`key(ctrl-n)`
clone entry	`key(ctrl-k)`
close database	`key(ctrl-w)`
copy (earl \| url \| link)	`key(ctrl-alt-u)`
copy password	`key(ctrl-c)`
copy user [name]	`key(ctrl-b)`
delete entry	`key(ctrl-d)`
find	`key(ctrl-f)`
find <user.text>	`key(ctrl-f)` `insert("{text}")`
lock database	`key(ctrl-l)`
open (earl \| url \| link)	`key(ctrl-u)`
open database	`key(ctrl-o)`
quit	`key(ctrl-q)`
save database	`key(ctrl-s)`

Mindmap

`kubectl`

Context: user.community.apps.kubectl.kubectl.talon

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

Mindmap

`meld`

Context: user.community.apps.meld.meld.talon

Spoken	Backend
change (previous \| last)	`key(alt-up)`
change next	`key(alt-down)`

Mindmap

`orion`

Context: user.community.apps.orion.orion.talon

Spoken	Backend
tab overview [open \| close]	`user.overview_tabs()`

Mindmap

`outlook_web`

Context: user.community.apps.outlook.outlook_web.talon

Spoken	Backend
(expand \| collapse) [conversation]	`key(x)`
(perm \| permanently) delete [this] [message]	`key(shift\+delete)`
(prev \| previous) [pane] (item \| message)	`key(,)`
(select \| unselect) [this] message	`key(ctrl-space)`
[open] [the] (prev \| previous) item	`key(ctrl-,)`
[open] [the] next (item \| message)	`key(ctrl-.)`
archive	`key(e)`
categorize [this] message	`key(c)`
clear all [messages]	`key(esc)`
close [this] message	`key(esc)`
delete [this] [message]	`key(delete)`
discard [draft]	`key(esc)`
flag [this] [(item \| message)]	`key(insert)`
forward [this] message	`key(ctrl-shift-f)`
go [to] calendar	`key(ctrl-shift-2)`
go [to] inbox	`key(g)` `key(i)`
go [to] mail	`key(ctrl-shift-1)`
go [to] people	`key(ctrl-shift-3)`
go [to] to do	`key(ctrl-shift-4)`
go to drafts	`key(g)` `key(d)`
go to sent	`key(g)` `key(s)`
insert [a] [hyper] link	`key(ctrl-k)`
mark [this] [(item \| message)] as read	`key(q)`
mark [this] [(item \| message)] as unread	`key(u)`
mark [this] [message] [as] junk	`key(j)`
moved to [a] folder	`key(v)`
new folder	`key(shift-e)`
new message	`key(n)`
next reading [pane] (item \| message)	`key(.)`
open [this] message	`key(o)`
open [this] message [in] [a] new window	`key(shift-enter)`
reply [to] [this] message	`key(r)`
reply all [to] [this] message	`key(ctrl-shift-r)`
save [draft]	`key(ctrl-s)`
search [email]	`key(alt-q)`
select all [messages]	`key(ctrl-a)`
select first [message]	`key(home)`
select last [message]	`key(and)`
send [this] message	`key(alt-s)`
show help	`key(?)`
undo [last] [action]	`key(ctrl-z)`

Mindmap

`outlook_win`

Context: user.community.apps.outlook.outlook_win.talon

Spoken	Backend
forward	`key(ctrl-f)`
reply	`key(ctrl-r)`
reply all	`key(ctrl-shift-r)`
accept	`key(shift-f10 c c enter)`
archive	`key(alt h o 1)`
calendar	`key(ctrl-2)`
inbox	`key(ctrl-1)`
new e-mail	`key(ctrl-n)`

Mindmap

`protonmail`

Context: user.community.apps.protonmail.protonmail.talon

Spoken	Backend
(deselect \| unselect) all	`key(*)` `key(n)`
(go \| jump) [to] archive	`key(g)` `key(a)`
(go \| jump) [to] draft	`key(g)` `key(d)`
(go \| jump) [to] inbox	`key(g)` `key(i)`
(go \| jump) [to] sent	`key(g)` `key(s)`
(go \| jump) [to] spam	`key(g)` `key(x)`
(go \| jump) [to] starred	`key(g)` `key(.)`
(go \| jump) [to] trash	`key(g)` `key(t)`
(prev \| previous) contact	`key(up)`
(prev \| previous) message	`key(up)`
(show \| display) newer [message]	`key(k)`
(show \| display) older [message]	`key(j)`
[focus] search	`key(/)`
close active	`key(escape)`
confirm active	`key(enter)`
delete contact	`key(t)`
enter contact	`key(right)`
enter message	`key(right)`
exit contact	`key(left)`
exit message	`key(left)`
forward (message \| conversation)	`key(shift-f)`
go back	`key(escape)`
mark [as] read	`key(r)`
mark [as] unread	`key(u)`
move to archive	`key(a)`
move to inbox	`key(i)`
move to spam	`key(s)`
move to trash	`key(t)`
new message	`key(c)`
next contact	`key(down)`
next message	`key(down)`
open command [palette]	`key(shift-space)`
open help	`key(?)`
open message	`key(enter)`
reply all [to] (message \| conversation)	`key(shift-a)`
reply to (message \| conversation)	`key(shift-r)`
save contact	`key(ctrl-s)`
save message	`key(ctrl-s)`
select [the] (message \| conversation)	`key(x)`
select all	`key(*)` `key(a)`
send message	`key(ctrl-enter)`
star (message \| conversation)	`key(.)`

Mindmap

`rstudio_mac`

Context: user.community.apps.rstudio.rstudio_mac.talon

Spoken	Backend
(zoom \| show) all	`key("ctrl-shift-0")`
add cursor down	`key("ctrl-alt-down")`
add cursor up	`key("ctrl-alt-up")`
assign that	`key("alt--")`
close all tabs	`key("cmd-shift-w")`
debug continue	`key("shift-f5")`
debug finish (function \| funk)	`key("shift-f6")`
debug next	`key("f10")`
debug step into (function \| funk)	`key("shift-f4")`
debug stop	`key("shift-f8")`
define that	`key("f2")`
delete line	`key("cmd-d")`
delete word left	`key("alt-backspace")`
delete word right	`key("alt-delete")`
dev tools build	`key("cmd-shift-b")`
dev tools check	`key("cmd-shift-e")`
dev tools document	`key("cmd-shift-d")`
dev tools load all	`key("cmd-shift-l")`
dev tools test	`key("cmd-shift-t")`
duplicate line [down]	`key("cmd-alt-down")`
duplicate line up	`key("cmd-alt-up")`
expand selection	`key("shift-alt-cmd-up")`
find and replace	`key("cmd-f")`
find in files	`key("cmd-shift-f")`
find next	`key("cmd-g")`
find previous	`key("cmd-shift-g")`
find with selection	`key("cmd-e")`
fold all	`key("cmd-alt-o")`
fold that	`key("cmd-alt-l")`
go to (plots \| plot)	`key("ctrl-6")`
go to build	`key("ctrl-0")`
go to console	`key("ctrl-2")`
go to environment	`key("ctrl-8")`
go to files	`key("ctrl-5")`
go to first tab	`key("ctrl-shift-f11")`
go to git	`key("ctrl-9")`
go to help	`key("ctrl-3")`
go to history	`key("ctrl-4")`
go to last tab	`key("ctrl-shift-f12")`
go to line	`key("cmd-shift-alt-g")`
go to next tab	`key("ctrl-f12")`
go to omni	`key("ctrl-.")`
go to packages	`key("ctrl-7")`
go to previous tab	`key("ctrl-f11")`
go to section	`key("cmd-shift-alt-j")`
go to source	`key("ctrl-1")`
go to tab	`key("ctrl-shift-.")`
go to terminal	`key("alt-shift-t")`
help that	`key("f1")`
indent lines	`key("cmd-i")`
insert knitter chunk	`key("cmd-alt-i")`
jump back	`key("cmd-f9")`
jump forward	`key("cmd-f10")`
jump to matching	`key("ctrl-p")`
line down	`key("alt-down")`
line up	`key("alt-up")`
move active cursor down	`key("ctrl-alt-shift-down")`
move active cursor up	`key("ctrl-alt-shift-up")`
next plot	`key("cmd-alt-f12")`
pipe that	`key("cmd-shift-m")`
previous plot	`key("cmd-alt-f11")`
reduce selection	`key("shift-alt-cmd-down")`
reformat r code	`key("cmd-shift-a")`
reformat comment	`key("cmd-shift-/")`
restart r session	`key("cmd-shift-f10")`
run (function \| funk)	`key("cmd-alt-f")`
run all	`key("cmd-shift-s")`
run chunk	`key("cmd-alt-c")`
run document	`key("cmd-alt-r")`
run from top	`key("cmd-alt-b")`
run git commit	`key("ctrl-alt-m")`
run git diff	`key("ctrl-alt-d")`
run knitter	`key("cmd-shift-k")`
run next chunk	`key("cmd-alt-n")`
run previous chunks	`key("cmd-alt-p")`
run profiler	`key("cmd-shift-alt-p")`
run replace	`key("cmd-shift-j")`
run section	`key("cmd-alt-t")`
run spell check	`key("f7")`
run that	`key("cmd-enter")`
run to end	`key("cmd-alt-e")`
select to matching paren	`key("ctrl-shift-alt-e")`
select to paren	`key("ctrl-shift-e")`
toggle breakpoint	`key("shift-f9")`
toggle comment	`key("cmd-shift-c")`
unfold all	`key("cmd-shift-alt-o")`
unfold that	`key("cmd-shift-alt-l")`
zoom source	`key("ctrl-shift-1")`

Mindmap

`signal_linux`

Context: user.community.apps.signal.signal_linux.talon

Spoken	Backend
(first \| top) message	`key("ctrl-up")`
(last \| bottom) message	`key("ctrl-down")`
(next \| nav \| navigate) [by] (sec \| section)	`key("ctrl-t")`
(prev \| previous) (chat \| conversation)	`key("alt-down")`
(prev \| previous) unread	`key("alt-shift-down")`
[open] (pref \| preferences)	`key("ctrl-,")`
archive chat	`key("ctrl-shift-a")`
attach [file]	`key("ctrl-u")`
close chat	`key("ctrl-shift-c")`
delete [message]	`key("ctrl-shift-d")`
expand chat	`key("ctrl-shift-x")`
focus (chat \| composer)	`key("ctrl-shift-t")`
message details	`key("ctrl-d")`
next (chat \| conversation)	`key("alt-up")`
next unread	`key("alt-shift-up")`
open conversation menu	`key("ctrl-shift-l")`
open emoji	`key("ctrl-shift-j")`
open media	`key("ctrl-shift-m")`
open sticker	`key("ctrl-shift-s")`
react [message]	`key("ctrl-shift-e")`
record [voice] message	`key("ctrl-shift-v")`
remove [link] attachment	`key("ctrl-shift-p")`
remove [link] preview	`key("ctrl-p")`
reply [message]	`key("ctrl-shift-r")`
save attachment	`key("ctrl-s")`
search	`key("ctrl-f")`
search chat	`key("ctrl-shift-f")`
send it	`key("enter")`
send message	`key("ctrl-enter")`
show shortcuts	`key("ctrl-/")`
unarchive chat	`key("ctrl-shift-u")`

Mindmap

`slack`

Context: user.community.apps.slack.slack.talon

Spoken	Backend
([toggle] mute \| unmute)	`key(m)`
(element \| bit) (previous \| last)	`key(shift-tab)`
(element \| bit) [next]	`key(tab)`
(go \| undo \| toggle) full	`user.slack_toggle_full_screen()`
(insert command \| commandify)	`user.slack_insert_command()`
(italic \| italicize)	`user.slack_toggle_italic()`
(move \| next) focus	`app.notify("please use the voice command 'focus next' instead of 'next focus'")` key(ctrl-`)
(previous \| last) (element \| bit)	`app.notify("please use the voice command 'element last' instead of 'last element'")` `key(shift-tab)`
(previous \| last) (section \| zone)	`app.notify("please use the voice command 'section last' instead of 'last section'")` `key(shift-f6)`
(section \| zone) (previous \| last)	`user.slack_section_previous()`
(section \| zone) [next]	`user.slack_section_next()`
(slack \| lack) ([toggle] video)	`key(v)`
(slack \| lack) (bull \| bullet \| bulleted) [list]	`user.slack_start_bulleted_list()`
(slack \| lack) (history [next] \| back \| backward)	`user.slack_go_back()`
(slack \| lack) (my stuff \| activity)	`user.slack_open_activity()`
(slack \| lack) (number \| numbered) [list]	`user.slack_start_numbered_list()`
(slack \| lack) (quotes \| quotation)	`user.slack_insert_quotation()`
(slack \| lack) (react \| reaction)	`user.slack_add_reaction()`
(slack \| lack) (slap \| slaw \| slapper)	`edit.line_insert_down()`
(slack \| lack) (starred [items] \| stars)	`user.slack_open_starred_items()`
(slack \| lack) [channel] info	`user.slack_show_channel_info()`
(slack \| lack) [direct] messages	`user.slack_open_direct_messages()`
(slack \| lack) directory	`user.slack_open_directory()`
(slack \| lack) forward	`user.slack_go_forward()`
(slack \| lack) huddle	`user.slack_huddle()`
(slack \| lack) invite	`key(a)`
(slack \| lack) shortcuts	`user.slack_open_keyboard_shortcuts()`
(slack \| lack) snippet	`user.slack_create_snippet()`
(slack \| lack) threads	`user.slack_open_threads()`
(slack \| lack) unread [messages]	`user.slack_open_unread_messages()`
(strike \| strikethrough)	`user.slack_toggle_strikethrough()`
[next] (element \| bit)	`app.notify("please use the voice command 'element next' instead of 'next element'")` `key(tab)`
[next] (section \| zone)	`app.notify("please use the voice command 'section next' instead of 'next section'")` `key(f6)`
add line	`key(shift-enter)`
bold	`user.slack_toggle_bold()`
emote <user.text>	`":{text}:"`
focus (move \| next)	key(ctrl-`)
grab left	`key(shift-up)`
grab right	`key(shift-down)`
insert code	`user.slack_insert_code()`
insert link	`user.slack_insert_link()`
toggle left sidebar	`user.slack_toggle_left_sidebar()`
toggle right sidebar	`user.slack_toggle_right_sidebar()`
workspace	`user.slack_open_workspace(number)`

Mindmap

`stata_do_file_editor`

Context: user.community.apps.stata.stata_do_file_editor.talon

Spoken	Backend
do (all \| file)	`edit.select_all()` `edit.copy()` `key(ctrl-d)`
do line	`edit.select_line()` `key(ctrl-d)`
do this	`key(ctrl-d)`
do way down	`edit.extend_file_end()` `edit.copy()` `key(ctrl-d)`
do way up	`edit.extend_file_start()` `edit.copy()` `key(ctrl-d)`

Mindmap

`talon_debug_window`

Context: user.community.apps.talon.talon_debug_window.talon_debug_window.talon

Spoken	Backend
action {user.talon_actions}	`"{talon_actions}"`
application {user.talon_apps}	`"{talon_apps}"`
capture {user.talon_captures}	`"{talon_captures}"`
key <user.keys> over	`"{keys}"`
key <user.modifiers> over	`"{modifiers}"`
list {user.talon_lists}	`"{talon_lists}"`
set {user.talon_settings}	`"{talon_settings}"`
tag {user.talon_tags}	`"{talon_tags}"`

Mindmap

`talon_repl`

Context: user.community.apps.talon.talon_repl.talon_repl.talon

Spoken	Backend
debug {user.running} windows	`insert("actions.user.talon_debug_app_windows('{running}')")` `key(enter)`
debug action {user.talon_actions}	`insert("actions.find('{user.talon_actions}')")` `key(enter)`
debug all windows	`insert("actions.user.talon_pretty_print(ui.windows())")` `key(enter)`
debug list {user.talon_lists}	`insert("actions.user.talon_pretty_print(registry.lists['{talon_lists}'])")` `key(enter)`
debug modes	`insert("actions.user.talon_pretty_print(scope.get('mode'))")` `key(enter)`
debug running apps	`insert("actions.user.talon_pretty_print(ui.apps(background=False))")` `key(enter)`
debug scope {user.talon_scopes}	`insert("actions.user.talon_pretty_print(scope.get('{talon_scopes}'))")` `key(enter)`
debug settings	`insert("actions.user.talon_pretty_print(registry.settings)")` `key(enter)`
debug tags	`insert("actions.user.talon_pretty_print(registry.tags)")` `key(enter)`
test	`insert("sim('{phrase}')")` `key(enter)`
test last	`phrase = user.history_get(1)` `command = "sim('{phrase}')"` `insert(command)` `key(enter)`
test numb <number_small>	`phrase = user.history_get(number_small)` `command = "sim('{phrase}')"` `insert(command)` `key(enter)`

Mindmap

`taskwarrior_linux`

Context: user.community.apps.taskwarrior.taskwarrior_linux.talon

Spoken	Backend
(tasks \| task next)	`"task next\\n"`
task delete	`"task {number} delete"`
task done	`"task {number} done"`
task edit	`"task {number} edit"`
task add	`"task add "`
task add <user.text>	`"task add {text}\\n"`
task commands	`"task commands\\n"`
task help	`"task help\\n"`
task list	`"task list\\n"`
task list <user.text>	`"task list {text}\\n"`
task list orphans	`"task project: list\\n"`
task list project	`"task list project: "`
task list project <user.text>	`"task list project:{text}\\n"`
task list untagged	`"task tags.none: list\\n"`
task undo	`"task undo\\n"`
task version	`"task --version\\n"`

Mindmap

`teams`

Context: user.community.apps.teams.teams.talon

Spoken	Backend
(safe \| send) meeting request	`key(ctrl-s)`
[expand] compose [box]	`key(ctrl-shift-x)`
[go] [to] (prev \| previous) [list] item	`key(alt-up)`
[go] [to] (prev \| previous) section	`key(ctrl-shift-f6)`
[go] [to] compose [box]	`key(c)`
[go] [to] next [list] item	`key(alt-down)`
[go] [to] next section	`key(ctrl-f6)`
[go] [to] search	`key(ctrl-e)`
[go] [to] sharing toolbar	`key(ctrl-shift-space)`
[start] new chat	`key(ctrl-n)`
[start] new line	`key(shift-enter)`
accept audio call	`key(ctrl-shift-s)`
accept screen share	`key(ctrl-shift-a)`
accept video call	`key(ctrl-shift-a)`
attach file	`key(ctrl-o)`
close	`key(escape)`
decline call	`key(ctrl-shift-d)`
decline screen share	`key(ctrl-shift-d)`
go to	`key(ctrl-g)`
go to (prev \| previous) (day \| week)	`key(ctrl-alt-left)`
go to current time	`key(alt-.)`
go to next (day \| week)	`key(ctrl-alt-right)`
go to suggested time	`key(alt-shift-s)`
join [from] meeting [details]	`key(alt-shift-j)`
move [selected] team down	`key(ctrl-shift-down)`
move [selected] team up	`key(ctrl-shift-up)`
open (apps \| applications)	key(ctrl-`)
open activity	`key(ctrl-1)`
open calendar	`key(ctrl-4)`
open calls	`key(ctrl-6)`
open chat	`key(ctrl-2)`
open files	`key(ctrl-7)`
open filter	`key(ctrl-shift-f)`
open help	`key(f1)`
open planner	`key(ctrl-5)`
open settings	`key(ctrl-,)`
open teams	`key(ctrl-3)`
reply [to] [thread]	`key(r)`
schedule [a] meeting	`key(alt-shift-n)`
send	`key(ctrl-enter)`
show commands	`key(ctrl-/)`
show shortcuts	`key(ctrl-.)`
starch screen share session	`key(ctrl-shift-e)`
start audio call	`key(ctrl-shift-c)`
start video call	`key(ctrl-shift-u)`
toggle mute	`key(ctrl-shift-m)`
toggle video	`key(ctrl-shift-o)`
view day	`key(ctrl-alt-1)`
view week	`key(ctrl-alt-3)`
view work week	`key(ctrl-alt-2)`

Mindmap

`teams_mac`

Context: user.community.apps.teams.teams_mac.talon

Spoken	Backend
(raise \| lower) hand	`key(super-shift-k)`
(save \| send) meeting request	`key(super-s)`
[expand] compose [box]	`key(super-shift-x)`
[go] [to] (prev \| previous) [list] item	`key(alt-up)`
[go] [to] (prev \| previous) section	`key(super-shift-f6)`
[go] [to] compose [box]	`key(shift-alt-c)`
[go] [to] next [list] item	`key(alt-down)`
[go] [to] next section	`key(super-f6)`
[go] [to] search	`key(super-e)`
[go] [to] sharing toolbar	`key(super-shift-space)`
[start] new chat	`key(super-n)`
[start] new line	`key(shift-enter)`
accept audio call	`key(super-shift-s)`
accept screen share	`key(super-shift-a)`
accept video call	`key(super-shift-a)`
attach file	`key(shift-alt-o)`
attach local file	`key(shift-alt-o)` `sleep(100ms)` `key(down)` `key(space)`
close	`key(escape)`
decline call	`key(super-shift-d)`
decline screen share	`key(super-shift-d)`
go to	`key(super-g)`
go to (prev \| previous) (day \| week)	`key(super-alt-left)`
go to current time	`key(alt-.)`
go to next (day \| week)	`key(super-alt-right)`
go to suggested time	`key(alt-shift-s)`
join [from] meeting [details]	`key(alt-shift-j)`
leave team meeting	`key(super-shift-h)`
move [selected] team down	`key(super-shift-down)`
move [selected] team up	`key(super-shift-up)`
open (act \| activity)	`key(super-1)`
open (apps \| applications)	key(ctrl-`)
open calendar	`key(super-4)`
open calls	`key(super-5)`
open chat	`key(super-2)`
open files	`key(super-6)`
open filter	`key(super-shift-f)`
open help	`key(f1)`
open history	`key(super-shift-h)`
open settings	`key(super-,)`
open teams	`key(super-3)`
reply [to] [thread]	`key(shift-alt-r)`
reset	`key(escape)` `key(escape)` `key(escape)` `key(escape)`
schedule [a] meeting	`key(alt-shift-n)`
send message	`key(super-enter)`
show commands	`key(super-/)`
show shortcuts	`key(super-.)`
starch screen share session	`key(super-shift-e)`
start audio call	`key(super-shift-c)`
start video call	`key(super-shift-u)`
toggle mute	`key(super-shift-m)`
toggle video	`key(super-shift-o)`
view day	`key(super-alt-1)`
view shortcuts	`key(super-.)`
view week	`key(super-alt-3)`
view work week	`key(super-alt-2)`
zoom reset	`key(super-0)`

Mindmap

`termite`

Context: user.community.apps.termite.termite.talon

Spoken	Backend
shell insert	`key("escape")`
shell select	`key("ctrl-shift-space")`
shell yank	`key("y")`
visual line	`key("v")`
visual line mode	`key("V")`

Mindmap

`terraform`

Context: user.community.apps.terraform.terraform.talon

Spoken	Backend
terraform	`"terraform "`
terraform apply	`"terraform apply "`
terraform destroy	`"terraform destroy "`
terraform format	`"terraform fmt\\n"`
terraform format recursive	`"terraform fmt -recursive\\n"`
terraform help	`"terraform -help"`
terraform init	`"terraform init\\n"`
terraform init upgrade	`"terraform init -upgrade\\n"`
terraform plan	`"terraform plan\\n"`
terraform state move	`"terraform state mv "`
terraform validate	`"terraform validate\\n"`

Mindmap

`thunderbird`

Context: user.community.apps.thunderbird.thunderbird.talon

Spoken	Backend
(open address [book] \| address book \| open contacts)	`user.thunderbird_mod("shift-b")`
dev tools	`user.thunderbird_mod("shift-i")`
go (calendar \| lightning)	`user.thunderbird_mod("shift-c")`
go (mails \| messages \| inbox)	`user.tab_jump(1)`
go tasks	`user.thunderbird_mod("shift-d")`

Mindmap

`thunderbird_calendar`

Context: user.community.apps.thunderbird.thunderbird_calendar.talon

Spoken	Backend
(task \| event) delete	`key(delete)`
event new	`user.thunderbird_mod("i")`
task new	`user.thunderbird_mod("d")`
toggle today	`key(f11)`
view <number_small>	`user.thunderbird_calendar_view(number_small)`
view day	`user.thunderbird_calendar_view(1)`
view month	`user.thunderbird_calendar_view(4)`
view multi [week]	`user.thunderbird_calendar_view(3)`
view week	`user.thunderbird_calendar_view(2)`

Mindmap

`thunderbird_composer`

Context: user.community.apps.thunderbird.thunderbird_composer.talon

Spoken	Backend
(draft \| mail \| message) print	`user.thunderbird_mod("p")`
(draft \| mail \| message) save	`user.thunderbird_mod("s")`
(draft \| mail \| message) send	`user.thunderbird_mod("enter")`
(unformatted \| raw) paste	`user.thunderbird_mod("shift-v")`
cite paste	`user.thunderbird_mod("shift-o")`
go (inbox \| thunderbird \| main)	`user.thunderbird_mod("1")`
link delete	`user.thunderbird_mod("shift-k")`
link new	`user.thunderbird_mod("k")`
toggle contacts	`key(f9)`

Mindmap

`thunderbird_contacts`

Context: user.community.apps.thunderbird.thunderbird_contacts.talon

Spoken	Backend
contact delete	`key(delete)`
contact down	`key(down)`
contact edit	`user.thunderbird_mod("i")`
contact message	`user.thunderbird_mod("m")`
contact new	`user.thunderbird_mod("n")`
contact print	`user.thunderbird_mod("p")`
contact up	`key(up)`

Mindmap

`thunderbird_inbox`

Context: user.community.apps.thunderbird.thunderbird_inbox.talon

Spoken	Backend
(mail \| message) (down \| next)	`key(f)`
(mail \| message) (favorite \| unfavorite)	`key(s)`
(mail \| message) (ignore \| unignore)	`key(k)`
(mail \| message) (read \| unread)	`key(m)`
(mail \| message) (up \| last)	`key(b)`
(mail \| message) (watch \| unwatch)	`key(w)`
(mail \| message) archive	`key(a)`
(mail \| message) delete	`key(delete)`
(mail \| message) edit	`user.thunderbird_mod("e")`
(mail \| message) forward	`user.thunderbird_mod("l")`
(mail \| message) new	`user.thunderbird_mod("n")`
(mail \| message) open	`key(enter)`
(mail \| message) print	`user.thunderbird_mod("p")`
(mail \| message) reply all	`user.thunderbird_mod("shift-r")`
(mail \| message) reply list	`user.thunderbird_mod("shift-l")`
(mail \| message) reply sender	`user.thunderbird_mod("r")`
(mail \| message) save	`user.thunderbird_mod("s")`
(mail \| message) spam	`key(j)`
(mail \| message) suspend	`key(c)`
go home	`key(alt-home)`
toggle (mail \| message) [pane]	`key(f8)`
unread [mail \| message] (down \| next)	`key(n)`
unread [mail \| message] (up \| last)	`key(p)`

Mindmap

`thunderbird_tasks`

Context: user.community.apps.thunderbird.thunderbird_tasks.talon

Spoken	Backend
(task \| event) delete	`key(delete)`
event new	`user.thunderbird_mod("i")`
task new	`user.thunderbird_mod("d")`
toggle today	`key(f11)`

Mindmap

`tmux`

Context: user.community.apps.tmux.tmux.talon

Spoken	Backend
go split	`user.tmux_execute_command("display-panes -d 0")`
go split <user.arrow_key>	`user.tmux_keybind(arrow_key)`

Mindmap

`tmux_linux`

Context: user.community.apps.tmux.tmux_linux.talon

Spoken	Backend
mux	`"tmux "`
mux close pane	`key(ctrl-b)` `key(x)`
mux close window	`key(ctrl-b)` `key(&)`
mux kill session	`insert("tmux kill-session -t ")`
mux move <user.arrow_key>	`key(ctrl-b)` `key(arrow_key)`
mux name session	`key(ctrl-b)` `key($)`
mux new session	`insert("tmux new ")`
mux new window	`key(ctrl-b)` `key(c)`
mux next pane	`key(ctrl-b)` `key(o)`
mux next window	`key(ctrl-b)` `key(n)`
mux pane numbers	`key(ctrl-b)` `key(q)`
mux previous window	`key(ctrl-b)` `key(p)`
mux rename window	`key(ctrl-b)` `key(,)`
mux sessions	`key(ctrl-b)` `key(s)`
mux split horizontal	`key(ctrl-b)` `key(%)`
mux split vertical	`key(ctrl-b)` `key(")`
mux window	`key(ctrl-b)` `key('{number}')`

Mindmap

`twitter`

Context: user.community.apps.twitter.twitter.talon

Spoken	Backend
(show shortcuts \| shortcuts help)	`key(?)`
block account	`key(x)`
bookmark	`key(b)`
display settings	`insert("gd")`
expand photo	`key(o)`
go book marks	`insert("gb")`
go direct messages	`insert("gm")`
go explore	`insert("ge")`
go home	`insert("gh")`
go likes	`insert("gl")`
go lists	`insert("gi")`
go mentions	`insert("gr")`
go notifications	`insert("gn")`
go profile	`insert("gp")`
go settings	`insert("gs")`
go to user	`insert("gu")`
like message	`key(l)`
load new tweet	`key(.)`
mute account	`key(urge)`
new direct message	`key(m)`
new tweet	`key(n)`
next tweet	`key(j)`
open details	`key(enter)`
page down	`key(space)`
previous tweet	`key(k)`
re tweet [message]	`key(t)`
reply message	`key(r)`
search	`key(/)`
send tweet	`key(ctrl-enter)`
share tweet	`key(s)`

Mindmap

`visual_studio`

Context: user.community.apps.visualstudio.visual_studio.talon

Spoken	Backend
(go declaration \| follow)	`key(ctrl-f12)`
break point	`key(f9)`
debug continue	`key(f5)`
debug start	`key(f5)`
debug step into	`key(f11)`
debug step out [of]	`key(f10)`
debug stopper	`key(shift-f5)`
definition peek	`key(alt-f12)`
definition show	`key(f12)`
file create	`key(ctrl-n)`
file hunt [<user.text>]	`key(ctrl-shift-t)` `insert(text or "")`
file rename	`key(ctrl-[ s f2)`
file reveal	`key(ctrl-[ s)`
fold definitions	`key(ctrl-m ctrl-o)`
fold toggle	`key(ctrl-m ctrl-m)`
fold toggle all	`key(ctrl-m ctrl-l)`
format selection	`key(ctrl-k ctrl-f)`
format that	`key(ctrl-k ctrl-d)`
fullscreen switch	`key(shift-alt-enter)`
go back	`key(ctrl--)`
go forward	`key(ctrl-shift--)`
go implementation	`key(f12)`
go last mark	`key(ctrl-k ctrl-p)`
go marks	`key(ctrl-k ctrl-w)`
go member [<user.text>]	`key(alt-\)` `sleep(100ms)` `insert(text or "")`
go next mark	`key(ctrl-k ctrl-n)`
go recent [<user.text>]	`key(ctrl-1 ctrl-r)` `sleep(100ms)` `insert(text or "")`
go type [<user.text>]	`key(ctrl-1 ctrl-t)` `sleep(100ms)` `insert(text or "")`
go usage	`key(shift-f12)`
hint show	`key(ctrl-shift-space)`
imports fix	`key(ctrl-r ctrl-g)`
panel breakpoints	`key(ctrl-alt-b)`
panel class	`key(ctrl-shift-c)`
panel design	`key(shift-f7)`
panel errors	`key(ctrl-\ ctrl-e)`
panel marks	`key(ctrl-k ctrl-w)`
panel output	`key(ctrl-alt-o)`
panel properties	`key(f4)`
panel solution	`key(ctrl-alt-l)`
refactor field	`key(ctrl-r ctrl-e)`
refactor interface	`key(ctrl-r ctrl-i)`
refactor method	`key(ctrl-r ctrl-m)`
refactor remove parameters	`key(ctrl-r ctrl-v)`
refactor reorder parameters	`key(ctrl-r ctrl-o)`
refactor that	`key(ctrl-r ctrl-r)`
references find	`key(shift-f12)`
show settings	`key(alt-t o)`
step over	`key(f10)`
toggle mark	`key(ctrl-k ctrl-k)`
wrap switch	`key(ctrl-e ctrl-w)`

Mindmap

`vivaldi`

Context: user.community.apps.vivaldi.vivaldi.talon

Spoken	Backend
(sidebar \| panel) bookmarks	`user.vivaldi_bookmarks_panel()`
(sidebar \| panel) downloads	`user.vivaldi_downloads_panel()`
(sidebar \| panel) history	`user.vivaldi_history_panel()`
(sidebar \| panel) notes	`user.vivaldi_notes_panel()`

Mindmap

`vscode`

Context: user.community.apps.vscode.vscode.talon

Spoken	Backend
(go declaration \| follow)	`user.vscode("editor.action.revealDefinition")`
bar explore	`user.vscode("workbench.view.explorer")`
bar extensions	`user.vscode("workbench.view.extensions")`
bar marks	`user.vscode("workbench.view.extension.bookmarks")`
bar outline	`user.vscode("outline.focus")`
bar run	`user.vscode("workbench.view.debug")`
bar search	`user.vscode("workbench.view.search")`
bar source	`user.vscode("workbench.view.scm")`
bar switch	`user.vscode("workbench.action.toggleSidebarVisibility")`
bar test	`user.vscode("workbench.view.testing.focus")`
break point	`user.vscode("editor.debug.action.toggleBreakpoint")`
cell last	`user.vscode("notebook.focusPreviousEditor")`
cell next	`user.vscode("notebook.focusNextEditor")`
cell run	`user.vscode("notebook.cell.execute")`
cell run above	`user.vscode("notebook.cell.executeCellsAbove")`
centered switch	`user.vscode("workbench.action.toggleCenteredLayout")`
change last	`key(shift-alt-f5)`
change next	`key(alt-f5)`
close all tabs	`user.vscode("workbench.action.closeAllEditors")`
close other tabs	`user.vscode("workbench.action.closeOtherEditors")`
close tabs way left	`user.vscode("workbench.action.closeEditorsToTheLeft")`
close tabs way right	`user.vscode("workbench.action.closeEditorsToTheRight")`
copy line down	`user.vscode("editor.action.copyLinesDownAction")`
copy line up	`user.vscode("editor.action.copyLinesUpAction")`
curse redo	`user.vscode("cursorRedo")`
curse undo	`user.vscode("cursorUndo")`
debug clean	`user.vscode("workbench.debug.panel.action.clearReplAction")`
debug console	`user.vscode("workbench.debug.action.toggleRepl")`
debug continue	`user.vscode("workbench.action.debug.continue")`
debug pause	`user.vscode("workbench.action.debug.pause")`
debug restart	`user.vscode("workbench.action.debug.restart")`
debug start	`user.vscode("workbench.action.debug.start")`
debug step into	`user.vscode("workbench.action.debug.stepInto")`
debug step out [of]	`user.vscode("workbench.action.debug.stepOut")`
debug stopper	`user.vscode("workbench.action.debug.stop")`
definition peek	`user.vscode("editor.action.peekDefinition")`
definition show	`user.vscode("editor.action.revealDefinition")`
definition side	`user.vscode("editor.action.revealDefinitionAside")`
file clone	`user.vscode("fileutils.duplicateFile")` `sleep(150ms)`
file copy local [path]	`user.vscode("copyRelativeFilePath")`
file copy name	`user.vscode("fileutils.copyFileName")`
file copy path	`user.vscode("copyFilePath")`
file create	`user.vscode("workbench.action.files.newUntitledFile")`
file create relative	`user.vscode("fileutils.newFile")`
file create root	`user.vscode("fileutils.newFileAtRoot")`
file create sibling	`user.vscode_and_wait("explorer.newFile")`
file delete	`user.vscode("fileutils.removeFile")` `sleep(150ms)`
file hunt (pace \| paste)	`user.vscode("workbench.action.quickOpen")` `sleep(50ms)` `edit.paste()`
file hunt [<user.text>]	`user.vscode("workbench.action.quickOpen")` `sleep(50ms)` `insert(text or "")`
file move	`user.vscode("fileutils.moveFile")` `sleep(150ms)`
file open folder	`user.vscode("revealFileInOS")`
file rename	`user.vscode("fileutils.renameFile")` `sleep(150ms)`
file reveal	`user.vscode("workbench.files.action.showActiveFileInExplorer")`
focus editor	`user.vscode("workbench.action.focusActiveEditorGroup")`
fold all	`user.vscode("editor.foldAll")`
fold comments	`user.vscode("editor.foldAllBlockComments")`
fold five	`user.vscode("editor.foldLevel5")`
fold four	`user.vscode("editor.foldLevel4")`
fold one	`user.vscode("editor.foldLevel1")`
fold seven	`user.vscode("editor.foldLevel7")`
fold six	`user.vscode("editor.foldLevel6")`
fold that	`user.vscode("editor.fold")`
fold those	`user.vscode("editor.foldAllMarkerRegions")`
fold three	`user.vscode("editor.foldLevel3")`
fold two	`user.vscode("editor.foldLevel2")`
format selection	`user.vscode("editor.action.formatSelection")`
format that	`user.vscode("editor.action.formatDocument")`
full screen	`user.vscode("workbench.action.toggleFullScreen")`
fullscreen switch	`user.vscode("workbench.action.toggleFullScreen")`
git branch	`user.vscode("git.branchFrom")`
git branch this	`user.vscode("git.branch")`
git checkout [<user.text>]	`user.vscode("git.checkout")` `sleep(50ms)` `insert(text or "")`
git commit [<user.text>]	`user.vscode("git.commitStaged")` `sleep(100ms)` `user.insert_formatted(text or "", "CAPITALIZE_FIRST_WORD")`
git commit amend	`user.vscode("git.commitStagedAmend")`
git commit undo	`user.vscode("git.undoCommit")`
git diff	`user.vscode("git.openChange")`
git fetch	`user.vscode("git.fetch")`
git fetch all	`user.vscode("git.fetchAll")`
git ignore	`user.vscode("git.ignore")`
git merge	`user.vscode("git.merge")`
git output	`user.vscode("git.showOutput")`
git pull	`user.vscode("git.pullRebase")`
git push	`user.vscode("git.push")`
git push force	`user.vscode("git.pushForce")`
git rebase abort	`user.vscode("git.rebaseAbort")`
git reveal	`user.vscode("git.revealInExplorer")`
git revert	`user.vscode("git.revertChange")`
git stage	`user.vscode("git.stage")`
git stage all	`user.vscode("git.stageAll")`
git stash	`user.vscode("git.stash")`
git stash pop	`user.vscode("git.stashPop")`
git status	`user.vscode("workbench.scm.focus")`
git sync	`user.vscode("git.sync")`
git unstage	`user.vscode("git.unstage")`
git unstage all	`user.vscode("git.unstageAll")`
go back	`user.vscode("workbench.action.navigateBack")`
go edit	`user.vscode("workbench.action.navigateToLastEditLocation")`
go forward	`user.vscode("workbench.action.navigateForward")`
go implementation	`user.vscode("editor.action.goToImplementation")`
go last mark	`user.vscode("bookmarks.jumpToPrevious")`
go marks	`user.deprecate_command("2023-06-06", "go marks", "bar marks")` `user.vscode("workbench.view.extension.bookmarks")`
go next mark	`user.vscode("bookmarks.jumpToNext")`
go recent [<user.text>]	`user.vscode("workbench.action.openRecent")` `sleep(50ms)` `insert(text or "")` `sleep(250ms)`
go type	`user.vscode("editor.action.goToTypeDefinition")`
go usage	`user.vscode("references-view.find")`
go view [<user.text>]	`user.vscode("workbench.action.openView")` `insert(user.text or "")`
hierarchy peek	`user.vscode("editor.showCallHierarchy")`
hint show	`user.vscode("editor.action.triggerParameterHints")`
hover show	`user.vscode("editor.action.showHover")`
imports fix	`user.vscode("editor.action.organizeImports")`
install local	`user.vscode("workbench.extensions.action.installVSIX")`
join lines	`user.vscode("editor.action.joinLines")`
language switch	`user.vscode("workbench.action.editor.changeLanguageMode")`
maximize	`user.vscode("workbench.action.minimizeOtherEditors")`
minimap	`user.vscode("editor.action.toggleMinimap")`
panel control	`user.vscode("workbench.panel.repl.view.focus")`
panel output	`user.vscode("workbench.panel.output.focus")`
panel problems	`user.vscode("workbench.panel.markers.view.focus")`
panel switch	`user.vscode("workbench.action.togglePanel")`
panel terminal	`user.vscode("workbench.action.terminal.focus")`
preview markdown	`user.vscode("markdown.showPreview")`
problem fix	`user.vscode("problems.action.showQuickFixes")`
problem last	`user.vscode("editor.action.marker.prevInFiles")`
problem next	`user.vscode("editor.action.marker.nextInFiles")`
pull request	`user.vscode("pr.create")`
refactor rename	`user.vscode("editor.action.rename")`
refactor that	`user.vscode("editor.action.refactor")`
refactor this	`user.vscode("editor.action.refactor")`
references find	`user.vscode("references-view.find")`
references show	`user.vscode("editor.action.goToReferences")`
rename that	`user.vscode("editor.action.rename")`
replace here	`user.replace("")` `key(cmd-alt-l)`
restore	`user.vscode("workbench.action.evenEditorWidths")`
save ugly	`user.vscode("workbench.action.files.saveWithoutFormatting")`
select (more \| this)	`user.vscode("editor.action.smartSelect.expand")`
select breadcrumb	`user.vscode("breadcrumbs.focusAndSelect")`
select less	`user.vscode("editor.action.smartSelect.shrink")`
select word	`user.vscode("editor.action.addSelectionToNextFindMatch")`
show settings	`user.vscode("workbench.action.openGlobalSettings")`
show settings folder	`user.vscode("workbench.action.openFolderSettings")`
show settings folder json	`user.vscode("workbench.action.openFolderSettingsFile")`
show settings json	`user.vscode("workbench.action.openSettingsJson")`
show settings workspace	`user.vscode("workbench.action.openWorkspaceSettings")`
show settings workspace json	`user.vscode("workbench.action.openWorkspaceSettingsFile")`
show shortcuts	`user.vscode("workbench.action.openGlobalKeybindings")`
show shortcuts json	`user.vscode("workbench.action.openGlobalKeybindingsFile")`
show snippets	`user.vscode("workbench.action.openSnippets")`
skip word	`user.vscode("editor.action.moveSelectionToNextFindMatch")`
snip (last \| previous)	`user.vscode("jumpToPrevSnippetPlaceholder")`
snip next	`user.vscode("jumpToNextSnippetPlaceholder")`
step over	`user.vscode("workbench.action.debug.stepOver")`
suggest show	`user.vscode("editor.action.triggerSuggest")`
symbol hunt [<user.text>]	`user.vscode("workbench.action.gotoSymbol")` `sleep(50ms)` `insert(text or "")`
symbol hunt all [<user.text>]	`user.vscode("workbench.action.showAllSymbols")` `sleep(50ms)` `insert(text or "")`
task run [<user.text>]	`user.vscode("workbench.action.tasks.runTask")` `insert(user.text or "")`
terminal <number_small>	`user.vscode_terminal(number_small)`
terminal external	`user.vscode("workbench.action.terminal.openNativeConsole")`
terminal last	`user.vscode("workbench.action.terminal.focusPrevious")`
terminal new	`user.vscode("workbench.action.terminal.new")`
terminal next	`user.vscode("workbench.action.terminal.focusNext")`
terminal scroll down	`user.vscode("workbench.action.terminal.scrollDown")`
terminal scroll up	`user.vscode("workbench.action.terminal.scrollUp")`
terminal split	`user.vscode("workbench.action.terminal.split")`
terminal toggle	`user.vscode_and_wait("workbench.action.terminal.toggleTerminal")`
terminal trash	`user.vscode("workbench.action.terminal.kill")`
terminal zoom	`user.vscode("workbench.action.toggleMaximizedPanel")`
test cancel	`user.vscode("testing.cancelRun")`
test debug	`user.vscode("testing.debugAtCursor")`
test debug all	`user.vscode("testing.debugAll")`
test debug failed	`user.vscode("testing.debugFailTests")`
test debug file	`user.vscode("testing.debugCurrentFile")`
test debug last	`user.vscode("testing.debugLastRun")`
test run	`user.vscode("testing.runAtCursor")`
test run all	`user.vscode("testing.runAll")`
test run failed	`user.vscode("testing.reRunFailTests")`
test run file	`user.vscode("testing.runCurrentFile")`
test run last	`user.vscode("testing.reRunLastRun")`
theme switch	`user.vscode("workbench.action.selectTheme")`
toggle mark	`user.vscode("bookmarks.toggle")`
unfold all	`user.vscode("editor.unfoldAll")`
unfold that	`user.vscode("editor.unfold")`
unfold those	`user.vscode("editor.unfoldRecursively")`
whitespace trim	`user.vscode("editor.action.trimTrailingWhitespace")`
window close	`user.vscode("workbench.action.closeWindow")`
window reload	`user.vscode("workbench.action.reloadWindow")`
wrap switch	`user.vscode("editor.action.toggleWordWrap")`
zen switch	`user.vscode("workbench.action.toggleZenMode")`

Mindmap

`windbg`

Context: user.community.apps.windbg.windbg.talon

Spoken	Backend
(lib \| library) <user.windows_dlls>	`"{windows_dlls}"`
add microsoft symbols	`insert("srvC:\\symbolshttp://msdl.microsoft.com/download/symbols;\\n")`
dereference pointer	`user.insert_between("poi(", ")")`
display pointers	`insert("dps ")`
dump function params	`"r @rcx,@rdx,@r8,@r9\\n"`
force reload symbols	`insert(".reload /f\\n")`
loaded modules	`insert("lm l\\n")`
open help	`insert(".hh\\n")`
register <user.registers>	`key(@)` `insert("{registers}")`
reload symbols	`insert(".reload\\n")`
show version	`key(ctrl-alt-w)`
view (processes \| threads)	`key(alt-9)`
view call stack	`key(alt-6)`
view command	`key(alt-1)`
view disassembly	`key(alt-7)`
view locals	`key(alt-3)`
view memory	`key(alt-5)`
view registers	`key(alt-4)`
view scratch pad	`key(alt-8)`
view watch	`key(alt-2)`

Mindmap

`windows_explorer`

Context: user.community.apps.windows_explorer.windows_explorer.talon

Spoken	Backend
go app data	`user.file_manager_open_directory("%AppData%")`
go program files	`user.file_manager_open_directory("%ProgramFiles%")`

Mindmap

`windows_terminal`

Context: user.community.apps.windows_terminal.windows_terminal.talon

Spoken	Backend
find it	`edit.find()`
find it	`key(escape)` `edit.find("{phrase}\\n")`
focus down	`key(ctrl-alt-shift-down)`
focus left	`key(ctrl-alt-shift-left)`
focus right	`key(ctrl-alt-shift-right)`
focus up	`key(ctrl-alt-shift-up)`
settings open	`key(ctrl-,)`
term menu	`key(ctrl-shift-f1)`

Mindmap

`wsl`

Context: user.community.apps.wsl.wsl.talon

Spoken	Backend
go <user.letter>	`user.file_manager_open_volume("/mnt/{letter}")`
(wsl \| weasel) reset path detection	`user.wsl_reset_path_detection()`
(wsl \| weasel) speak	`user.wsl_speak()`

Mindmap

`edit`

Context: user.community.core.edit.edit.talon

Spoken	Backend
(indent less \| out dent)	`edit.indent_less()`
(pace \| paste) (that \| it)	`edit.paste()`
(pace \| paste) enter	`edit.paste()` `key(enter)`
(pad \| padding) <user.symbol_key>+	`insert(" ")` `user.insert_many(symbol_key_list)` `insert(" ")`
[go] line mid	`user.line_middle()`
<user.edit_action> <user.edit_modifier>	`user.edit_command(edit_action, edit_modifier)`
clone line	`edit.line_clone()`
clone that	`edit.selection_clone()`
copy that	`edit.copy()`
cut that	`edit.cut()`
file save	`edit.save()`
file save all	`edit.save_all()`
find it	`edit.find()`
go <user.navigation_step>+	`user.perform_navigation_steps(navigation_step_list)`
go bottom	`edit.file_end()`
go line end \| tail	`edit.line_end()`
go line start \| head	`edit.line_start()`
go page down	`edit.page_down()`
go page up	`edit.page_up()`
go top	`edit.file_start()`
go way down	`edit.file_end()`
go way left	`edit.line_start()` `edit.line_start()`
go way right	`edit.line_end()`
go way up	`edit.file_start()`
hunt next	`edit.find_next()`
hunt previous	`edit.find_previous()`
indent [more]	`edit.indent_more()`
new line above	`edit.line_insert_up()`
new line below \| slap	`edit.line_insert_down()`
next one	`edit.find_next()`
padding	`user.insert_between(" ", " ")`
paste match	`edit.paste_match_style()`
redo that	`edit.redo()`
scroll down	`edit.page_down()`
scroll up	`edit.page_up()`
undo that	`edit.undo()`
zoom in	`edit.zoom_in()`
zoom out	`edit.zoom_out()`
zoom reset	`edit.zoom_reset()`

Mindmap

`edit_text_file`

Context: user.community.core.edit_text_file.edit_text_file.talon

Spoken	Backend
customize {user.edit_text_file}	`user.edit_text_file(edit_text_file)` `sleep(500ms)` `edit.file_end()`

Mindmap

`file_extension`

Context: user.community.core.file_extension.file_extension.talon

Spoken	Backend
{user.file_extension}	`"{file_extension}"`

Mindmap

`help`

Context: user.community.core.help.help.talon

Spoken	Backend
(help formatters \| help format \| format help)	`user.help_formatters(user.get_formatters_words(), false)`
(help re formatters \| help re format \| re format help)	`user.help_formatters(user.get_reformatters_words(), true)`
help active	`user.help_context_enabled()`
help alphabet	`user.help_list("user.letter")`
help arrows	`user.help_list("user.arrow_key")`
help context {user.help_contexts}	`user.help_selected_context(help_contexts)`
help context	`user.help_context()`
help function keys	`user.help_list("user.function_key")`
help help	`user.help_search("help")`
help modifier	`user.help_list("user.modifier_key")`
help numbers	`user.help_list("user.number_key")`
help punctuation	`user.help_list("user.punctuation")`
help scope	`user.help_scope_toggle()`
help search <user.text>	`user.help_search(text)`
help snip	`user.help_list("user.snippet")`
help special keys	`user.help_list("user.special_key")`
help symbols	`user.help_list("user.symbol_key")`

Mindmap

`help_open`

Context: user.community.core.help.help_open.talon

Spoken	Backend
help (previous \| last)	`user.help_previous()`
help	`user.help_select_index(number - 1)`
help close	`user.help_hide()`
help next	`user.help_next()`
help refresh	`user.help_refresh()`
help return	`user.help_return()`

Mindmap

`help_scope_open`

Context: user.community.core.help.help_scope_open.talon

Spoken	Backend
scope (hide \| close)	`user.help_scope_toggle()`

Mindmap

`homophones`

Context: user.community.core.homophones.homophones.talon

Spoken	Backend
phones (hide \| exit)	`user.homophones_hide()`
phones [<user.ordinals>] word left	`n = ordinals or 1` `user.words_left(n - 1)` `edit.extend_word_left()` `user.homophones_show_selection()`
phones [<user.ordinals>] word right	`n = ordinals or 1` `user.words_right(n - 1)` `edit.extend_word_right()` `user.homophones_show_selection()`
phones <user.homophones_canonical>	`user.homophones_show(homophones_canonical)`
phones force	`user.homophones_force_show_selection()`
phones force <user.homophones_canonical>	`user.homophones_force_show(homophones_canonical)`
phones that	`user.homophones_show_auto()`
phones word	`edit.select_word()` `user.homophones_show_selection()`

Mindmap

`homophones_open`

Context: user.community.core.homophones.homophones_open.talon

Spoken	Backend
choose <user.formatters> <number_small>	`result = user.homophones_select(number_small)` `insert(user.formatted_text(result, formatters))` `user.homophones_hide()`

Mindmap

`keys`

Context: user.community.core.keys.keys.talon

Spoken	Backend
(ship \| uppercase) <user.letters> [(lowercase \| sunk)]	`user.insert_formatted(letters, "ALL_CAPS")`
<user.function_key>	`key(function_key)`
<user.keypad_key>	`key(keypad_key)`
<user.letter>	`key(letter)`
<user.modifiers> <user.unmodified_key>	`key("{modifiers}-{unmodified_key}")`
<user.special_key>	`key(special_key)`
<user.symbol_key>	`key(symbol_key)`
press <user.keys>	`key(keys)`
press <user.modifiers>	`key(modifiers)`

Mindmap

`menu_choose`

Context: user.community.core.menu_choose.menu_choose.talon

Spoken	Backend
choose <number_small>	`user.choose(number_small)`
choose up <number_small>	`user.choose_up(number_small)`

Mindmap

`command_and_dictation_mode`

Context: user.community.core.modes.command_and_dictation_mode.talon

Spoken	Backend
command mode	`mode.disable("sleep")` `mode.disable("dictation")` `mode.enable("command")`
dictation mode	`mode.disable("sleep")` `mode.disable("command")` `mode.enable("dictation")` `user.code_clear_language_mode()` `user.gdb_disable()`
mixed mode	`mode.disable("sleep")` `mode.enable("dictation")` `mode.enable("command")`

Mindmap

`dictation_mode`

Context: user.community.core.modes.dictation_mode.talon

Spoken	Backend
(no cap \| no-caps) that	`user.dictation_reformat_no_cap()`
(no space \| no-space) that	`user.dictation_reformat_no_space()`
cap that	`user.dictation_reformat_cap()`
escape <user.text>	`user.dictation_insert(user.text)`
format selection <user.formatters>	`user.formatters_reformat_selection(formatters)`
press <user.keys>	`key(keys)`
press <user.modifiers>	`key(modifiers)`
(no cap \| no-caps)	`user.dictation_format_no_cap()`
(no space \| no-space)	`user.dictation_format_no_space()`
(nope \| scratch) selection	`edit.delete()`
<user.raw_prose>	`user.dictation_insert(raw_prose)`
cap	`user.dictation_format_cap()`
clear left <number_small> (character \| characters)	`edit.extend_left()` `repeat(number_small - 1)` `edit.delete()`
clear left <number_small> (word \| words)	`edit.extend_word_left()` `repeat(number_small - 1)` `edit.delete()`
clear right <number_small> (character \| characters)	`edit.extend_right()` `repeat(number_small - 1)` `edit.delete()`
clear right <number_small> (word \| words)	`edit.extend_word_right()` `repeat(number_small - 1)` `edit.delete()`
formatted <user.format_text>	`user.dictation_insert_raw(format_text)`
go down <number_small> (line \| lines)	`edit.down()` `repeat(number_small - 1)`
go left <number_small> (word \| words)	`edit.word_left()` `repeat(number_small - 1)`
go line end	`edit.line_end()`
go line start	`edit.line_start()`
go right <number_small> (word \| words)	`edit.word_right()` `repeat(number_small - 1)`
go up <number_small> (line \| lines)	`edit.up()` `repeat(number_small - 1)`
nope that \| scratch that	`user.clear_last_phrase()`
select left <number_small> (character \| characters)	`edit.extend_left()` `repeat(number_small - 1)`
select left <number_small> (word \| words)	`edit.extend_word_left()` `repeat(number_small - 1)`
select right <number_small> (character \| characters)	`edit.extend_right()` `repeat(number_small - 1)`
select right <number_small> (word \| words)	`edit.extend_word_right()` `repeat(number_small - 1)`
select that	`user.select_last_phrase()`
spell that <user.formatters> <user.letters>	`result = user.formatted_text(letters, formatters)` `user.dictation_insert_raw(result)`
spell that <user.letters>	`user.dictation_insert(letters)`

Mindmap

`dragon_mode`

Context: user.community.core.modes.dragon_mode.talon

Spoken	Backend
dragon mode	`user.dragon_mode()`
talon mode	`user.talon_mode()`

Mindmap

`language_modes`

Context: user.community.core.modes.language_modes.talon

Spoken	Backend
clear language mode	`user.code_clear_language_mode()`
force {user.language_mode}	`user.code_set_language_mode(language_mode)`
show [forced] language mode	`user.code_show_forced_language_mode()`

Mindmap

`modes_dragon`

Context: user.community.core.modes.modes_dragon.talon

Spoken	Backend
sleep all []	`user.switcher_hide_running()` `user.history_disable()` `user.homophones_hide()` `user.help_hide()` `user.mouse_sleep()` `speech.disable()` `user.dragon_engine_sleep()`
talon sleep []	`speech.disable()`
talon wake []	`speech.enable()`

Mindmap

`modes_not_dragon`

Context: user.community.core.modes.modes_not_dragon.talon

Spoken	Backend
(wake up)+	`speech.enable()`
go to sleep []	`speech.disable()`
sleep all []	`user.switcher_hide_running()` `user.history_disable()` `user.homophones_hide()` `user.help_hide()` `user.mouse_sleep()` `speech.disable()`
talon sleep []	`speech.disable()`
talon wake []	`speech.enable()`

Mindmap

`sleep_mode`

Context: user.community.core.modes.sleep_mode.talon

Spoken	Backend
(welcome back)+	`user.mouse_wake()` `user.history_enable()` `user.talon_mode()`

Mindmap

`sleep_mode_wav2letter`

Context: user.community.core.modes.sleep_mode_wav2letter.talon

Spoken	Backend
	`skip()`

Mindmap

`mouse_grid`

Context: user.community.core.mouse_grid.mouse_grid.talon

Spoken	Backend
m grid	`app.notify("please use the voice command 'mouse grid' instead of 'm grid'")` `user.grid_select_screen(1)` `user.grid_activate()`

Mindmap

`mouse_grid_always`

Context: user.community.core.mouse_grid.mouse_grid_always.talon

Spoken	Backend
grid <user.number_key>+	`user.grid_activate()` `user.grid_narrow_list(number_key_list)`
grid screen []	`user.grid_select_screen(number or 1)` `user.grid_activate()`
grid win	`user.grid_place_window()` `user.grid_activate()`
mouse grid	`user.grid_select_screen(1)` `user.grid_activate()`

Mindmap

`mouse_grid_open`

Context: user.community.core.mouse_grid.mouse_grid_open.talon

Spoken	Backend
<user.number_key>	`user.grid_narrow(number_key)`
grid (off \| close \| hide)	`user.grid_close()`
grid back	`user.grid_go_back()`
grid reset	`user.grid_reset()`

Mindmap

Context: user.community.core.navigation.navigation.talon

Spoken	Backend
go back	`user.go_back()`
go forward	`user.go_forward()`

Mindmap

`numbers_prefixed`

Context: user.community.core.numbers.numbers_prefixed.talon

Spoken	Backend
<user.number_prose_prefixed>	`"{number_prose_prefixed}"`

Mindmap

`numbers_unprefixed`

Context: user.community.core.numbers.numbers_unprefixed.talon

Spoken	Backend
<user.number_prose_unprefixed>	`"{number_prose_unprefixed}"`

Mindmap

`screens`

Context: user.community.core.screens.screens.talon

Spoken	Backend
screen numbers	`user.screens_show_numbering()`

Mindmap

`snippets`

Context: user.community.core.snippets.snippets.talon

Spoken	Backend
snip {user.snippet_with_phrase} <user.text>	`user.insert_snippet_by_name_with_phrase(snippet_with_phrase, text)`
snip {user.snippet}	`user.insert_snippet_by_name(snippet)`

Mindmap

`text`

Context: user.community.core.text.text.talon

Spoken	Backend
{user.prose_formatter} <user.prose> {user.phrase_ender}	`user.insert_formatted(prose, prose_formatter)` `insert(phrase_ender)`
{user.prose_formatter} <user.prose>	`user.insert_formatted(prose, prose_formatter)`
{user.word_formatter} <user.word>	`user.insert_formatted(word, word_formatter)`
(abbreviate \| abreviate \| brief) {user.abbreviation}	`"{abbreviation}"`
<user.format_code>+ {user.phrase_ender}	`user.insert_many(format_code_list)` `insert(phrase_ender)`
<user.format_code>+	`user.insert_many(format_code_list)`
<user.formatters> (abbreviate \| abreviate \| brief) {user.abbreviation}	`user.insert_formatted(abbreviation, formatters)`
<user.formatters> (pace \| paste)	`user.insert_formatted(clip.text(), formatters)`
<user.formatters> that	`user.formatters_reformat_selection(user.formatters)`
before that	`user.before_last_phrase()`
nope that \| scratch that	`user.clear_last_phrase()`
nope that was <user.formatters>	`user.formatters_reformat_last(formatters)`
phrase <user.text> {user.phrase_ender}	`user.add_phrase_to_history(text)` `insert("{text}{phrase_ender}")`
phrase <user.text>	`user.add_phrase_to_history(text)` `insert(text)`
recent close	`user.phrase_history_hide()`
recent copy <number_small>	`clip.set_text(user.get_recent_phrase(number_small))`
recent list	`user.toggle_phrase_history()`
recent repeat <number_small>	`recent_phrase = user.get_recent_phrase(number_small)` `user.add_phrase_to_history(recent_phrase)` `insert(recent_phrase)`
select that	`user.select_last_phrase()`

Mindmap

`edit_vocabulary`

Context: user.community.core.vocabulary.edit_vocabulary.talon

Spoken	Backend
check vocab	`user.check_vocabulary_for_selection()`
copy name to replacements as	`user.add_selection_to_words_to_replace(phrase, "name")`
copy name to vocab [as ]	`user.add_selection_to_vocabulary(phrase or "", "name")`
copy noun to replacements as	`user.add_selection_to_words_to_replace(phrase, "noun")`
copy noun to vocab [as ]	`user.add_selection_to_vocabulary(phrase or "", "noun")`
copy to replacements as	`user.add_selection_to_words_to_replace(phrase)`
copy to vocab [as ]	`user.add_selection_to_vocabulary(phrase or "")`

Mindmap

`websites_and_search_engines`

Context: user.community.core.websites_and_search_engines.websites_and_search_engines.talon

Spoken	Backend
{user.search_engine} (that \| this)	`text = edit.selected_text()` `user.search_with_search_engine(search_engine, text)`
{user.search_engine} hunt <user.text>	`user.search_with_search_engine(search_engine, user.text)`
{user.search_engine} paste	`user.search_with_search_engine(search_engine, clip.text())`
open {user.website}	`user.open_url(website)`
open paste	`user.open_url(clip.text())`
open that	`user.open_url(edit.selected_text())`

Mindmap

`tabs`

Context: user.community.core.windows_and_tabs.tabs.talon

Spoken	Backend
go tab	`user.tab_jump(number)`
go tab final	`user.tab_final()`
tab (duplicate \| clone)	`user.tab_duplicate()`
tab (last \| previous)	`app.tab_previous()`
tab (open \| new)	`app.tab_open()`
tab (reopen \| restore)	`app.tab_reopen()`
tab close	`user.tab_close_wrapper()`
tab next	`app.tab_next()`

Mindmap

`window_layout`

Context: user.community.core.windows_and_tabs.window_layout.talon

Spoken	Backend
layout <user.window_layout>	`user.snap_layout(window_layout)`

Mindmap

`window_management`

Context: user.community.core.windows_and_tabs.window_management.talon

Spoken	Backend
app (preferences \| prefs \| settings)	`app.preferences()`
focus <user.running_applications>	`user.switcher_focus(running_applications)`
focus last	`user.switcher_focus_last()`
focus	`user.switcher_menu()`
launch <user.launch_applications>	`user.switcher_launch(launch_applications)`
running close	`user.switcher_hide_running()`
running list	`user.switcher_toggle_running()`
snap <user.running_applications> [screen]	`user.move_app_to_screen(running_applications, number)`
snap <user.running_applications> <user.window_snap_position>	`user.snap_app(running_applications, window_snap_position)`
snap <user.window_snap_position>	`user.snap_window(window_snap_position)`
snap last [screen]	`user.move_window_previous_screen()`
snap next [screen]	`user.move_window_next_screen()`
snap screen	`user.move_window_to_screen(number)`
window (new \| open)	`app.window_open()`
window close	`app.window_close()`
window hide	`app.window_hide()`
window last	`app.window_previous()`
window next	`app.window_next()`

Mindmap

`batch`

Context: user.community.lang.batch.batch.talon

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

Mindmap

`c`

Context: user.community.lang.c.c.talon

Spoken	Backend
[state] (undefine \| undeaf) <user.text>	`"#undef {user.formatted_text(text, 'ALL_CAPS,SNAKE_CASE')}"`
[state] define <user.text>	`"#define {user.formatted_text(text, 'ALL_CAPS,SNAKE_CASE')}"`
[state] if (define \| deaf) <user.text>	`"#ifdef {user.formatted_text(text, 'ALL_CAPS,SNAKE_CASE')}"`
<user.c_keywords>	`"{c_keywords}"`
<user.c_pointers>	`"{c_pointers}"`
<user.c_signed>	`"{c_signed} "`
<user.c_types>	`"{c_types}"`
<user.c_variable>	`insert("{c_variable} ")` `insert(user.formatted_text(phrase, "PRIVATE_CAMEL_CASE,NO_SPACES"))`
<user.c_variable> <user.letter>	`insert("{c_variable} {letter} ")`
cast to <user.c_cast>	`"{c_cast}"`
include <user.code_libraries>	`user.code_insert_library(code_libraries, "")` `key(end enter)`
int main	`user.insert_between("int main(", ")")`
push braces	`edit.line_end()` `insert("{}")` `edit.left()` `key(enter)` `key(enter)` `edit.up()`
standard <user.stdint_types>	`"{stdint_types}"`
standard cast to <user.stdint_cast>	`"{stdint_cast}"`
state (undefine \| undeaf)	`"#undef "`
state default	`"default:\\nbreak;"`
state define	`"#define "`
state error	`"#error "`
state if (define \| deaf)	`"#ifdef "`
state include	`insert("#include ")`
state include local	`user.insert_between('#include "', '"')`
state include system	`user.insert_between("#include <", ">")`
state pragma	`"#pragma "`
state pre else if	`"#elif "`
state pre end	`"#endif "`
state pre if	`"#if "`
state type deaf	`insert("typedef ")`
state type deaf struct	`user.insert_snippet_by_name("typedefStructDeclaration")`

Mindmap

`css`

Context: user.community.lang.css.css.talon

Spoken	Backend
(value \| state) {user.css_global_value}	`"{css_global_value}"`
[value] current color	`"currentColor"`
at {user.css_at_rule}	`"@{css_at_rule} "`
attribute [<user.text>]	`name = user.formatted_text(text or "", "DASH_SEPARATED")` `user.insert_between("[{name}", "]")`
block	`user.code_block()`
op important	`" !important"`
op var	`user.insert_between("var(--", ")")`
prop <user.text>	`name = user.formatted_text(text, "DASH_SEPARATED")` `user.insert_between("{name}: ", ";")`
rule <user.text>	`name = user.formatted_text(text, "DASH_SEPARATED")` `insert("{name}: ")`
unit {user.css_unit}	`insert(css_unit)`
value <user.number_string> [{user.css_unit}]	`"{number_string}{css_unit or ''}"`
value <user.number_string> point <digit_string> [{user.css_unit}]	`"{number_string}.{digit_string}{css_unit or ''}"`
value <user.text>	`user.insert_formatted(text, "DASH_SEPARATED")`
variable <user.text>	`name = user.formatted_text(text, "DASH_SEPARATED")` `insert("var(--{name})")`

Mindmap

`elixir`

Context: user.community.lang.elixir.elixir.talon

Spoken	Backend
[state] raise {user.elixir_exception}	`user.insert_between("raise ", "")`
[state] rescue {user.elixir_exception}	`"rescue {elixir_exception}"`
op pipe	`" \|> "`
state after	`"after"`
state case	`"case "`
state cond	`"cond do"`
state def	`"def "`
state defp	`"defp "`
state else	`"else"`
state end	`"end"`
state if	`"if "`
state rescue	`"rescue"`
state try	`"try do"`

Mindmap

`go`

Context: user.community.lang.go.go.talon

Spoken	Backend
(variadic \| spread)	`"..."`
[state] if (err \| error)	`insert("if err != nil {")` `key("enter")`
[state] if not (err \| error)	`insert("if err == nil {")` `key("enter")`
channel (receive \| send)	`" <- "`
declare	`" := "`

Mindmap

`java`

Context: user.community.lang.java.java.talon

Spoken	Backend
[state] {user.java_modifier}	`insert(user.java_modifier \+ " ")`
boxed [type] {user.java_boxed_type}	`insert(user.java_boxed_type \+ " ")`
generic [type] {user.java_generic_data_structure}	`user.insert_between(java_generic_data_structure \+ "<", ">")`
op array	`user.code_operator_subscript()`
op new	`insert("new ")`
state var	`"var "`
type {user.code_type} array	`insert(user.code_type)` `user.code_operator_subscript()`

Mindmap

`javascript`

Context: user.community.lang.javascript.javascript.talon

Spoken	Backend
(op \| is) strict equal	`user.deprecate_command("2025-03-4", "(op \| is) strict equal", "is equal")` `user.code_operator("MATH_EQUAL")`
(op \| is) strict not equal	`user.deprecate_command("2025-03-4", "(op \| is) strict not equal", "is not equal")` `user.code_operator("MATH_NOT_EQUAL")`
dot {user.code_common_member_function}	`user.insert_between(".{code_common_member_function}(", ")")`
from import	`user.insert_between(' from "', '"')`
op null else	`" ?? "`
state async	`"async "`
state await	`"await "`
state const	`"const "`
state export	`"export "`
state filter	`app.notify('ERROR: Command deprecated; please use "dot filter"')`
state let	`"let "`
state map	`app.notify('ERROR: Command deprecated; please use "dot map"')`
state reduce	`app.notify('ERROR: Command deprecated; please use "dot reduce"')`
state spread	`"..."`
state var	`"var "`

Mindmap

`lua`

Context: user.community.lang.lua.lua.talon

Spoken	Backend
index (var \| variable) <user.text>	`var = user.formatted_text(text, "SNAKE_CASE")` `insert("[{var}]")`
index <user.word>	`'["{word}"]'`
method <user.text>	`insert(":")` `user.code_public_function_formatter(text)` `insert("()")` `edit.left()`
require <user.code_libraries>	`user.code_insert_library("", code_libraries)` `key(end enter)`
self dot	`"self."`
state (variable \| var) [<user.text>] [over]	`user.code_public_variable_formatter(text)`
state append string	`" .. "`
state end	`"end"`
state label <user.text>	`insert("::")` `user.insert_formatted(text, "SNAKE_CASE")` `insert("::")`
state local	`"local"`
state local (variable \| var) [<user.text>] [over]	`insert("local ")` `user.code_private_variable_formatter(text)`
state repeat	`"repeat"`
state return (null \| nil)	`"return nil"`
state return dick	`user.insert_between("return {", "}")`
state return false	`"return false"`
state return table	`user.insert_between("return {", "}")`
state return true	`"return true"`
state then	`"then"`
state until	`"until"`

Mindmap

`stylua`

Context: user.community.lang.lua.stylua.talon

Spoken	Backend
lint ignore	`"-- stylua: ignore"`
lint ignore end	`"-- stylua: ignore end"`
lint ignore start	`"-- stylua: ignore start"`

Mindmap

`markdown`

Context: user.community.lang.markdown.markdown.talon

Spoken	Backend
{user.markdown_code_block_language} block	user.insert_snippet("```{markdown_code_block_language}\\n$0\\n```")
(level \| heading \| header) five	`edit.line_start()` `"##### "`
(level \| heading \| header) four	`edit.line_start()` `"#### "`
(level \| heading \| header) one	`edit.line_start()` `"# "`
(level \| heading \| header) six	`edit.line_start()` `"###### "`
(level \| heading \| header) three	`edit.line_start()` `"### "`
(level \| heading \| header) two	`edit.line_start()` `"## "`
link	`user.insert_snippet_by_name("link")`
list [one]	`edit.line_start()` `"- "`
list five	`edit.line_start()` `" - "`
list four	`edit.line_start()` `" - "`
list six	`edit.line_start()` `" - "`
list three	`edit.line_start()` `" - "`
list two	`edit.line_start()` `" - "`

Mindmap

`php`

Context: user.community.lang.php.php.talon

Spoken	Backend
(op \| is) loosely equal	`user.deprecate_command("2025-03-20", "(op \| is) loosely equal", "is weak equal")` `insert(" == ")`
(op \| is) loosely not equal	`user.deprecate_command("2025-03-20", "(op \| is) loosely not equal", "is weak not equal")` `insert(" != ")`
state catch	`user.insert_snippet_by_name("catchStatement")`
state try	`user.insert_snippet_by_name("tryStatement")`
var [over]	`insert("$")` `insert(user.formatted_text(phrase, "PRIVATE_CAMEL_CASE"))`

Mindmap

`proto`

Context: user.community.lang.proto.proto.talon

Spoken	Backend
block	`user.code_block()`
op equals	`" = "`
repeated type {user.code_type}	`"repeated {code_type}"`
state enum	`"enum "`
state import	`"import "`
state import public	`"import public "`
state message	`"message "`
state option	`"option "`
state package	`"package "`
state repeated	`"repeated "`
state reserved	`"reserved "`
type {user.code_type}	`"{code_type}"`

Mindmap

`python`

Context: user.community.lang.python.python.talon

Spoken	Backend
[state] except {user.python_exception}	`"except {python_exception}:"`
[state] raise {user.python_exception}	`user.insert_between("raise {python_exception}(", ")")`
dock {user.python_docstring_fields}	`insert("{python_docstring_fields}")` `edit.left()`
dock returns type {user.code_type}	`user.insert_between(":rtype ", ": {code_type}")`
dock string	`user.code_comment_documentation()`
dock type {user.code_type}	`user.insert_between(":type ", ": {code_type}")`
dunder in it	`"__init__"`
from import	`user.insert_snippet_by_name("importFromStatement")`
import <user.code_libraries>	`user.code_insert_library(code_libraries, "")` `key(end enter)`
pie test	`"pytest"`
self taught	`"self."`
state (def \| deaf \| deft)	`"def "`
state except	`"except "`
state past	`"pass"`
state raise	`"raise "`
state try	`"try:\\n"`

Mindmap

`r`

Context: user.community.lang.r.r.talon

Spoken	Backend
function define <user.text>	`user.code_private_function(text)`
(chain \| pipe that)	`key(end)` `" %>%"` `key(enter)`
library <user.code_libraries>	`user.code_insert_library(code_libraries, "")` `key(end enter)`
named arg {user.code_parameter_name}	`user.code_insert_named_argument(code_parameter_name)`
state na	`insert("NA")`

Mindmap

`ruby`

Context: user.community.lang.ruby.ruby.talon

Spoken	Backend
instance <user.text>	`insert("@")` `user.code_public_variable_formatter(text)`
args pipe	`user.insert_between("\|", "\|")`
dock string	`user.code_comment_documentation()`
state begin	`"begin"`
state end	`"end"`
state module	`"module "`
state rescue	`"rescue "`

Mindmap

`rust`

Context: user.community.lang.rust.rust.talon

Spoken	Backend
block dock comment	`user.code_comment_documentation_block()`
borrow	`"&"`
borrow mutable	`"&mut "`
dynamic trait {user.code_trait}	`insert("dyn {code_trait}")`
implement (struct \| structure)	`user.code_state_implements()`
implemented trait {user.code_trait}	`insert("impl {code_trait}")`
inner block dock comment	`user.code_comment_documentation_block_inner()`
inner dock comment	`user.code_comment_documentation_inner()`
is implemented trait	`": impl "`
is implemented trait {user.code_trait}	`": impl {code_trait}"`
is some	`user.code_insert_is_not_null()`
macro {user.code_macros}	`user.code_insert_macro(code_macros, "")`
macro wrap {user.code_macros}	`user.code_insert_macro(code_macros, edit.selected_text())`
returns implemented trait	`" -> impl "`
returns implemented trait {user.code_trait}	`" -> impl {code_trait}"`
self taught	`"self."`
state (a sink \| async \| asynchronous)	`"async "`
state (dyn \| dynamic)	`"dyn "`
state (funk \| func \| function)	`"fn "`
state (imp \| implements)	`"impl "`
state (mod \| module)	`"mod "`
state (mute \| mutable)	`"mut "`
state (pub \| public)	`"pub "`
state (pub \| public) crate	`"pub(crate) "`
state (some \| sum)	`"Some"`
state (struct \| structure) <user.text>	`insert("struct ")` `insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))`
state constant	`"const "`
state enum <user.text>	`insert("enum ")` `insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))`
state if let (ok \| okay)	`user.insert_between("if let Ok(", ")")`
state if let error	`user.insert_between("if let Err(", ")")`
state if let some	`user.insert_between("if let Some(", ")")`
state let	`"let "`
state let mute	`"let mut "`
state match	`user.code_state_switch()`
state ref	`"ref "`
state ref (mute \| mutable)	`"ref mut "`
state static	`"static "`
state trait	`"trait "`
state unsafe	`"unsafe "`
state use	`user.code_import()`
trait {user.code_trait}	`insert("{code_trait}")`
unsafe block	`user.code_state_unsafe()`
use <user.code_libraries>	`user.code_insert_library(code_libraries, "")` `key(enter)`

Mindmap

`scala`

Context: user.community.lang.scala.scala.talon

Spoken	Backend
block string	`insert('""""""')` `key("left left left")`
op left arrow	`" <- "`
op plus plus	`" \+\+ "`
op right arrow	`" -> "`
op subtype	`" <: "`
state {user.scala_keyword}	`insert("{scala_keyword} ")`
state {user.scala_modifier}	`insert("{user.scala_modifier} ")`
state match	`user.code_state_switch()`

Mindmap

`sql`

Context: user.community.lang.sql.sql.talon

Spoken	Backend
ascending	`" ASC"`
column	`key(return)` `", "`
count	`user.code_insert_function("Count", "")`
date	`user.insert_between("DATE '", "'")`
descending	`" DESC"`
distinct	`"DISTINCT "`
dot i d	`".id"`
from	`"FROM "`
group by	`"GROUP BY "`
having	`"HAVING "`
inner join	`user.insert_between("INNER JOIN ", " ON ")`
inner join using	`user.insert_between("INNER JOIN ", " USING ")`
left outer join	`user.insert_between("LEFT OUTER JOIN ", " ON ")`
order by	`"ORDER BY "`
right outer join	`user.insert_between("RIGHT OUTER JOIN ", " ON ")`
select	`"SELECT "`
select star from	`"SELECT *\\nFROM "`
where	`"WHERE "`
with	`user.insert_snippet_by_name("withStatement")`

Mindmap

`stata`

Context: user.community.lang.stata.stata.talon

Spoken	Backend
arg {user.code_parameter_name}	`user.code_insert_named_argument(code_parameter_name)`
s s c install	`user.code_import()`
s s c install <user.code_libraries>	`user.code_insert_library(code_libraries, "")`
state for val	`user.code_state_for()`

Mindmap

`comment_block`

Context: user.community.lang.tags.comment_block.talon

Spoken	Backend
(line \| inline) block comment <user.text> over	`edit.line_end()` `user.code_comment_block_prefix()` `key(space)` `insert(user.text)` `key(space)` `user.code_comment_block_suffix()`
(line \| inline) block comment <user.text>	`edit.line_end()` `user.code_comment_block_prefix()` `key(space)` `insert(user.text)` `key(space)` `user.code_comment_block_suffix()`
block comment	`user.code_comment_block()`
block comment <user.text> over	`user.code_comment_block()` `insert(user.text)`
block comment <user.text>	`user.code_comment_block()` `insert(user.text)`
block comment line	`edit.line_start()` `user.code_comment_block_prefix()` `key(space)` `edit.line_end()` `key(space)` `user.code_comment_block_suffix()`
block comment line <user.text> over	`edit.line_start()` `user.code_comment_block()` `insert(user.text)`
close block comment	`user.code_comment_block_suffix()`
open block comment	`user.code_comment_block_prefix()`

Mindmap

`comment_documentation`

Context: user.community.lang.tags.comment_documentation.talon

Spoken	Backend
dock comment	`user.code_comment_documentation()`

Mindmap

`comment_line`

Context: user.community.lang.tags.comment_line.talon

Spoken	Backend
(line \| inline) comment <user.text> over	`edit.line_end()` `user.code_comment_line_prefix()` `insert(user.text)`
(line \| inline) comment <user.text>	`edit.line_end()` `user.code_comment_line_prefix()` `insert(user.text)`
comment	`user.code_comment_line_prefix()`
comment <user.text> over	`user.code_comment_line_prefix()` `insert(user.text)`
comment <user.text>	`user.code_comment_line_prefix()` `insert(user.text)`
comment line	`edit.line_start()` `user.code_comment_line_prefix()`
comment line <user.text> over	`edit.line_start()` `user.code_comment_line_prefix()` `insert(user.text)` `insert(" ")`

Mindmap

`data_bool`

Context: user.community.lang.tags.data_bool.talon

Spoken	Backend
state false	`user.code_insert_false()`
state true	`user.code_insert_true()`

Mindmap

`data_null`

Context: user.community.lang.tags.data_null.talon

Spoken	Backend
is (none \| null)	`user.code_insert_is_null()`
is not (none \| null)	`user.code_insert_is_not_null()`
state (no \| none \| nil \| null)	`user.code_insert_null()`

Mindmap

`functions`

Context: user.community.lang.tags.functions.talon

Spoken	Backend
{user.code_function_modifier} funky <user.text>*	`user.code_modified_function(code_function_modifier_list or 0, text)`
is type <user.code_type>	`user.code_insert_type_annotation(code_type)`
returns [type] <user.code_type>	`user.code_insert_return_type(code_type)`
type <user.code_type>	`insert(code_type)`

Mindmap

`functions_common`

Context: user.community.lang.tags.functions_common.talon

Spoken	Backend
funk <user.code_common_function>	`user.code_insert_function(code_common_function, "")`
funk cell	`user.code_select_function(number - 1, "")`
funk wrap	`user.code_select_function(number - 1, edit.selected_text())`
funk wrap <user.code_common_function>	`user.code_insert_function(code_common_function, edit.selected_text())`
toggle funk	`user.code_toggle_functions()`

Mindmap

`functions_common_gui_active`

Context: user.community.lang.tags.functions_common_gui_active.talon

Spoken	Backend
toggle funk	`user.code_toggle_functions()`

Mindmap

`imperative`

Context: user.community.lang.tags.imperative.talon

Spoken	Backend
block	`user.code_block()`
state (continue \| next)	`user.code_next()`
state (switch \| match)	`user.code_state_switch()`
state break	`user.code_break()`
state case	`user.code_state_case()`
state do	`user.code_state_do()`
state else	`user.code_state_else()`
state else if	`user.code_state_else_if()`
state for	`user.code_state_for()`
state for in	`user.code_state_for_each()`
state goto	`user.code_state_go_to()`
state if	`user.code_state_if()`
state loop	`user.code_state_infinite_loop()`
state return	`user.code_state_return()`
state while	`user.code_state_while()`

Mindmap

`keywords`

Context: user.community.lang.tags.keywords.talon

Spoken	Backend
keyword (<user.code_keyword>+)	`user.code_keyword(code_keyword_list)`

Mindmap

`libraries`

Context: user.community.lang.tags.libraries.talon

Spoken	Backend
state import	`user.code_import()`

Mindmap

`object_oriented`

Context: user.community.lang.tags.object_oriented.talon

Spoken	Backend
self dot	`user.code_self()` `user.code_operator_object_accessor()`
state class	`user.code_define_class()`
state self	`user.code_self()`

Mindmap

`operators`

Context: user.community.lang.tags.operators.talon

Spoken	Backend
is {user.code_operators_math_comparison}	`user.code_operator(code_operators_math_comparison)`
op {user.code_operators_array}	`user.code_operator(code_operators_array)`
op {user.code_operators_assignment}	`user.code_operator(code_operators_assignment)`
op {user.code_operators_bitwise}	`user.code_operator(code_operators_bitwise)`
op {user.code_operators_lambda}	`user.code_operator(code_operators_lambda)`
op {user.code_operators_math}	`user.code_operator(code_operators_math)`
op {user.code_operators_pointer}	`user.code_operator(code_operators_pointer)`

Mindmap

`operators_assignment_deprecations`

Context: user.community.lang.tags.operators_assignment_deprecations.talon

Spoken	Backend
(op \| logical \| bitwise) (ex \| exclusive) or equals	`user.deprecate_command("2025-01-19", "(op \| logical \| bitwise) (ex \| exclusive) or equals", "op bitwise exclusive or equals")` `user.code_operator("ASSIGNMENT_BITWISE_EXCLUSIVE_OR")`
[(op \| logical \| bitwise)] (left shift \| shift left) equals	`user.deprecate_command("2025-01-19", "[(op \| logical \| bitwise)] (left shift \| shift left) equals", "op left shift equals")` `user.code_operator("ASSIGNMENT_BITWISE_LEFT_SHIFT")`
[(op \| logical \| bitwise)] (right shift \| shift right) equals	`user.deprecate_command("2025-01-19", "[(op \| logical \| bitwise)] (right shift \| shift right) equals", "op right shift equals")` `user.code_operator("ASSIGNMENT_BITWISE_RIGHT_SHIFT")`
[op] bit [wise] and equals	`user.deprecate_command("2025-01-19", "[op] bit [wise] and equals", "op bitwise and equals")` `user.code_operator("ASSIGNMENT_BITWISE_AND")`
[op] bit [wise] or equals	`user.deprecate_command("2025-01-19", "[op] bit [wise] or equals", "op bitwise or equals")` `user.code_operator("ASSIGNMENT_BITWISE_OR")`
increment	`user.deprecate_command("2025-01-19", "increment", "op increment")` `user.code_operator("ASSIGNMENT_INCREMENT")`
op add equals	`user.deprecate_command("2025-01-19", "op add equals", "op plus equals")` `user.code_operator("ASSIGNMENT_ADDITION")`
op assign	`user.deprecate_command("2025-01-19", "op assign", "op equals")` `user.code_operator("ASSIGNMENT")`
op multiply equals	`user.deprecate_command("2025-01-19", "op multiply equals", "op times equals")` `user.code_operator("ASSIGNMENT_MULTIPLICATION")`
op subtract equals	`user.deprecate_command("2025-01-19", "op subtract equals", "op minus equals")` `user.code_operator("ASSIGNMENT_SUBTRACTION")`

Mindmap

`operators_bitwise_deprecations`

Context: user.community.lang.tags.operators_bitwise_deprecations.talon

Spoken	Backend
(op \| logical \| bitwise) (ex \| exclusive) or	`user.deprecate_command("2025-01-19", "(op \| logical \| bitwise) (ex \| exclusive) or", "op bitwise ex or")` `user.code_operator("BITWISE_EXCLUSIVE_OR")`
(op \| logical \| bitwise) (left shift \| shift left)	`user.deprecate_command("2025-01-19", "(op \| logical \| bitwise) (left shift \| shift left)", "op bitwise left shift")` `user.code_operator("BITWISE_LEFT_SHIFT")`
(op \| logical \| bitwise) (right shift \| shift right)	`user.deprecate_command("2025-01-19", "(op \| logical \| bitwise) (right shift \| shift right)", "op bitwise right shift")` `user.code_operator("BITWISE_RIGHT_SHIFT")`
bitwise and	`user.deprecate_command("2025-01-19", "bitwise and", "op bitwise and")` `user.code_operator("BITWISE_AND")`
bitwise not	`user.deprecate_command("2025-01-19", "bitwise not", "op bitwise not")` `user.code_operator("BITWISE_NOT")`
bitwise or	`user.deprecate_command("2025-01-19", "bitwise or", "op bitwise or")` `user.code_operator("BITWISE_OR")`

Mindmap

`operators_math_deprecations`

Context: user.community.lang.tags.operators_math_deprecations.talon

Spoken	Backend
is below [than]	`user.deprecate_command("2025-01-19", "is below [than]", "is less")` `user.code_operator("MATH_LESS_THAN")`
is greater than or equal	`user.deprecate_command("2025-01-19", "is greater than or equal", "is greater or equal")` `user.code_operator("MATH_GREATER_THAN_OR_EQUAL")`
is less than or equal	`user.deprecate_command("2025-01-19", "is less than or equal", "is less or equal")` `user.code_operator("MATH_LESS_THAN_OR_EQUAL")`
is more	`user.deprecate_command("2025-01-19", "is more", "is greater")` `user.code_operator("MATH_GREATER_THAN")`
logical and	`user.deprecate_command("2025-01-19", "logical and", "op and")` `user.code_operator("MATH_AND")`
logical not	`user.deprecate_command("2025-01-19", "logical not", "op not")` `user.code_operator("MATH_NOT")`
logical or	`user.deprecate_command("2025-01-19", "logical or", "op or")` `user.code_operator("MATH_OR")`
op (exponent \| to the power [of])	`user.deprecate_command("2025-01-19", "op (exponent \| to the power [of])", "op power")` `user.code_operator("MATH_EXPONENT")`
op add	`user.deprecate_command("2025-01-19", "op add", "op plus")` `user.code_operator("MATH_ADD")`
op colon	`user.deprecate_command("2025-01-19", "op colon", "pad colon")` `insert(" : ")`
op multiply	`user.deprecate_command("2025-01-19", "op multiply", "op times")` `user.code_operator("MATH_MULTIPLY")`
op subtract	`user.deprecate_command("2025-01-19", "op subtract", "op minus")` `user.code_operator("MATH_SUBTRACT")`

Mindmap

`talon-list`

Context: user.community.lang.talon.talon-list.talon

Spoken	Backend
list [require]	`"list: "`
list [require] {user.talon_lists}	`"list: {talon_lists}"`

Mindmap

`talon`

Context: user.community.lang.talon.talon.talon

Spoken	Backend
setting block	`insert("settings():\\n\t")`

Mindmap

`talon_common`

Context: user.community.lang.talon.talon_common.talon

Spoken	Backend
action {user.talon_actions}	`user.talon_code_insert_action_call(talon_actions, edit.selected_text())`
capture {user.talon_captures}	`"<{talon_captures}>"`
key <user.keys> over	`"{keys}"`
key <user.modifiers> over	`"{modifiers}"`
list {user.talon_lists}	`"{{{talon_lists}}}"`
setting {user.talon_settings}	`user.talon_code_enable_setting(talon_settings)`
tag set [{user.talon_tags}]	`tag = talon_tags or ""` `user.talon_code_enable_tag(tag)`

Mindmap

`talon_context`

Context: user.community.lang.talon.talon_context.talon

Spoken	Backend
application [require] [{user.talon_apps}]	`app = "{talon_apps}\\n" or ""` `insert("app: {app}")`
host require	`hostname = user.talon_get_hostname()` `insert("hostname: {hostname}\\n")`
linux require	`insert("os: linux\\n")`
mac require	`insert("os: mac\\n")`
mode require [{user.talon_modes}]	`mode = "{talon_modes}\\n" or ""` `insert("mode: {mode}")`
tag require [{user.talon_tags}]	`tag = "{talon_tags}\\n" or ""` `insert("tag: {tag}")`
title require	`insert("win.title: ")`
win require	`insert("os: windows\\n")`

Mindmap

`terraform`

Context: user.community.lang.terraform.terraform.talon

Spoken	Backend
[state] prop {user.terraform_common_property}	`insert(user.terraform_common_property)` `user.code_operator_assignment()`
block	`user.code_block()`
data [source] <user.text>	`user.code_terraform_data_source(text)`
resource <user.text>	`user.code_terraform_resource(text)`
state {user.terraform_module_block}	`user.code_terraform_module_block(user.terraform_module_block)`
type {user.code_type}	`insert("{code_type}")`

Mindmap

`typescript`

Context: user.community.lang.typescript.typescript.talon

Spoken	Backend
as const	`" as const"`
state type	`user.insert_between("type ", " = ")`
type intersect [<user.code_type>]	`" & {code_type or ''}"`
type union [<user.code_type>]	`" \| {code_type or ''}"`

Mindmap

`vimscript`

Context: user.community.lang.vimscript.vimscript.talon

Spoken	Backend
[<user.vimscript_scope>] (variable \| var) [<user.text>] [over]	`insert(vimscript_scope or "")` `user.code_private_variable_formatter(text)`
<user.vimscript_functions>	`insert("{vimscript_functions} ")`
assign [<user.vimscript_scope>] (variable \| var) [<user.text>] [over]	`insert("let ")` `insert(vimscript_scope or "")` `user.code_private_variable_formatter(text)`
state command	`"command! "`
state continue	`"continue"`
state end for	`"endfor"`
state end function	`"endfunction"`
state end if	`"endif"`
state end while	`"endwhile"`

Mindmap

`are_you_sure`

Context: user.community.plugin.are_you_sure.are_you_sure.talon

Spoken	Backend
cancel	`user.are_you_sure_cancel()`
yes i am sure	`user.are_you_sure_confirm()`

Mindmap

`cancel`

Context: user.community.plugin.cancel.cancel.talon

Spoken	Backend
cancel cancel	`skip()`
ignore []	`app.notify("Command ignored")`

Mindmap

`command_history`

Context: user.community.plugin.command_history.command_history.talon

Spoken	Backend
command history	`user.history_toggle()`
command history clear	`user.history_clear()`
command history close	`user.history_disable()`
command history less	`user.history_less()`
command history more	`user.history_more()`

Mindmap

`datetimeinsert`

Context: user.community.plugin.datetimeinsert.datetimeinsert.talon

Spoken	Backend
date insert	`insert(user.time_format("%Y-%m-%d"))`
date insert utc	`insert(user.time_format_utc("%Y-%m-%d"))`
timestamp insert	`insert(user.time_format("%Y-%m-%d %H:%M:%S"))`
timestamp insert utc	`insert(user.time_format_utc("%Y-%m-%d %H:%M:%S"))`
timestamp insert utc high resolution	`insert(user.time_format_utc("%Y-%m-%d %H:%M:%S.%f"))`
timestamp insert high resolution	`insert(user.time_format("%Y-%m-%d %H:%M:%S.%f"))`

Mindmap

`desktops`

Context: user.community.plugin.desktops.desktops.talon

Spoken	Backend
desk <number_small>	`user.desktop(number_small)`
desk last	`user.desktop_last()`
desk next	`user.desktop_next()`
desk show	`user.desktop_show()`
window move desk	`user.window_move_desktop(number)`
window move desk left	`user.window_move_desktop_left()`
window move desk right	`user.window_move_desktop_right()`

Mindmap

`draft_editor`

Context: user.community.plugin.draft_editor.draft_editor.talon

Spoken	Backend
draft all	`edit.select_all()` `user.draft_editor_open()`
draft bottom	`edit.extend_file_end()` `user.draft_editor_open()`
draft line	`edit.select_line()` `user.draft_editor_open()`
draft submit	`user.draft_editor_paste_last()`
draft this	`user.draft_editor_open()`
draft top	`edit.extend_file_start()` `user.draft_editor_open()`

Mindmap

`draft_editor_open`

Context: user.community.plugin.draft_editor.draft_editor_open.talon

Spoken	Backend
draft discard	`user.draft_editor_discard()`
draft submit	`user.draft_editor_submit()`

Mindmap

Context: user.community.plugin.dropdown.dropdown.talon

Spoken	Backend
drop down <number_small>	`user.deprecate_command("2024-05-29", "drop down", "choose")`
drop down up <number_small>	`user.deprecate_command("2024-05-29", "drop down up", "choose up")`

Mindmap

`gamepad_tester`

Context: user.community.plugin.gamepad.gamepad_tester.talon

Spoken	Backend
gamepad tester	`user.gamepad_tester_toggle()`

Mindmap

`macro`

Context: user.community.plugin.macro.macro.talon

Spoken	Backend
macro copy [{user.saved_macros}]	`user.macro_copy(saved_macros or "")`
macro copy as <user.text>	`user.macro_copy(text)`
macro list	`user.macro_list()`
macro list close	`user.macro_list_close()`
macro play [{user.saved_macros}]	`user.macro_play(saved_macros or "")`
macro record	`user.macro_record()`
macro save as <user.text>	`user.macro_save(text)`
macro stop	`user.macro_stop()`

Mindmap

`media`

Context: user.community.plugin.media.media.talon

Spoken	Backend
(volume \| media) mute	`key(mute)`
[media] play next	`key(next)`
[media] play previous	`key(prev)`
media (play \| pause)	`user.play_pause()`
set volume	`user.media_set_volume(number)`
volume down	`key(voldown)`
volume up	`key(volup)`

Mindmap

`microphone_selection`

Context: user.community.plugin.microphone_selection.microphone_selection.talon

Spoken	Backend
microphone close	`user.microphone_selection_hide()`
microphone pick <number_small>	`user.microphone_select(number_small)`
microphone show	`user.microphone_selection_toggle()`

Mindmap

`continuous_scrolling`

Context: user.community.plugin.mouse.continuous_scrolling.talon

Spoken	Backend
[wheel] stop	`user.mouse_scroll_stop()`
[wheel] stop here	`user.mouse_move_center_active_window()` `user.mouse_scroll_stop()`
<number_small>	`user.mouse_scroll_set_speed(number_small)`

Mindmap

`mouse`

Context: user.community.plugin.mouse.mouse.talon

Spoken	Backend
(dub click \| duke)	`tracking.zoom_cancel()` `mouse_click()` `mouse_click()` `user.grid_close()`
(trip click \| trip lick)	`tracking.zoom_cancel()` `mouse_click()` `mouse_click()` `mouse_click()` `user.grid_close()`
<user.modifiers> righty	`tracking.zoom_cancel()` `key("{modifiers}:down")` `mouse_click(1)` `key("{modifiers}:up")` `user.grid_close()`
<user.modifiers> touch	`tracking.zoom_cancel()` `key("{modifiers}:down")` `mouse_click(0)` `key("{modifiers}:up")` `user.grid_close()`
camera overlay	`tracking.control_debug_toggle()`
control mouse	`tracking.control_toggle()`
control off	`user.mouse_sleep()`
copy mouse position	`user.copy_mouse_position()`
curse no	`app.notify("Please activate the user.mouse_cursor_commands_enable tag to enable this command")`
end drag \| drag end	`user.mouse_drag_end()`
left drag \| drag \| drag start	`tracking.zoom_cancel()` `user.mouse_drag(0)` `user.grid_close()`
mid click	`tracking.zoom_cancel()` `mouse_click(2)` `user.grid_close()`
mouse hiss down	`user.hiss_scroll_down()`
mouse hiss up	`user.hiss_scroll_up()`
right drag \| righty drag	`tracking.zoom_cancel()` `user.mouse_drag(1)` `user.grid_close()`
righty	`tracking.zoom_cancel()` `mouse_click(1)` `user.grid_close()`
run calibration	`tracking.calibrate()`
touch	`tracking.zoom_cancel()` `mouse_click(0)` `user.grid_close()` `user.mouse_drag_end()`
wheel {user.continuous_scrolling_direction}	`user.mouse_scroll_continuous(continuous_scrolling_direction)`
wheel {user.continuous_scrolling_direction} <number_small>	`user.mouse_scroll_continuous(continuous_scrolling_direction, number_small)`
wheel {user.continuous_scrolling_direction} here	`user.mouse_move_center_active_window()` `user.mouse_scroll_continuous(continuous_scrolling_direction)`
wheel {user.continuous_scrolling_direction} here <number_small>	`user.mouse_move_center_active_window()` `user.mouse_scroll_continuous(continuous_scrolling_direction, number_small)`
wheel down	`user.mouse_scroll_down()`
wheel down here	`user.mouse_move_center_active_window()` `user.mouse_scroll_down()`
wheel gaze	`user.mouse_gaze_scroll()`
wheel gaze here	`user.mouse_move_center_active_window()` `user.mouse_gaze_scroll()`
wheel left	`user.mouse_scroll_left()`
wheel left here	`user.mouse_move_center_active_window()` `user.mouse_scroll_left()`
wheel right	`user.mouse_scroll_right()`
wheel right here	`user.mouse_move_center_active_window()` `user.mouse_scroll_right()`
wheel tiny [down]	`user.mouse_scroll_down(0.2)`
wheel tiny [down] here	`user.mouse_move_center_active_window()` `user.mouse_scroll_down(0.2)`
wheel tiny left	`user.mouse_scroll_left(0.5)`
wheel tiny left here	`user.mouse_move_center_active_window()` `user.mouse_scroll_left(0.5)`
wheel tiny right	`user.mouse_scroll_right(0.5)`
wheel tiny right here	`user.mouse_move_center_active_window()` `user.mouse_scroll_right(0.5)`
wheel tiny up	`user.mouse_scroll_up(0.2)`
wheel tiny up here	`user.mouse_move_center_active_window()` `user.mouse_scroll_up(0.2)`
wheel up	`user.mouse_scroll_up()`
wheel up here	`user.mouse_move_center_active_window()` `user.mouse_scroll_up()`
zoom mouse	`tracking.control_zoom_toggle()`

Mindmap

`mouse_cursor`

Context: user.community.plugin.mouse.mouse_cursor.talon

Spoken	Backend
curse no	`user.mouse_cursor_hide()`
curse yes	`user.mouse_cursor_show()`

Mindmap

`repeater`

Context: user.community.plugin.repeater.repeater.talon

Spoken	Backend
(repeat phrase \| again) [<number_small> times]	`core.repeat_partial_phrase(number_small or 1)`
(repeat that \| twice)	`core.repeat_command(1)`
<number_small> times	`core.repeat_command(number_small - 1)`
<user.ordinals>	`core.repeat_command(ordinals - 1)`
repeat that <number_small> [times]	`core.repeat_command(number_small)`

Mindmap

`screenshot`

Context: user.community.plugin.screenshot.screenshot.talon

Spoken	Backend
grab screen <number_small> clip	`user.screenshot_clipboard(number_small)`
grab screen <number_small>	`user.screenshot(number_small)`
grab screen clip	`user.screenshot_clipboard()`
grab screen	`user.screenshot()`
grab selection clip	`user.screenshot_selection_clip()`
grab selection	`user.screenshot_selection()`
grab settings	`user.screenshot_settings()`
grab window clip	`user.screenshot_window_clipboard()`
grab window	`user.screenshot_window()`

Mindmap

`symbols`

Context: user.community.plugin.symbols.symbols.talon

Spoken	Backend
(comma and \| spamma)	`", "`
(dot dot \| dotdot)	`".."`
<user.delimiter_pair>	`user.delimiter_pair_insert(delimiter_pair)`
<user.delimiter_pair> that	`user.delimiter_pair_wrap_selection(delimiter_pair)`
arrow	`"->"`
double dash	`"--"`
dub arrow	`"=>"`
ellipsis	`"..."`
new line	`"\\n"`
triple grave \| triple back tick \| gravy	"```"
triple quote	`"'''"`

Mindmap

`symbols_deprecated`

Context: user.community.plugin.symbols.symbols_deprecated.talon

Spoken	Backend
(brace \| curly bracket) that	`user.deprecate_command("2024-11-24", "(brace \| curly bracket) that", "curly that")` `text = edit.selected_text()` `user.paste("{{{text}}}")`
(double quote \| dub quote) that	`user.deprecate_command("2024-11-24", "(double quote \| dub quote) that", "quad that")` `text = edit.selected_text()` `user.paste('"{text}"')`
(grave \| back tick) that	`user.deprecate_command("2024-11-24", "(grave \| back tick) that", "skis that")` `text = edit.selected_text()` user.paste("`{text}`")
(parens \| args) that	`user.deprecate_command("2024-11-24", "(parens \| args) that", "round that")` `text = edit.selected_text()` `user.paste("({text})")`
(square \| bracket \| square bracket) that	`user.deprecate_command("2024-11-24", "(square \| bracket \| square bracket) that", "box that")` `text = edit.selected_text()` `user.paste("[{text}]")`
angle that	`user.deprecate_command("2024-11-24", "angle that", "diamond that")` `text = edit.selected_text()` `user.paste("<{text}>")`
empty dub string	`user.deprecate_command("2024-11-24", "empty dub string", "quad")` `user.insert_between('"', '"')`
empty escaped (dub string \| dub quotes)	`user.deprecate_command("2024-11-24", "empty escaped (dub string \| dub quotes)", "escaped quad")` `user.insert_between('\\"', '\\"')`
empty escaped string	`user.deprecate_command("2024-11-24", "empty escaped string", "escaped twin")` `user.insert_between("\\'", "\\'")`
empty string	`user.deprecate_command("2024-11-24", "empty string", "twin")` `user.insert_between("'", "'")`
inside (braces \| curly brackets)	`user.deprecate_command("2024-11-24", "inside (braces \| curly brackets)", "curly")` `user.insert_between("{", "}")`
inside (double quotes \| dub quotes)	`user.deprecate_command("2024-11-24", "inside (double quotes \| dub quotes)", "quad")` `user.insert_between('"', '"')`
inside (graves \| back ticks)	`user.deprecate_command("2024-11-24", "inside (graves \| back ticks)", "skis")` user.insert_between("`", "`")
inside (parens \| args)	`user.deprecate_command("2024-11-24", "inside (parens \| args)", "round")` `user.insert_between("(", ")")`
inside (quotes \| string)	`user.deprecate_command("2024-11-24", "inside (quotes \| string)", "twin")` `user.insert_between("'", "'")`
inside (squares \| brackets \| square brackets \| list)	`user.deprecate_command("2024-11-24", "inside (squares \| brackets \| square brackets \| list)", "box")` `user.insert_between("[", "]")`
inside percent	`user.deprecate_command("2024-11-24", "inside percent", "percentages")` `user.insert_between("%", "%")`
percent that	`user.deprecate_command("2024-11-24", "percent that", "percentages that")` `text = edit.selected_text()` `user.paste("%{text}%")`
quote that	`user.deprecate_command("2024-11-24", "quote that", "twin that")` `text = edit.selected_text()` `user.paste("'{text}'")`

Mindmap

`draft_global`

Context: user.community.plugin.talon_draft_window.draft_global.talon

Spoken	Backend
draft edit	`text = edit.selected_text()` `key(backspace)` `user.draft_show(text)`
draft edit all	`edit.select_all()` `text = edit.selected_text()` `key(backspace)` `user.draft_show(text)`
draft empty	`user.draft_show("")`
draft show	`user.draft_hide()` `user.draft_show()`
draft show <user.draft_window_position>	`user.draft_hide()` `user.draft_show()` `user.draft_named_move(draft_window_position)`
draft show large	`user.draft_hide()` `user.draft_show()` `user.draft_resize(800, 500)`
draft show small	`user.draft_hide()` `user.draft_show()` `user.draft_resize(600, 200)`

Mindmap

`draft_window`

Context: user.community.plugin.talon_draft_window.draft_window.talon

Spoken	Backend
(change \| chuck \| clear) <user.draft_anchor>	`user.draft_select("{draft_anchor}", "", 1)` `key(backspace)`
(change \| chuck \| clear) <user.draft_anchor> (through \| past) <user.draft_anchor>	`user.draft_select(draft_anchor_1, draft_anchor_2, 1)` `key(backspace)`
(post \| cursor after) <user.draft_anchor>	`user.draft_position_caret("{draft_anchor}", 1)`
(pre \| cursor \| cursor before) <user.draft_anchor>	`user.draft_position_caret("{draft_anchor}")`
(take \| select) <user.draft_anchor>	`user.draft_select("{draft_anchor}")`
(take \| select) <user.draft_anchor> (through \| past) <user.draft_anchor>	`user.draft_select("{draft_anchor_1}", "{draft_anchor_2}")`
<user.formatters> <user.draft_anchor> (through \| past) <user.draft_anchor>	`user.draft_select(draft_anchor_1, draft_anchor_2, 1)` `user.formatters_reformat_selection(user.formatters)`
<user.formatters> word <user.draft_anchor>	`user.draft_select("{draft_anchor}", "", 1)` `user.formatters_reformat_selection(user.formatters)`
replace <user.draft_anchor> with <user.text>	`user.draft_select("{draft_anchor}")` `result = user.formatted_text(text, "NOOP")` `insert(result)`

Mindmap

`draft_window_open`

Context: user.community.plugin.talon_draft_window.draft_window_open.talon

Spoken	Backend
draft hide	`user.draft_hide()`
draft submit	`content = user.draft_get_text()` `user.draft_hide()` `insert(content)`

Mindmap

`talon_helpers`

Context: user.community.plugin.talon_helpers.talon_helpers.talon

Spoken	Backend
talon copy active app	`result = user.talon_get_active_application_info()` `clip.set_text(result)`
talon copy list {user.talon_lists}	`user.talon_copy_list(talon_lists)`
talon create app context	`user.talon_create_app_context()`
talon create linux app context	`user.talon_create_app_context("linux")`
talon create mac app context	`user.talon_create_app_context("mac")`
talon create windows app context	`user.talon_create_app_context("win")`
talon debug action {user.talon_actions}	`user.talon_action_find("{user.talon_actions}")`
talon debug active app	`result = user.talon_get_active_application_info()` `print("** Dumping active application ")` `print(result)` `print("*********************")`
talon debug all settings	`user.talon_debug_all_settings()`
talon debug list {user.talon_lists}	`user.talon_debug_list(talon_lists)`
talon debug modes	`user.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 tags	`user.talon_debug_tags()`
talon test	`user.talon_sim_phrase(phrase)`
talon test last	`phrase = user.history_get(1)` `user.talon_sim_phrase(phrase)`
talon test numb <number_small>	`phrase = user.history_get(number_small)` `user.talon_sim_phrase(phrase)`
talon (bug report \| report bug)	`user.open_url("https://github.com/talonhub/community/issues")`
talon check updates	`menu.check_for_updates()`
talon copy bundle	`bundle = app.bundle()` `clip.set_text(bundle)`
talon copy class	`class_name = user.talon_get_active_window_class_name()` `clip.set_text(class_name)`
talon copy context	`user.talon_add_context_clipboard()`
talon copy context pie	`user.talon_add_context_clipboard_python()`
talon copy executable	`executable = app.executable()` `clip.set_text(executable)`
talon copy name	`name = app.name()` `clip.set_text(name)`
talon copy title	`title = win.title()` `clip.set_text(title)`
talon dump context	`result = user.talon_get_active_context()` `print(result)`
talon dump version	`result = user.talon_version_info()` `print(result)`
talon home	`menu.open_talon_home()`
talon insert version	`result = user.talon_version_info()` `user.paste(result)`
talon open debug	`menu.open_debug_window()`
talon open log	`menu.open_log()`
talon open rebel	`menu.open_repl()`

Mindmap

`text_navigation`

Context: user.community.plugin.text_navigation.text_navigation.talon

Spoken	Backend
big word neck [<number_small>]	`user.navigation_by_name("SELECT", "RIGHT", "DEFAULT", "big", number_small or 1)`
big word pre [<number_small>]	`user.navigation_by_name("SELECT", "LEFT", "DEFAULT", "big", number_small or 1)`
navigate [{user.arrow_key}] [{user.navigation_action}] [{user.navigation_target_name}] [{user.before_or_after}] [<user.ordinals>] <user.navigation_target>	`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)`
small word neck [<number_small>]	`user.navigation_by_name("SELECT", "RIGHT", "DEFAULT", "small", number_small or 1)`
small word pre [<number_small>]	`user.navigation_by_name("SELECT", "LEFT", "DEFAULT", "small", number_small or 1)`
word neck [<number_small>]	`user.navigation_by_name("SELECT", "RIGHT", "DEFAULT", "word", number_small or 1)`
word pre [<number_small>]	`user.navigation_by_name("SELECT", "LEFT", "DEFAULT", "word", number_small or 1)`

Mindmap

`then`

Context: user.community.plugin.then.then.talon

Spoken	Backend
then	`skip()`

Mindmap

`address`

Context: user.community.tags.address.address.talon

Spoken	Backend
address bar \| go address \| go url	`user.address_focus()`
address copy \| copy path \| url copy \| copy address \| copy url	`user.address_copy_address()`
go [to] <user.address>	`user.address_navigate(address)`

Mindmap

`browser`

Context: user.community.tags.browser.browser.talon

Spoken	Backend
(refresh \| reload) it	`browser.reload()`
(refresh \| reload) it hard	`browser.reload_hard()`
bookmark bar [show]	`browser.bookmarks_bar()`
bookmark it	`browser.bookmark()`
bookmark show	`browser.bookmarks()`
bookmark tabs	`browser.bookmark_tabs()`
cache show	`browser.show_clear_cache()`
dev tools [show]	`browser.toggle_dev_tools()`
downloads show	`browser.show_downloads()`
extensions show	`browser.show_extensions()`
go home	`browser.go_home()`
go page \| page focus	`browser.focus_page()`
go private	`browser.open_private_window()`
history show	`browser.show_history()`
show cache	`browser.show_clear_cache()`
show downloads	`browser.show_downloads()`
show extensions	`browser.show_extensions()`
show history	`browser.show_history()`

Mindmap

`chapters`

Context: user.community.tags.chapters.chapters.talon

Spoken	Backend
chapter last	`user.chapter_previous()`
chapter next	`user.chapter_next()`
go chapter	`user.chapter_jump(number)`
go chapter final	`user.chapter_final()`

Mindmap

`command_search`

Context: user.community.tags.command_search.command_search.talon

Spoken	Backend
please [<user.text>]	`user.command_search(user.text or "")`

Mindmap

`debugger`

Context: user.community.tags.debugger.debugger.talon

Spoken	Backend
(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()`
(stack \| back) trace	`user.debugger_backtrace()`
break here	`user.debugger_break_here()`
break now	`user.debugger_break_now()`
clear (break \| break point)	`user.debugger_clear_breakpoint()`
clear (break \| break point) <number_small>	`user.debugger_clear_breakpoint_id(number_small)`
clear all (breaks \| break points)	`user.debugger_clear_all_breakpoints()`
clear line	`user.debugger_clear_line()`
continue	`user.debugger_continue()`
debug detach	`user.debugger_detach()`
debug exit	`user.debugger_exit()`
debug restart	`user.debugger_restart()`
debug start	`user.debugger_start()`
debug stop	`user.debugger_stop()`
disable (break \| break point)	`user.debugger_disable_breakpoint()`
disable (break \| break point) <number_small>	`user.debugger_disable_breakpoint_id(number_small)`
disable all (breaks \| break points)	`user.debugger_disable_all_breakpoints()`
disassemble	`user.debugger_disassemble()`
disassemble clipboard	`user.debugger_disassemble_clipboard()`
disassemble here	`user.debugger_disassemble_here()`
dump pointers	`user.debugger_dump_pointers()`
dump string	`user.debugger_dump_ascii_string()`
dump unicode [string]	`user.debugger_dump_unicode_string()`
enable (break \| break point)	`user.debugger_enable_breakpoint()`
enable (break \| break point) <number_small>	`user.debugger_enable_breakpoint_id(number_small)`
enable all (breaks \| break points)	`user.debugger_enable_all_breakpoints()`
get register	`user.debugger_get_register()`
inspect type	`user.debugger_inspect_type()`
jump to address	`user.debugger_goto_address()`
jump to clipboard	`user.debugger_goto_clipboard()`
jump to highlighted	`user.debugger_goto_highlighted()`
list modules	`user.debugger_list_modules()`
set register	`user.debugger_set_register()`
show registers	`user.debugger_show_registers()`
step into	`user.debugger_step_into()`
step line	`user.debugger_step_line()`
step out	`user.debugger_step_out()`
step over	`user.debugger_step_over()`
step over line	`user.debugger_step_over_line()`

Mindmap

`emoji`

Context: user.community.tags.emoji.emoji.talon

Spoken	Backend
emoji {user.emoji}	`user.paste(emoji)`
emoticon {user.emoticon}	`"{emoticon}"`
kaomoji {user.kaomoji}	`user.paste(kaomoji)`

Mindmap

`file_manager`

Context: user.community.tags.file_manager.file_manager.talon

Spoken	Backend
[select \| cell] file {user.file_manager_files}	`user.file_manager_select_file(file_manager_files)`
[select \| cell] file numb <number_small>	`file = user.file_manager_get_file_by_index(number_small - 1)` `user.file_manager_select_file(file)`
[select \| cell] folder {user.file_manager_directories}	`user.file_manager_select_directory(file_manager_directories)`
[select \| cell] folder numb <number_small>	`directory = user.file_manager_get_directory_by_index(number_small - 1)` `user.file_manager_select_directory(directory)`
follow {user.file_manager_directories}	`user.file_manager_open_directory(file_manager_directories)`
follow numb <number_small>	`directory = user.file_manager_get_directory_by_index(number_small - 1)` `user.file_manager_open_directory(directory)`
open {user.file_manager_files}	`user.file_manager_open_file(file_manager_files)`
open numb <number_small>	`file = user.file_manager_get_file_by_index(number_small - 1)` `user.file_manager_open_file(file)`
(go parent \| daddy)	`user.file_manager_open_parent()`
file last	`user.file_manager_previous_file_page()`
file next	`user.file_manager_next_file_page()`
folder last	`user.file_manager_previous_folder_page()`
folder new [<user.text>]	`user.file_manager_new_folder(text or "")`
folder next	`user.file_manager_next_folder_page()`
manager close	`user.file_manager_hide_pickers()`
manager refresh	`user.file_manager_update_lists()`
manager show	`user.file_manager_toggle_pickers()`
properties show	`user.file_manager_show_properties()`
terminal here	`user.file_manager_terminal_here()`
title force	`user.file_manager_refresh_title()`

Mindmap

`file_manager_win`

Context: user.community.tags.file_manager.file_manager_win.talon

Spoken	Backend
go {user.letter}	`user.file_manager_open_volume("{letter}:\\")`

Mindmap

`find`

Context: user.community.tags.find.find.talon

Spoken	Backend
hunt next	`edit.find_next()`
hunt previous	`edit.find_previous()`
hunt this	`edit.find()`
hunt this (pace \| paste)	`edit.find()` `sleep(25ms)` `edit.paste()`
hunt this <user.text>	`edit.find(text)`

Mindmap

`find_and_replace`

Context: user.community.tags.find_and_replace.find_and_replace.talon

Spoken	Backend
clear last <user.text> [over]	`user.select_previous_occurrence(text)` `sleep(100ms)` `edit.delete()`
clear last clip	`user.select_previous_occurrence(clip.text())` `edit.delete()`
clear next <user.text> [over]	`user.select_next_occurrence(text)` `sleep(100ms)` `edit.delete()`
clear next clip	`user.select_next_occurrence(clip.text())` `sleep(100ms)` `edit.delete()`
comment last <user.text> [over]	`user.select_previous_occurrence(text)` `sleep(100ms)` `code.toggle_comment()`
comment last clip	`user.select_previous_occurrence(clip.text())` `sleep(100ms)` `code.toggle_comment()`
comment next <user.text> [over]	`user.select_next_occurrence(text)` `sleep(100ms)` `code.toggle_comment()`
comment next clip	`user.select_next_occurrence(clip.text())` `sleep(100ms)` `code.toggle_comment()`
go last <user.text> [over]	`user.select_previous_occurrence(text)` `sleep(100ms)` `edit.right()`
go last clip	`user.select_previous_occurrence(clip.text())` `sleep(100ms)` `edit.right()`
go next <user.text> [over]	`user.select_next_occurrence(text)` `edit.right()`
go next clip	`user.select_next_occurrence(clip.text())` `edit.right()`
hunt all	`user.find_everywhere("")`
hunt all (pace \| paste)	`user.find_everywhere("")` `sleep(25ms)` `edit.paste()`
hunt all <user.text>	`user.find_everywhere(text)`
hunt case	`user.find_toggle_match_by_case()`
hunt expression	`user.find_toggle_match_by_regex()`
hunt word	`user.find_toggle_match_by_word()`
paste last <user.text> [over]	`user.select_previous_occurrence(text)` `sleep(100ms)` `edit.right()` `edit.paste()`
paste next <user.text> [over]	`user.select_next_occurrence(text)` `sleep(100ms)` `edit.right()` `edit.paste()`
replace <user.text> all	`user.replace_everywhere(text)`
replace all	`user.replace_everywhere("")`
replace confirm all	`user.replace_confirm_all()`
replace confirm that	`user.replace_confirm()`
replace last <user.text> [over]	`user.select_previous_occurrence(text)` `sleep(100ms)` `edit.paste()`
replace next <user.text> [over]	`user.select_next_occurrence(text)` `sleep(100ms)` `edit.paste()`
replace this [<user.text>]	`user.replace(text or "")`
select last <user.text> [over]	`user.select_previous_occurrence(text)`
select last clip	`user.select_previous_occurrence(clip.text())`
select next <user.text> [over]	`user.select_next_occurrence(text)`
select next clip	`user.select_next_occurrence(clip.text())`

Mindmap

`line_commands`

Context: user.community.tags.line_commands.line_commands.talon

Spoken	Backend
(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)`
bend	`user.deprecate_command("2024-07-30", "bend", "go line start \| head")` `edit.line_start()`
clear [line]	`user.select_range(number, number)` `edit.delete()`
clear until	`user.select_range(number_1, number_2)` `edit.delete()`
clone [line]	`user.line_clone(number)`
comment [line]	`user.select_range(number, number)` `code.toggle_comment()`
comment until	`user.select_range(number_1, number_2)` `code.toggle_comment()`
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()`
drag [line] down	`edit.line_swap_down()`
drag [line] up	`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()`
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()`
go	`edit.jump_line(number)`
go end	`edit.jump_line(number)` `edit.line_end()`
go camel left	`user.camel_left()`
go camel right	`user.camel_right()`
lend	`user.deprecate_command("2024-07-30", "lend", "go line end \| tail")` `edit.line_end()`
retab [line]	`user.select_range(number, number)` `edit.indent_less()`
retab until	`user.select_range(number_1, number_2)` `edit.indent_less()`
retab that	`edit.indent_less()`
select camel left	`user.extend_camel_left()`
select camel right	`user.extend_camel_right()`
tab [line]	`edit.jump_line(number)` `edit.indent_more()`
tab until	`user.select_range(number_1, number_2)` `edit.indent_more()`
tab that	`edit.indent_more()`

Mindmap

`messaging`

Context: user.community.tags.messaging.messaging.talon

Spoken	Backend
([channel] unread last \| gopreev)	`user.messaging_unread_previous()`
([channel] unread next \| goneck)	`user.messaging_unread_next()`
channel	`user.messaging_open_channel_picker()`
channel <user.text>	`user.messaging_open_channel_picker()` `insert(user.formatted_text(user.text, "ALL_LOWERCASE"))`
channel down	`user.messaging_channel_next()`
channel up	`user.messaging_channel_previous()`
go (find \| search)	`user.messaging_open_search()`
mark (all \| workspace \| server) read	`user.messaging_mark_workspace_read()`
mark channel read	`user.messaging_mark_channel_read()`
next (workspace \| server)	`user.messaging_workspace_next()`
previous (workspace \| server)	`user.messaging_workspace_previous()`
upload file	`user.messaging_upload_file()`

Mindmap

`multiple_cursors`

Context: user.community.tags.multiple_cursors.multiple_cursors.talon

Spoken	Backend
cursor all	`user.multi_cursor_select_all_occurrences()`
cursor down	`user.multi_cursor_add_below()`
cursor less	`user.multi_cursor_select_fewer_occurrences()`
cursor lines	`user.multi_cursor_add_to_line_ends()`
cursor more	`user.multi_cursor_select_more_occurrences()`
cursor multiple	`user.multi_cursor_enable()`
cursor skip	`user.multi_cursor_skip_occurrence()`
cursor stop	`user.multi_cursor_disable()`
cursor up	`user.multi_cursor_add_above()`

Mindmap

`pages`

Context: user.community.tags.pages.pages.talon

Spoken	Backend
go page	`user.page_jump(number)`
go page final	`user.page_final()`
page last	`user.page_previous()`
page next	`user.page_next()`
rotate left	`user.page_rotate_left()`
rotate right	`user.page_rotate_right()`

Mindmap

`splits`

Context: user.community.tags.splits.splits.talon

Spoken	Backend
go split	`user.split_number(number)`
split (horizontally \| horizontal)	`user.split_window_horizontally()`
split (vertically \| vertical)	`user.split_window_vertically()`
split clear	`user.split_clear()`
split clear all	`user.split_clear_all()`
split down	`user.split_window_down()`
split flip	`user.split_flip()`
split last	`user.split_last()`
split left	`user.split_window_left()`
split max	`user.split_maximize()`
split next	`user.split_next()`
split reset	`user.split_reset()`
split right	`user.split_window_right()`
split up	`user.split_window_up()`
split window	`user.split_window()`

Mindmap

`terminal`

Context: user.community.tags.terminal.terminal.talon

Spoken	Backend
clear screen	`user.terminal_clear_screen()`
copy paste	`edit.copy()` `sleep(50ms)` `edit.paste()`
go <user.system_path>	`insert('cd "{system_path}"\\n')`
katie (up \| back)	`user.terminal_change_directory("..")`
katie [dir] [<user.text>]	`user.terminal_change_directory(text or "")`
katie root	`user.terminal_change_directory_root()`
kill all	`user.terminal_kill_all()`
lisa	`user.terminal_list_directories()`
lisa all	`user.terminal_list_all_directories()`
path <user.system_path>	`insert('"{system_path}"')`
rerun [<user.text>]	`user.terminal_rerun_search(text or "")`
rerun search	`user.terminal_rerun_search("")`
run last	`user.terminal_run_last()`

Mindmap

`unix_utilities`

Context: user.community.tags.terminal.unix_utilities.talon

Spoken	Backend
core {user.unix_utility}	`"{unix_utility} "`

Mindmap

`cursorless`

Context: user.cursorless-talon.src.cursorless.talon

Spoken	Backend
{user.cursorless_bring_move_action} <user.cursorless_bring_move_targets>	`user.private_cursorless_bring_move(cursorless_bring_move_action, cursorless_bring_move_targets)`
{user.cursorless_call_action} <user.cursorless_target> on <user.cursorless_target>	`user.private_cursorless_call(cursorless_target_1, cursorless_target_2)`
{user.cursorless_hide_scope_visualizer}	`user.private_cursorless_hide_scope_visualizer()`
{user.cursorless_homophone} migrate snippets	`user.private_cursorless_migrate_snippets()`
{user.cursorless_homophone} settings	`user.private_cursorless_show_settings_in_ide()`
{user.cursorless_homophone} stats	`user.private_cursorless_show_command_statistics()`
{user.cursorless_homophone} tutorial	`user.private_cursorless_start_tutorial()`
{user.cursorless_insert_snippet_action} {user.snippet} <user.cursorless_destination>	`user.private_cursorless_insert_community_snippet(snippet, cursorless_destination)`
{user.cursorless_paste_action} <user.cursorless_destination>	`user.private_cursorless_paste(cursorless_destination)`
{user.cursorless_reformat_action} <user.formatters> at <user.cursorless_target>	`user.cursorless_reformat(cursorless_target, formatters)`
{user.cursorless_show_scope_visualizer} <user.cursorless_scope_type> [{user.cursorless_visualization_type}]	`user.private_cursorless_show_scope_visualizer(cursorless_scope_type, cursorless_visualization_type or "content")`
{user.cursorless_swap_action} <user.cursorless_swap_targets>	`user.private_cursorless_swap(cursorless_swap_targets)`
{user.snippet_wrapper} {user.cursorless_wrap_action} <user.cursorless_target>	`user.private_cursorless_wrap_with_community_snippet(snippet_wrapper, cursorless_target)`
<user.cursorless_action_or_ide_command> <user.cursorless_target>	`user.private_cursorless_action_or_ide_command(cursorless_action_or_ide_command, cursorless_target)`
<user.cursorless_wrapper_paired_delimiter> {user.cursorless_wrap_action} <user.cursorless_target>	`user.private_cursorless_wrap_with_paired_delimiter(cursorless_wrap_action, cursorless_target, cursorless_wrapper_paired_delimiter)`
bar {user.cursorless_homophone}	`user.private_cursorless_show_sidebar()`
tutorial (list \| close)	`user.private_cursorless_tutorial_list()`
tutorial (previous \| last)	`user.private_cursorless_tutorial_previous()`
tutorial <number_small>	`user.private_cursorless_tutorial_start_by_number(number_small)`
tutorial next	`user.private_cursorless_tutorial_next()`
tutorial restart	`user.private_cursorless_tutorial_restart()`
tutorial resume	`user.private_cursorless_tutorial_resume()`

Mindmap

`cursorless_global`

Context: user.cursorless-talon.src.cursorless_global.talon

Spoken	Backend
{user.cursorless_homophone} (instructions \| docks \| help) \| help {user.cursorless_homophone}	`user.private_cursorless_open_instructions()`
{user.cursorless_homophone} (reference \| ref \| cheatsheet \| cheat sheet)	`user.private_cursorless_cheat_sheet_show_html()`

Mindmap

`talon_helpers`

Context: user.my-overrides.andreas_arvidsson.talon_helpers.talon

Spoken	Backend
talon restart	`user.talon_restart()`
talon check updates	`menu.check_for_updates()`
talon copy <user.text> actions	`clip.set_text(user.talon_get_actions_search(text))`
talon copy actions	`clip.set_text(user.talon_get_actions())`
talon copy actions long	`clip.set_text(user.talon_get_actions_long())`
talon copy captures	`clip.set_text(user.talon_get_captures())`
talon copy commands	`user.help_copy_all_commands()`
talon copy context	`user.talon_add_context_clipboard()`
talon copy core	`clip.set_text(user.talon_get_core())`
talon copy modes	`clip.set_text(user.talon_get_modes())`
talon copy name	`clip.set_text(app.name())`
talon copy python context	`user.talon_add_context_clipboard_python()`
talon copy tags	`clip.set_text(user.talon_get_tags())`
talon copy title	`clip.set_text(win.title())`
talon create app context	`user.talon_create_app_context()`
talon open debug	`menu.open_debug_window()`
talon open home	`menu.open_talon_home()`
talon open log	`menu.open_log()`
talon open repl	`menu.open_repl()`
talon print <user.text> actions	`print(" \\n{user.talon_get_actions_search(text)}")`
talon print actions	`print(" \\n{user.talon_get_actions()}")`
talon print actions long	`print(" \\n{user.talon_get_actions_long()}")`
talon print captures	`print(" \\n{user.talon_get_captures()}")`
talon print context	`name = app.name()` `executable = app.executable()` `title = win.title()` `print("Name: {name}")` `print("Executable: {executable}")` `print("Title: {title}")`
talon print core	`print(" \\n{user.talon_get_core()}")`
talon print list problems	`user.talon_print_list_problems()`
talon print lists	`print(" \\n{user.talon_get_lists()}")`
talon print modes	`print(" \\n{user.talon_get_modes()}")`
talon print name	`print(app.name())`
talon print tags	`print(" \\n{user.talon_get_tags()}")`
talon print title	`print(win.title())`
talon show lists	`user.show_talon_lists()`
talon sim	`user.talon_sim_phrase(phrase)`

Mindmap

`community-aliases-awake`

Context: user.my-overrides.community.aliases.community-aliases-awake.talon

Spoken	Backend
drowse []	`speech.disable()`

Mindmap

`community-aliases-global`

Context: user.my-overrides.community.aliases.community-aliases-global.talon

Spoken	Backend
nope	`edit.undo()`
waze	`user.mouse_gaze_scroll()`
waze here	`user.mouse_move_center_active_window()` `user.mouse_gaze_scroll()`

Mindmap

`anki`

Context: user.my-overrides.community.apps.anki.talon

Spoken	Backend
[go] back	`key(ctrl-z)`
[rate] again	`key(1)`
[rate] easy	`key(4)`
[rate] good	`key(3)`
[rate] hard	`key(2)`
[show] answer	`key(space)`
browse	`key(b)`
decks	`key(d)`
sync	`key(y)`

Mindmap

`bash`

Context: user.my-overrides.community.apps.bash.bash.talon

Spoken	Backend
apt install	`"apt install "`
apt update	`"apt update\\n"`
cancel	`key(ctrl-c)`
cat	`"cat "`
cd	`"cd "`
change mode	`"chmod "`
change owner	`"chown "`
clear	`key(ctrl-l)`
clipboard	`"clipboard"`
copy	`"cp "`
copy dir	`"pwd \| clipboard\\n"`
curl	`"curl "`
dev null	`"/dev/null"`
diff	`"diff "`
dir	`"cd "`
dir <user.letters> tab	`"cd {letters}\t"`
dir <user.letters>	`"cd {letters}"`
dir <user.text> tab	`"cd {text}\t"`
dir <user.text>	`"cd {text}"`
docker compose up	`"docker compose up -d && docker compose logs -f\\n"`
docker image	`"docker image "`
docker image list	`"docker image ls\\n"`
docker image tag	`"docker image tag "`
docker login	`"docker login\\n"`
docker run	`"docker run --rm -it "`
drop	`key(ctrl-d)`
echo	`"echo "`
echo <user.text>	`"echo {text}"`
edit	`key(ctrl-x)` `key(ctrl-e)`
exargs	`"xargs "`
exec	`"exec "`
flag	`" -"`
flag <user.letters>	`" -{letters} "`
grep	`"grep "`
head <number_small>	`"head -{number_small}"`
history	`"history "`
history grep	`"history \| grep "`
history tail	`"history \| tail\\n"`
history tail <number_small>	`"history \| tail -{number_small}\\n"`
jump	`"autojump "`
just	`"just "`
less	`"less "`
list	`"ls\\n"`
list all	`"ls -a\\n"`
list long	`"ls -lah\\n"`
list long pipe	`"ls -lah \| "`
make dir	`"mkdir "`
move	`"mv "`
op and	`" && "`
op or	`" \|\| "`
pipe	`" \| "`
print dir	`"pwd\\n"`
print exit code	`"echo $?\\n"`
revert	`key(alt-r)`
run history	`"!{number}\\n"`
run last	`"!!\\n"`
run last	`"!-{number}\\n"`
ssh	`"ssh "`
sudo	`"sudo "`
tail <number_small>	`"tail -{number_small}"`
talon user update	`"find {user.talon_user()} -type d -name .git -print -execdir git pull --ff-only \\;\\n"` `"git -C {user.user_home()}/repositories/cursorless-talon pull\\n"`
tar create	`"tar -czvf "`
tar extractf	`"tar -xzvf "`
terminate	`key(ctrl-c)`
touch	`"touch "`
translate	`"tr "`
trash put	`"trash-put "`
tree files	`"tree\\n"`
tree folders	`"tree -d\\n"`
unique	`"uniq "`
vim	`"vim "`
watch talon log	`"tail -f {user.talon_home()}/talon.log\\n"`
yarn	`"yarn "`

Mindmap

`firefox`

Context: user.my-overrides.community.apps.firefox.talon

Spoken	Backend
reopen tab	`key(ctrl-shift-t)`

Mindmap

`joplin`

Context: user.my-overrides.community.apps.joplin.talon

Spoken	Backend
edit (note \| this)	`key(ctrl-e)`
find it	`key(ctrl-f)`
find it everywhere	`key(f6)`
go to anything	`key(ctrl-p)`
go to options	`key(ctrl-,)`
new note	`key(ctrl-n)`
synchronize	`key(ctrl-s)`
toggle layout	`key(ctrl-l)`
toggle sidebar	`key(f10)`

Mindmap

`slack_linux`

Context: user.my-overrides.community.apps.slack.slack_linux.talon

Spoken	Backend
([toggle] mute \| unmute)	`key(m)`
(element \| bit) (previous \| last)	`key(shift-tab)`
(element \| bit) [next]	`key(tab)`
(go \| undo \| toggle) full	`key(ctrl-ctrl-f)`
(insert command \| commandify)	`key(ctrl-shift-c)`
(italic \| italicize)	`key(ctrl-i)`
(section \| zone) (previous \| last)	`key(shift-f6)`
(section \| zone) [next]	`key(f6)`
(slack \| lack) ([toggle] video)	`key(v)`
(slack \| lack) (bull \| bullet \| bulleted) [list]	`key(ctrl-shift-8)`
(slack \| lack) (history [next] \| back \| backward)	`key(ctrl-[)`
(slack \| lack) (my stuff \| activity)	`key(ctrl-shift-m)`
(slack \| lack) (number \| numbered) [list]	`key(ctrl-shift-7)`
(slack \| lack) (quotes \| quotation)	`key(ctrl-shift->)`
(slack \| lack) (react \| reaction)	`key(ctrl-shift-\)`
(slack \| lack) (slap \| slaw \| slapper)	`key(ctrl-right shift-enter)`
(slack \| lack) (starred [items] \| stars)	`key(ctrl-shift-s)`
(slack \| lack) [channel] info	`key(ctrl-shift-i)`
(slack \| lack) [direct] messages	`key(ctrl-shift-k)`
(slack \| lack) directory	`key(ctrl-shift-e)`
(slack \| lack) forward	`key(ctrl-])`
(slack \| lack) huddle	`key(ctrl-shift-h)`
(slack \| lack) invite	`key(a)`
(slack \| lack) shortcuts	`key(ctrl-/)`
(slack \| lack) snippet	`key(ctrl-shift-enter)`
(slack \| lack) threads	`key(ctrl-shift-t)`
(slack \| lack) unread [messages]	`key(ctrl-shift-a)`
(strike \| strikethrough)	`key(ctrl-shift-x)`
add line	`key(shift-enter)`
bold	`key(ctrl-b)`
focus (move \| next)	key(ctrl-`)
grab left	`key(shift-up)`
grab right	`key(shift-down)`
insert code	`key(ctrl-shift-alt-c)`
insert link	`key(ctrl-shift-u)`
send	`key(ctrl-enter)`
toggle left sidebar	`key(ctrl-shift-d)`
toggle right sidebar	`key(ctrl-.)`
workspace	`key("ctrl-{number}")`

Mindmap

`tmux`

Context: user.my-overrides.community.apps.tmux.tmux.talon

Spoken	Backend
go split	`user.tmux_execute_command("display-panes -d 0")`
go split <user.arrow_key>	`user.tmux_keybind(arrow_key)`

Mindmap

`tmux_linux`

Context: user.my-overrides.community.apps.tmux.tmux_linux.talon

Spoken	Backend
mux	`"tmux "`
mux close pane	`key(ctrl-b)` `key(x)`
mux close window	`key(ctrl-b)` `key(&)`
mux kill session	`insert("tmux kill-session -t ")`
mux move <user.arrow_key>	`key(ctrl-b)` `key(arrow_key)`
mux name session	`key(ctrl-b)` `key($)`
mux new session	`insert("tmux new ")`
mux new window	`key(ctrl-b)` `key(c)`
mux next pane	`key(ctrl-b)` `key(o)`
mux next window	`key(ctrl-b)` `key(n)`
mux pane numbers	`key(ctrl-b)` `key(q)`
mux previous window	`key(ctrl-b)` `key(p)`
mux rename window	`key(ctrl-b)` `key(,)`
mux sessions	`key(ctrl-b)` `key(s)`
mux split horizontal	`key(ctrl-b)` `key(%)`
mux split vertical	`key(ctrl-b)` `key(")`
mux window	`key(ctrl-b)` `key('{number}')`

Mindmap

`vscode`

Context: user.my-overrides.community.apps.vscode.talon

Spoken	Backend
hats off	`user.run_rpc_command("cursorless.toggleDecorations", false)`
hats on	`user.run_rpc_command("cursorless.toggleDecorations", true)`

Mindmap

`xournalpp`

Context: user.my-overrides.community.apps.xournalpp.talon

Spoken	Backend
add latex	`key(ctrl-shift-x)`
change font	`key(ctrl-shift-f)`
draw (ellipse \| circle)	`key(ctrl-3)`
draw (rectangle \| square)	`key(ctrl-2)`
draw arrow	`key(ctrl-4)`
draw coordinate system	`key(ctrl-6)`
draw double arrow	`key(ctrl-5)`
draw line	`key(ctrl-7)`
draw nothing	`key(ctrl-7)` `sleep(50ms)` `key(ctrl-8)` `sleep(50ms)` `key(ctrl-8)`
draw spline	`key(ctrl-8)`
erase \| delete	`key(delete)`
file export	`key(ctrl-e)`
file new	`key(ctrl-n)`
file open	`key(ctrl-o)`
file quit	`key(ctrl-q)`
file save	`key(ctrl-s)`
layer delete	`key(ctrl-shift-l)`
layer last	`key(shift-pagedown)`
layer new	`key(ctrl-l)`
layer next	`key(shift-pageup)`
page delete	`key(ctrl-shift-delete)`
page first	`key(ctrl-home)`
page last	`key(ctrl-pageup)`
page new	`key(ctrl-d)`
page next	`key(ctrl-pagedown)`
redo [this \| that]	`key(ctrl-y)`
select object	`key(ctrl-shift-o)`
select rect	`key(ctrl-shift-r)`
select region	`key(ctrl-shift-g)`
shape recognizer	`key(ctrl-1)`
tool default	`key(ctrl-shift-d)`
tool eraser	`key(ctrl-shift-e)`
tool hand	`key(ctrl-shift-a)`
tool highlight	`key(ctrl-shift-h)`
tool image	`key(ctrl-shift-i)`
tool pen	`key(ctrl-shift-p)`
tool text	`key(ctrl-shift-t)`
undo [this \| that]	`key(ctrl-z)`
vertical space	`key(ctrl-shift-v)`

Mindmap

`command-mode-shortcuts`

Context: user.my-overrides.community.command-mode-shortcuts.talon

Spoken	Backend
kak	`key(ctrl-backspace)`

Mindmap

`keepass`

Context: user.my-overrides.community.tags.keepass.keepass.talon

Spoken	Backend
auto type	`key(alt-shift-p)`

Mindmap

`term_basics`

Context: user.my-overrides.community.tags.terminal.term_basics.talon

Spoken	Backend
cancel	`key(ctrl-c)`
clear	`key(ctrl-l)`
copy dir	`"pwd \| clipboard\\n"`
dev null	`"/dev/null"`
drop	`key(ctrl-d)`
edit	`key(ctrl-x)` `key(ctrl-e)`
flag	`" -"`
flag <user.letters>	`" -{letters} "`
op and	`" && "`
op or	`" \|\| "`
pipe	`" \| "`
print dir	`"pwd\\n"`
print exit code	`"echo $?\\n"`
rerun	`key(ctrl-c)` `sleep(50ms)` `key(up)` `key(enter)` `key(enter)`
revert	`key(alt-r)`
run history	`"!{number}\\n"`
run last	`"!!\\n"`
run last	`"!-{number}\\n"`
terminate	`key(ctrl-c)`

Mindmap

`term_docker`

Context: user.my-overrides.community.tags.terminal.term_docker.talon

Spoken	Backend
docker compose logs	`"docker compose logs -f\\n"`
docker compose up	`"docker compose up -d && docker compose logs -f\\n"`
docker image	`"docker image "`
docker image list	`"docker image ls\\n"`
docker image tag	`"docker image tag "`
docker login	`"docker login\\n"`
docker ps	`"docker ps "`
docker run	`"docker run --rm -it "`
docker stop	`"docker stop "`

Mindmap

`term_git`

Context: user.my-overrides.community.tags.terminal.term_git.talon

Spoken	Backend
git	`"git "`
git add	`"git add "`
git checkout last	`"git checkout -\\n"`
git clean	`"git clean "`
git diff <user.text>	`"git diff {text}"`
git diff halt	`"git diff "`
git fetch	`"git fetch "`
git fetch all	`"git fetch -a\\n"`
git fetch prune	`"git fetch --prune origin\\n"`
git fetch upstream	`"git fetch upstream\\n"`
git init	`"git init\\n"`
git log original	`"git log\\n"`
git numstat	`user.git_numstat("")`
git numstat month	`user.git_numstat("1 month")`
git numstat week	`user.git_numstat("1 week")`
git numstat year	`user.git_numstat("1 year")`
git pull upstream	`"git pull upstream\\n"`
git pull upstream main	`"git pull upstream main\\n"`
git pull upstream master	`"git pull upstream master\\n"`
git push deli	`"git push origin -d "`
git rebase	`"git rebase "`
git reflog	`"git reflog\\n"`
git remove	`"git rm "`
git reset	`"git reset "`
git reset hard	`"git reset --hard "`
git reset head	`"git reset --soft HEAD^"`
git reset soft	`"git reset --soft "`
git revert	`"git revert "`
git shortlog	`"git shortlog -sn\\n"`
git verison	`"git --version\\n"`

Mindmap

`term_talon`

Context: user.my-overrides.community.tags.terminal.term_talon.talon

Spoken	Backend
talon user update	`"find {user.talon_user()} -type d -name .git -print -execdir git pull --ff-only \\;\\n"` `"git -C {user.user_home()}/repositories/cursorless-talon pull\\n"`
watch talon log	`"tail -f {user.talon_home()}/talon.log\\n"`

Mindmap

`term_utils`

Context: user.my-overrides.community.tags.terminal.term_utils.talon

Spoken	Backend
apt install	`"apt install "`
apt update	`"apt update\\n"`
cat	`"cat "`
cd	`"cd "`
change mode	`"chmod "`
change owner	`"chown "`
clipboard	`"clipboard"`
copy	`"cp "`
copy dir	`"pwd \| clipboard\\n"`
curl	`"curl "`
diff	`"diff "`
dir	`"cd "`
dir <user.letters> tab	`"cd {letters}\t"`
dir <user.letters>	`"cd {letters}"`
dir <user.text> tab	`"cd {text}\t"`
dir <user.text>	`"cd {text}"`
echo	`"echo "`
echo <user.text>	`"echo {text}"`
exargs	`"xargs "`
exec	`"exec "`
grep	`"grep "`
head <number_small>	`"head -{number_small}"`
history	`"history "`
history grep	`"history \| grep "`
history tail	`"history \| tail\\n"`
history tail <number_small>	`"history \| tail -{number_small}\\n"`
jump	`"autojump "`
just	`"just "`
less	`"less "`
list	`"ls\\n"`
list all	`"ls -a\\n"`
list long	`"ls -lah\\n"`
list long pipe	`"ls -lah \| "`
make dir	`"mkdir "`
move	`"mv "`
poetry shell	`"poetry shell"`
print dir	`"pwd\\n"`
ssh	`"ssh "`
sudo	`"sudo "`
tail <number_small>	`"tail -{number_small}"`
talon user update	`"find {user.talon_user()} -type d -name .git -print -execdir git pull --ff-only \\;\\n"` `"git -C {user.user_home()}/repositories/cursorless-talon pull\\n"`
tar create	`"tar -czvf "`
tar extract	`"tar -xzvf "`
touch	`"touch "`
translate	`"tr "`
trash put	`"trash-put "`
tree files	`"tree\\n"`
tree folders	`"tree -d\\n"`
unique	`"uniq "`
vim	`"vim "`
watch talon log	`"tail -f {user.talon_home()}/talon.log\\n"`
yarn	`"yarn "`

Mindmap

`vikunja`

Context: user.my-overrides.community.websites.vikunja.talon

Spoken	Backend
assign <user.word>	`" @\"{user.word}\" "`
label <user.word>	`" *\"{user.word}\" "`
new subtask <user.text>	`key(shift-enter)` `sleep(200ms)` `insert(' ')` `insert(user.text)`
new task <user.text>	`key(shift-enter)` `sleep(200ms)` `insert(user.text)`
priority <number_small>	`" !{number_small} "`
project <user.word>	`" \+\"{user.word}\" "`

Mindmap

`youtube`

Context: user.my-overrides.community.websites.youtube.talon

Spoken	Backend
(play \| pause)	`key(k)`
toggle full screen	`key(f)`
toggle mini player mode	`key(i)`
toggle mute	`key(m)`
toggle theater mode	`key(t)`
decrease font size	`key(-)`
increase font size	`key(\+)`
last frame	`key(.)`
last video	`key(P)`
louder sound track	`key(up)`
next frame	`key(,)`
next video	`key(N)`
play back faster	`key(>)`
play back slower	`key(<)`
quieter sound track	`key(down)`
seek backward	`key(left)`
seek backward ten seconds	`key(j)`
seek beginning	`key(home)`
seek ending	`key(end)`
seek forward	`key(right)`
seek forward ten seconds	`key(l)`
sub titles	`key(c)`
text opacity	`key(o)`
window opacity	`key(w)`
youtube <user.number_key>	`key(user.number_key)`

Mindmap

`mint`

Context: user.my-overrides.distro-specific.mint.talon

Spoken	Backend
lock it up	`key(ctrl-alt-l)`
log me out	`key(ctrl-alt-delete)`
shutdown	`key(ctrl-alt-end)`
desk choose	`key(ctrl-alt-up)`
desk show	`key(ctrl-alt-up)`
snap full	`key(alt-f10)`
window choose	`key(ctrl-alt-down)`

Mindmap

`ubuntu`

Context: user.my-overrides.distro-specific.ubuntu.talon

Spoken	Backend
desk choose	`user.desktop_show()`
lock screen	`key(super-l)`
window choose	`key(super)`
window last	`key(alt:down)` `sleep(0.15)` `key(shift-tab)` `key(alt:up)`
window next	`key(alt-escape)`
window show	`key(super)`

Mindmap

`direct_clicking`

Context: user.rango.src.modes.direct_clicking.talon

Spoken	Backend
<user.rango_direct_clicking_target>	`user.rango_direct_click_element(rango_direct_clicking_target)`

Mindmap

`rango`

Context: user.rango.src.rango.talon

Spoken	Backend
(go tab \| slot) <user.rango_tab_target>	`user.rango_activate_tab(rango_tab_target)`
[tab] marker (toggle \| switch)	`user.rango_toggle_tab_markers()`
[tab] marker refresh	`user.rango_refresh_tab_markers()`
blank <user.rango_target>	`user.rango_open_in_new_tab(rango_target)`
bottom <user.rango_target>	`user.rango_snap_scroll(rango_target, "bottom")`
bottom <user.text>	`user.rango_snap_scroll_text(text, "bottom")`
button <user.text>	`user.rango_run_action_on_text_matched_element("clickElement", text, false)`
center <user.rango_target>	`user.rango_snap_scroll(rango_target, "center")`
center <user.text>	`user.rango_snap_scroll_text(text, "center")`
change <user.rango_target>	`user.rango_clear_input(rango_target)`
click <user.rango_target>	`user.rango_click_element(rango_target)`
copy [link] <user.rango_target>	`user.rango_copy_link(rango_target)`
copy content <user.rango_target>	`user.rango_copy_element_text(rango_target)`
copy mark <user.rango_target>	`user.rango_copy_markdown_link(rango_target)`
copy mark address	`user.rango_copy_current_tab_markdown_url()`
copy page {user.rango_page_location_property}	`user.rango_copy_location_property(rango_page_location_property)`
crown <user.rango_target>	`user.rango_snap_scroll(rango_target, "top")`
crown <user.text>	`user.rango_snap_scroll_text(text, "top")`
custom hints reset	`user.rango_reset_custom_selectors()`
custom hints save	`user.rango_confirm_selectors_customization()`
dismiss	`user.rango_unhover_all()`
down again	`user.rango_scroll("repeatLast", "down")`
downer	`user.rango_scroll("main", "down")`
downer <number_small>	`user.rango_scroll("main", "down", number_small)`
downer <user.rango_target>	`user.rango_scroll_at_element(rango_target, "down")`
downer all	`user.rango_scroll("main", "down", 9999)`
downer left	`user.rango_scroll("leftSidebar", "down")`
downer left all	`user.rango_scroll("leftSidebar", "down", 9999)`
downer right	`user.rango_scroll("rightSidebar", "down")`
downer right all	`user.rango_scroll("rightSidebar", "down", 9999)`
enter <user.text> to <user.rango_target>	`user.rango_insert_text_to_input(text, rango_target, true)`
exclude <user.rango_target>	`user.rango_exclude_extra_selectors(rango_target)`
exclude all	`user.rango_exclude_all_hints()`
flick <user.rango_target>	`user.rango_focus_and_activate_element(rango_target)`
focus <user.rango_target>	`user.rango_focus_element(rango_target)`
follow <user.text>	`user.rango_run_action_on_text_matched_element("clickElement", text, true)`
go input	`user.rango_focus_first_input()`
go last sound	`user.rango_focus_tab_last_sounded()`
go muted	`user.rango_focus_next_muted_tab()`
go playing	`user.rango_focus_next_audible_tab()`
go root	`user.rango_navigate_to_page_root()`
go sound	`user.rango_focus_next_tab_with_sound()`
hide <user.rango_target>	`user.rango_hide_hint(rango_target)`
hint bigger	`user.rango_increase_hint_size()`
hint extra	`user.rango_display_extra_hints()`
hint less	`user.rango_display_less_hints()`
hint more	`user.rango_display_excluded_hints()`
hint smaller	`user.rango_decrease_hint_size()`
hints (toggle \| switch)	`user.rango_toggle_hints()`
hints off [{user.rango_hints_toggle_levels}]	`user.rango_disable_hints(rango_hints_toggle_levels or "global")`
hints on [{user.rango_hints_toggle_levels}]	`user.rango_enable_hints(rango_hints_toggle_levels or "global")`
hints refresh	`user.rango_refresh_hints()`
hints reset {user.rango_hints_toggle_levels}	`user.rango_reset_toggle_level(rango_hints_toggle_levels)`
hover <user.rango_target>	`user.rango_hover_element(rango_target)`
include <user.rango_target>	`user.rango_include_extra_selectors(rango_target)`
insert <user.text> to <user.rango_target>	`user.rango_insert_text_to_input(text, rango_target)`
keyboard (toggle \| switch)	`user.rango_toggle_keyboard_clicking()`
labels	`user.rango_enable_hints("now")`
left again	`user.rango_scroll("repeatLast", "left")`
mark <user.rango_target> as <user.text>	`user.rango_save_reference(rango_target, text)`
mark clear <user.text>	`user.rango_remove_reference(text)`
mark show	`user.rango_show_references()`
mark this as <user.text>	`user.rango_save_reference_for_active_element(text)`
menu <user.rango_target>	`user.rango_mouse_click_element(rango_target, 1)`
mouse click <user.rango_target>	`user.rango_mouse_click_element(rango_target, 0)`
move to <user.rango_target>	`user.rango_mouse_move_to_element(rango_target)`
mute <user.rango_tab_target>	`user.rango_mute_tab(rango_tab_target)`
mute all	`user.rango_mute_all_tabs_with_sound()`
mute next	`user.rango_mute_next_tab_with_sound()`
mute this	`user.rango_mute_current_tab()`
page last	`user.rango_navigate_to_previous_page()`
page next	`user.rango_navigate_to_next_page()`
paste to <user.rango_target>	`user.rango_insert_text_to_input(clip.text(), rango_target)`
post <user.rango_target>	`user.rango_set_selection_after(rango_target)`
pre <user.rango_target>	`user.rango_set_selection_before(rango_target)`
rango direct	`user.rango_force_direct_clicking()`
rango explicit	`user.rango_force_explicit_clicking()`
rango open {user.rango_page}	`user.rango_open_page_in_new_tab(rango_page)`
rango settings	`user.rango_open_settings_page()`
rango what's new	`user.rango_open_whats_new_page()`
right again	`user.rango_scroll("repeatLast", "right")`
scroll left	`user.rango_scroll("main", "left")`
scroll left <user.rango_target>	`user.rango_scroll_at_element(rango_target, "left")`
scroll left all	`user.rango_scroll("main", "left", 9999)`
scroll right	`user.rango_scroll("main", "right")`
scroll right <user.rango_target>	`user.rango_scroll_at_element(rango_target, "right")`
scroll right all	`user.rango_scroll("main", "right", 9999)`
scroll save <user.text>	`user.rango_store_scroll_position(text)`
scroll to <user.text>	`user.rango_scroll_to_position(text)`
show <user.rango_target>	`user.rango_show_link(rango_target)`
some less	`user.rango_include_or_exclude_less_selectors()`
some more	`user.rango_include_or_exclude_more_selectors()`
stash <user.rango_target>	`user.rango_open_in_background_tab(rango_target)`
tab ahead	`user.rango_cycle_tabs_by_text(1)`
tab back	`user.rango_focus_previous_tab()`
tab behind	`user.rango_cycle_tabs_by_text(-1)`
tab clone	`user.rango_clone_current_tab()`
tab close <user.rango_tab_target>	`user.rango_close_tab(rango_tab_target)`
tab close final [<number_small>]	`user.rango_close_tabs_right_end(number_small or 1)`
tab close first [<number_small>]	`user.rango_close_tabs_left_end(number_small or 1)`
tab close left	`user.rango_close_tabs_to_left()`
tab close next [<number_small>]	`user.rango_close_next_tabs(number_small or 1)`
tab close other	`user.rango_close_other_tabs()`
tab close previous [<number_small>]	`user.rango_close_previous_tabs(number_small or 1)`
tab close right	`user.rango_close_tabs_to_right()`
tab hunt <user.text>	`user.rango_focus_tab_by_text(text)`
tab split	`user.rango_move_tab_to_new_window()`
tiny down	`user.rango_scroll("main", "down", 0.2)`
tiny down <user.rango_target>	`user.rango_scroll_at_element(rango_target, "down", 0.2)`
tiny left	`user.rango_scroll("main", "left", 0.2)`
tiny left <user.rango_target>	`user.rango_scroll_at_element(rango_target, "left", 0.1)`
tiny right	`user.rango_scroll("main", "right", 0.2)`
tiny right <user.rango_target>	`user.rango_scroll_at_element(rango_target, "right", 0.1)`
tiny up	`user.rango_scroll("main", "up", 0.2)`
tiny up <user.rango_target>	`user.rango_scroll_at_element(rango_target, "up", 0.2)`
toggle show	`user.rango_display_toggles_status()`
unmute <user.rango_tab_target>	`user.rango_unmute_tab(rango_tab_target)`
unmute all	`user.rango_unmute_all_muted_tabs()`
unmute next	`user.rango_unmute_next_muted_tab()`
unmute this	`user.rango_unmute_current_tab()`
up again	`user.rango_scroll("repeatLast", "up")`
upper	`user.rango_scroll("main", "up")`
upper <number_small>	`user.rango_scroll("main", "up", number_small)`
upper <user.rango_target>	`user.rango_scroll_at_element(rango_target, "up")`
upper all	`user.rango_scroll("main", "up", 9999)`
upper left	`user.rango_scroll("leftSidebar", "up")`
upper left all	`user.rango_scroll("leftSidebar", "up", 9999)`
upper right	`user.rango_scroll("rightSidebar", "up")`
upper right all	`user.rango_scroll("rightSidebar", "up", 9999)`
visit {user.website}	`user.rango_focus_or_create_tab_by_url(website)`

Mindmap

`talon_helpers`

Context: user.rango.src.talon_helpers.talon

Spoken	Backend
click rango mark <user.text>	`"user.rango_run_action_on_reference(\"clickElement\", \"{text}\")"`
click rango text <user.text>	`"user.rango_run_action_on_text_matched_element(\"clickElement\", \"{text}\")"`
focus rango mark <user.text>	`"user.rango_run_action_on_reference(\"focusElement\", \"{text}\")"`
focus rango text <user.text>	`"user.rango_run_action_on_text_matched_element(\"focusElement\", \"{text}\")"`
hover rango mark <user.text>	`"user.rango_run_action_on_reference(\"hoverElement\", \"{text}\")"`
hover rango text <user.text>	`"user.rango_run_action_on_text_matched_element(\"hoverElement\", \"{text}\")"`

Mindmap

`gpt-confirmation-gui`

Context: user.talon-ai-tools.gpt.gpt-confirmation-gui.talon

Spoken	Backend
{user.model} toggle window	`user.confirmation_gui_close()`
chain response	`user.confirmation_gui_paste()` `user.gpt_select_last()`
copy response	`user.confirmation_gui_copy()`
discard response	`user.confirmation_gui_close()`
pass response to context	`user.confirmation_gui_pass_context()`
paste response	`user.confirmation_gui_paste()`

Mindmap

`gpt-cursorless`

Context: user.talon-ai-tools.gpt.gpt-cursorless.talon

Spoken	Backend
{user.model} [{user.modelthread}] <user.modelsimpleprompt> <user.cursorless_target> [<user.cursorless_destination>]	`text = user.cursorless_get_text_list(cursorless_target)` `result = user.gpt_apply_prompt_for_cursorless(user.modelSimplePrompt, model, modelThread or "", text)` `default_destination = user.cursorless_create_destination(cursorless_target)` `user.cursorless_insert(cursorless_destination or default_destination, result)`
{user.model} [{user.modelthread}] apply [from] clip <user.cursorless_target>	`prompt = clip.text()` `text = user.cursorless_get_text_list(cursorless_target)` `result = user.gpt_apply_prompt_for_cursorless(prompt, model, modelThread or "", text)` `default_destination = user.cursorless_create_destination(cursorless_target)` `user.cursorless_insert(default_destination, result)`
{user.model} pass <user.cursorless_target> to context	`text = user.cursorless_get_text_list(cursorless_target)` `user.gpt_push_context(text)`
{user.model} pass <user.cursorless_target> to new context	`text = user.cursorless_get_text_list(cursorless_target)` `user.gpt_clear_context()` `user.gpt_push_context(text)`

Mindmap

`gpt-shell`

Context: user.talon-ai-tools.gpt.gpt-shell.talon

Spoken	Backend
{user.model} [{user.modelthread}] (sequel \| sql) <user.text>	`result = user.gpt_generate_sql(user.text, model, modelThread or "")` `user.confirmation_gui_append(result)`
{user.model} [{user.modelthread}] shell <user.text>	`result = user.gpt_generate_shell(user.text, model, modelThread or "")` `user.confirmation_gui_append(result)`

Mindmap

`gpt-with-context`

Context: user.talon-ai-tools.gpt.gpt-with-context.talon

Spoken	Backend
{user.model} clear context	`user.gpt_clear_context()`
{user.model} pass ({user.modelsource} \| {user.modeldestination} \| {user.modelsource} {user.modeldestination})	`user.gpt_pass(modelSource or "", modelDestination or "")`

Mindmap

`gpt`

Context: user.talon-ai-tools.gpt.gpt.talon

Spoken	Backend
{user.model} [{user.modelthread}] [nope] that was <user.text>	`result = user.gpt_reformat_last(text, model, modelThread or "")` `user.paste(result)`
{user.model} [{user.modelthread}] <user.modelprompt> [{user.modelsource}] [{user.modeldestination}]	`user.gpt_apply_prompt(modelPrompt, model, modelThread or "", modelSource or "", modelDestination or "")`
{user.model} [{user.modelthread}] apply [from] clip	`prompt = clip.text()` `text = edit.selected_text()` `result = user.gpt_apply_prompt(prompt, model, modelThread or "", text)` `user.paste(result)`
{user.model} help	`user.gpt_help()`
{user.model} start debug	`user.gpt_start_debug()`
{user.model} stop debug	`user.gpt_stop_debug()`
{user.model} take response	`user.gpt_select_last()`

Mindmap

`ai-images`

Context: user.talon-ai-tools.images.ai-images.talon

Spoken	Backend
image generate <user.text>	`user.image_generate(text)`

Mindmap

`codeium`

Context: user.talon-ai-tools.copilot.codeium.talon

Spoken	Backend
pilot (previous \| last)	`user.vscode("editor.action.inlineSuggest.showPrevious")`
pilot cancel	`user.vscode("editor.action.inlineSuggest.hide")`
pilot chat [<user.prose>]	`user.vscode("codeium.openChatView")` `sleep(2)` `user.paste(user.prose or "")`
pilot debug	`user.vscode("codeium.explainProblem")`
pilot editor	`user.vscode("codeium.openChatInPane")`
pilot explain	`user.vscode("codeium.explainCodeBlock")`
pilot make [<user.prose>]	`user.vscode("codeium.openCodeiumCommand")` `sleep(0.7)` `user.paste(user.prose or "")`
pilot next	`user.vscode("editor.action.inlineSuggest.showNext")`
pilot nope	`user.vscode("editor.action.inlineSuggest.undo")`
pilot refactor	`user.vscode("codeium.refactorCodeBlock")`
pilot search	`user.vscode("codeium.openSearchView")`
pilot submit	`key(ctrl-shift-enter)`
pilot toggle	`user.vscode("codeium.toggleEnabledForCurrentLanguage")`
pilot yes	`user.vscode("editor.action.inlineSuggest.commit")`

Mindmap

`continue`

Context: user.talon-ai-tools.copilot.continue.talon

Spoken	Backend
bar tin you	`user.vscode("continue.continueGUIView.focus")`
tin you (accept \| yes)	`user.vscode("continue.acceptDiff")`
tin you add <user.cursorless_target>	`user.cursorless_ide_command("continue.focusContinueInput", cursorless_target)`
tin you cancel	`key("escape")`
tin you comment <user.cursorless_target>	`user.cursorless_ide_command("continue.writeCommentsForCode", cursorless_target)`
tin you debug terminal	`user.vscode("continue.debugTerminal")`
tin you dock <user.cursorless_target>	`user.cursorless_ide_command("continue.writeDocstringForCode", cursorless_target)`
tin you edit <user.cursorless_target>	`user.cursorless_ide_command("continue.quickEdit", cursorless_target)`
tin you file select	`user.vscode("continue.selectFilesAsContext")`
tin you fix code <user.cursorless_target>	`user.cursorless_ide_command("continue.fixCode", cursorless_target)`
tin you fix grammar <user.cursorless_target>	`user.cursorless_ide_command("continue.fixGrammar", cursorless_target)`
tin you history	`user.vscode("continue.viewHistory")`
tin you new	`user.vscode("continue.newSession")`
tin you optimize <user.cursorless_target>	`user.cursorless_ide_command("continue.optimizeCode", cursorless_target)`
tin you reject	`user.vscode("continue.rejectDiff")`
tin you select files	`user.vscode("continue.selectFilesAsContext")`
tin you share	`user.vscode("continue.shareSession")`
tin you toggle fullscreen	`user.vscode("continue.toggleFullScreen")`

Mindmap

`copilot`

Context: user.talon-ai-tools.copilot.copilot.talon

Spoken	Backend
pilot {user.copilot_slash_command} <user.cursorless_target> [to <user.prose>]	`user.cursorless_command("setSelection", cursorless_target)` `user.copilot_inline_chat(copilot_slash_command or "", prose or "")`
pilot (previous \| last)	`user.vscode("editor.action.inlineSuggest.showPrevious")`
pilot block last	`user.vscode("workbench.action.chat.previousCodeBlock")`
pilot block next	`user.vscode("workbench.action.chat.nextCodeBlock")`
pilot bring <user.cursorless_ordinal_or_last>	`user.copilot_bring_code_block(cursorless_ordinal_or_last)`
pilot bring <user.cursorless_ordinal_or_last> {user.makeshift_destination} <user.cursorless_target>	`user.cursorless_command(makeshift_destination, cursorless_target)` `user.copilot_bring_code_block(cursorless_ordinal_or_last)`
pilot cancel	`user.vscode("editor.action.inlineSuggest.hide")`
pilot chat [<user.prose>]	`user.copilot_chat(prose or "")`
pilot copy <user.cursorless_ordinal_or_last>	`user.copilot_focus_code_block(cursorless_ordinal_or_last)` `edit.copy()`
pilot jest	`user.vscode("editor.action.inlineSuggest.trigger")`
pilot make [<user.prose>]	`user.copilot_inline_chat("", prose or "")`
pilot new file <user.cursorless_ordinal_or_last>	`user.copilot_focus_code_block(cursorless_ordinal_or_last)` `user.vscode("workbench.action.chat.insertIntoNewFile")`
pilot next	`user.vscode("editor.action.inlineSuggest.showNext")`
pilot nope	`user.vscode("editor.action.inlineSuggest.undo")`
pilot yes	`user.vscode("editor.action.inlineSuggest.commit")`
pilot yes word	`user.vscode("editor.action.inlineSuggest.acceptNextWord")`

Mindmap

`hud_content_focus`

Context: user.talon_hud.content.hud_content_focus.talon

Spoken	Backend
focus indicator hide	`user.hud_deactivate_focus_indicator()`
focus indicator show	`user.hud_activate_focus_indicator()`

Mindmap

`hud_content_toolkit`

Context: user.talon_hud.content.hud_content_toolkit.talon

Spoken	Backend
toolkit debugging	`user.hud_toolkit_debug_options()`
toolkit documentation	`user.hud_show_documentation()`
toolkit lists	`user.hud_toolkit_lists()`
toolkit microphones	`user.show_microphone_options()`
toolkit options	`user.hud_toolkit_options()`
toolkit scope	`user.hud_toolkit_scope()`
toolkit speech	`user.hud_toolkit_speech()`
toolkit walkthroughs	`user.hud_show_walkthroughs()`

Mindmap

`hud_content_walkthrough`

Context: user.talon_hud.content.hud_content_walkthrough.talon

Spoken	Backend
head up theme dark	`sleep(0.5)` `user.switch_hud_theme('dark')`
head up theme light	`sleep(1.5)` `user.switch_hud_theme('light')`
music and video playlist	`user.open_url("https://www.youtube.com/watch?v=lyVICt4vdB0&list=PLEelxuGt2Io5jGNnA44S9lRhclhz7po1U&index=1")`
(continue\|skip step)	`user.hud_skip_walkthrough_step()`
(previous [step]\|last step)	`user.hud_previous_walkthrough_step()`
skip everything	`user.hud_skip_walkthrough_all()`

Mindmap

`hud_choice_commands`

Context: user.talon_hud.hud_choice_commands.talon

Spoken	Backend
{user.talon_hud_widget_enabled_voice_commands}	`user.hud_activate_enabled_voice_command(talon_hud_widget_enabled_voice_commands)`
[option] {user.talon_hud_choices}	`user.hud_activate_choice(talon_hud_choices)`
option {user.talon_hud_numerical_choices}+ {user.talon_hud_choices}	`user.hud_activate_choices(talon_hud_numerical_choices_list)` `user.hud_activate_choice(talon_hud_choices)`
option {user.talon_hud_numerical_choices}+	`user.hud_activate_choices(talon_hud_numerical_choices_list)`

Mindmap

`hud_commands`

Context: user.talon_hud.hud_commands.talon

Spoken	Backend
{user.talon_hud_widget_names} (back\|previous)	`user.hud_decrease_widget_page(talon_hud_widget_names)`
{user.talon_hud_widget_names} (hide\|close)	`user.hud_disable_id(talon_hud_widget_names)`
{user.talon_hud_widget_names} (show\|open)	`user.hud_enable_id(talon_hud_widget_names)`
{user.talon_hud_widget_names} maximize	`user.hud_set_widget_preference(talon_hud_widget_names, "minimized", 0)`
{user.talon_hud_widget_names} minimize	`user.hud_set_widget_preference(talon_hud_widget_names, "minimized", 1)`
{user.talon_hud_widget_names} next	`user.hud_increase_widget_page(talon_hud_widget_names)`
{user.talon_hud_widget_names} options	`user.hud_widget_options(talon_hud_widget_names)`
(head up focus \| focus head up)	`user.hud_focus()`
head up (drop\|stop\|confirm)	`user.hud_set_setup_mode("*", "")`
head up (hide\|close) {user.talon_hud_widget_names}	`user.hud_disable_id(talon_hud_widget_names)`
head up (hide\|close)	`user.hud_disable()`
head up (show\|open) {user.talon_hud_widget_names}	`user.hud_enable_id(talon_hud_widget_names)`
head up (show\|open)	`user.hud_enable()`
head up [enable] auto focus	`user.hud_set_auto_focus(1)`
head up align {user.talon_hud_widget_names} bottom	`user.hud_set_widget_preference(talon_hud_widget_names, "expand_direction", "up")`
head up align {user.talon_hud_widget_names} center	`user.hud_set_widget_preference(talon_hud_widget_names, "alignment", "center")`
head up align {user.talon_hud_widget_names} left	`user.hud_set_widget_preference(talon_hud_widget_names, "alignment", "left")`
head up align {user.talon_hud_widget_names} right	`user.hud_set_widget_preference(talon_hud_widget_names, "alignment", "right")`
head up align {user.talon_hud_widget_names} top	`user.hud_set_widget_preference(talon_hud_widget_names, "expand_direction", "down")`
head up basic {user.talon_hud_widget_names}	`user.hud_set_widget_preference(talon_hud_widget_names, "show_animations", 0)`
head up blur	`user.hud_blur()`
head up cancel	`user.hud_set_setup_mode("*", "cancel")`
head up development start	`user.hud_watch_directories()` `user.hud_watch_walkthrough_files()` `user.hud_watch_documentation_files()`
head up development stop	`user.hud_unwatch_directories()` `user.hud_unwatch_walkthrough_files()` `user.hud_unwatch_documentation_files()`
head up disable auto focus	`user.hud_set_auto_focus(0)`
head up drag {user.talon_hud_widget_names}+	`user.hud_set_setup_mode_multi(talon_hud_widget_names_list, "position")`
head up expand {user.talon_hud_widget_names}	`user.hud_set_setup_mode(talon_hud_widget_names, "limit")`
head up fancy {user.talon_hud_widget_names}	`user.hud_set_widget_preference(talon_hud_widget_names, "show_animations", 1)`
head up hide {user.talon_hud_widget_names} on sleep	`user.hud_set_widget_preference(talon_hud_widget_names, "sleep_enabled", 0)`
head up resize {user.talon_hud_widget_names}	`user.hud_set_setup_mode(talon_hud_widget_names, "dimension")`
head up show {user.talon_hud_widget_names} on sleep	`user.hud_set_widget_preference(talon_hud_widget_names, "sleep_enabled", 1)`
head up text scale {user.talon_hud_widget_names}	`user.hud_set_setup_mode(talon_hud_widget_names, "font_size")`
head up theme {user.talon_hud_themes}	`user.hud_switch_theme(talon_hud_themes)`

Mindmap

`hud_widget_quick_choices`

Context: user.talon_hud.hud_widget_quick_choices.talon

Spoken	Backend
{user.talon_hud_quick_choices}	`user.hud_activate_choice(talon_hud_quick_choices)`

Talon Commands