Configurar accesos rápidos con AutoHotkey: guía avanzada y ejemplos

MundoWin » General » Configurar accesos rápidos con AutoHotkey: guía avanzada y ejemplos

Si alguna vez has sentido que los atajos nativos se te quedan cortos, te va a encantar lo que puedes hacer con AutoHotkey en Windows. Con AHK no solo creas accesos rápidos a tu medida, también encadenas acciones, transformas texto al vuelo y controlas ventanas o apps sin despegar las manos del teclado.

Más allá de los clásicos Ctrl+Q o Ctrl+W, hay una idea que te abre un mundo: la «tecla líder». Conviertes una combinación en un “modo” temporal y la siguiente tecla decide qué script corre; incluso puedes detectar doble o triple toque y mostrar una pista visual. Esto multiplica las combinaciones sin mover la mano izquierda ni un milímetro.

¿Qué es AutoHotkey y por qué merece la pena?

AutoHotkey (AHK) es gratuito y de código abierto, pensado para Windows, y actúa como un “escuchador” de combinaciones que dispara scripts. Escribes tus reglas en archivos .ahk con una sintaxis sencilla, lo ejecutas y listo: el sistema queda atento a tus atajos personalizados.

Sus scripts pueden convertirse en programas independientes si necesitas llevarlos a otros equipos sin instalar nada. Compilas a .exe con un clic derecho y ocupan poquísima memoria, del orden de unos pocos MB por instancia, perfectos para tenerlos siempre activos.

Además de la parte de hotkeys, AHK puede enviar teclas, escribir texto, manipular el portapapeles, formatear fechas y mucho más. Con Send, SendInput o SendEvent ajustas velocidad y “sabor” del envío; para la mayoría de flujos, SendMode Input + SetKeyDelay -1,-1 da una sensación ultrarrápida y estable.

De atajos sueltos a una “tecla líder” con combinaciones a mansalva

El problema habitual es quedarte sin combinaciones cómodas con la mano izquierda. La solución es pensar al revés: usa, por ejemplo, Ctrl+Q como “líder”; al pulsarlo, la siguiente tecla que toques (Q, W, E, R…) lanza un script distinto y, luego, se desarma el modo. Ya con eso multiplicas posibilidades.

¿No te basta? Entra el doble toque. Ctrl+Q y luego dos toques a Q dispara otra variante, mientras que Ctrl+Q y dos toques a W dispara una diferente. Si quieres rizar el rizo, puedes añadir triple toque o más, aunque en la práctica acabarás con más combinaciones de las que puedes memorizar.

Como detalle ergonómico, mucha gente muestra una marca visual mínima: una mini GUI naranja en la esquina superior derecha cuando activas el líder. Es un cuadradito que desaparece tras la siguiente tecla y te confirma que el modo está “armado”.

Ejemplos de organización: líderes por temática

Un patrón que funciona de cine es agrupar acciones por líderes temáticos. Ctrl+Q para tareas de trabajo, Ctrl+W para abrir aplicaciones y Ctrl+R para ocio o juegos. Dentro de cada líder, la segunda tecla decide el script y el doble toque abre una variante.

Por ejemplo, imagina que usas scripts para un juego musical: Ctrl+R y luego P podría cargar un “piano” con una canción concreta, mientras que el doble toque a P carga otra canción diferente. Cambias de preset sin menús, todo teclado puro y duro.

Con esta mentalidad, no hace falta ponerse filosófico con el infinito. Físicamente no es “infinito” el teclado, pero a efectos prácticos tendrás combinaciones para aburrir: todas las letras, con o sin doble toque, y si quieres triple. Verás que el cuello de botella será la memoria, no la técnica.

Implementación base de líder con doble toque y GUI indicadora

Empecemos por un esqueleto en AutoHotkey v1, claro y ampliable. Este líder en Ctrl+Q espera una tecla y, si la repites rápido, entiende que es doble toque. Mientras está armado, muestra una GUI naranja mínima:

#NoEnv
SendMode Input
SetWorkingDir %A_ScriptDir%
SetKeyDelay, -1, -1
#InstallKeybdHook

; --- Líder Ctrl+Q con GUI y doble toque ---
$^q::
 if (leaderBusy)
  return
 leaderBusy := true

 ; Indicador visual arriba a la derecha
 SysGet, mon, MonitorWorkArea, 1
 Gui, +AlwaysOnTop -Caption +ToolWindow
 Gui, Color, FF7F00
 Gui, Show, % "x" monRight-28 " y" monTop+10 " w18 h18", Leader

 ; Espera una tecla (800 ms)
 Input, LKey, L1 T0.8 V
 Gui, Destroy

 if (ErrorLevel = "Timeout" || LKey = "") {
  leaderBusy := false
  return
 }

 ; Intento de doble toque
 second := ""
 KeyWait, %LKey%, T0.3
 if (!ErrorLevel) {
  Input, second, L1 T0.3 V
 }

 ; Enrutar a la etiqueta según simple/doble
 if (second = LKey)
  Gosub, Leader_Double_%LKey%
 else
  Gosub, Leader_Single_%LKey%

 leaderBusy := false
return

; ---- Ejemplos (sustituye por tus scripts) ----
Leader_Single_q:
 MsgBox, 64, Script 1, Ejecutado: Ctrl+Q y luego Q
return

Leader_Single_w:
 MsgBox, 64, Script 2, Ejecutado: Ctrl+Q y luego W
return

Leader_Double_q:
 MsgBox, 64, Script 3, Doble toque en Q tras Ctrl+Q
return

Leader_Double_w:
 MsgBox, 64, Script 4, Doble toque en W tras Ctrl+Q
return

Con esto ya tienes lo importante: tecla líder, indicador visual, captura de la siguiente pulsación y detección de doble toque. A partir de ahí, rellenas las etiquetas Leader_Single_x y Leader_Double_x con lo que quieras lanzar.

Cómo mantener “spameable” Ctrl sin soltarlo (caso Ctrl+G → Ctrl+T y luego Alt+G)

Es típico querer remapear Ctrl+G a la secuencia Ctrl+T y después Alt+G, pero manteniendo Ctrl físicamente pulsado para repetir sin perder ritmo. Si sueltas el modificador a mitad, te cargan el flujo.

La clave aquí es usar {Blind}: este modo respeta el estado de los modificadores físicos (tu Ctrl real). Envías la “t” con el Ctrl físico aún abajo; luego mandas Alt+g, y Ctrl sigue pulsado porque tú nunca lo soltaste. Ejemplo limpio y rápido:

SendMode, Input
SetKeyDelay, -1, -1

$^g::
 ; Primero Ctrl+t respetando el Ctrl físico
 SendInput, {Blind}{t}
 ; Después Alt+g explícito
 SendInput, !g
return

Con ese patrón no hace falta re-“bajar” Ctrl con {CtrlDown} al final. Mientras no envíes {CtrlUp}, el modificador se mantiene tal cual porque lo sigues manteniendo con el dedo.

Si tu aplicación es muy quisquillosa y quieres eventos explícitos, también puedes hacerlo, pero cuidando no dejar teclas “pegadas”. Añade una salida de seguridad al soltar Ctrl:

$^g::
 ; Variante con eventos explícitos
 SendEvent, {Ctrl Down}{t}{Alt Down}g{Alt Up}
return

; Asegúrate de liberar Ctrl sintético cuando sueltes el físico
*~Ctrl Up::
 SendEvent, {Ctrl Up}
return

En la práctica, la combinación SendInput + {Blind} es más estable y veloz; empieza por ahí antes de complicarte con Down/Up manuales.

Sintaxis rápida de AHK que te conviene memorizar

Cuando declares atajos y envíes teclas verás estos símbolos por todas partes. Con tenerlos en la cabeza ganarás velocidad al escribir:

• ^ = Ctrl
• + = Shift
• ! = Alt
• :: = define un hotkey
• := = asigna variables en modo expresión

Tu primer script: “Hola mundo” para validar que todo escucha

Descarga e instala AutoHotkey, crea un fichero .ahk (por ejemplo, hola_mundo.ahk), edítalo y pega esto. Sirve para comprobar que AHK está activo y que tu combinación no choca con otra:

^+!u:: ; Ctrl+Shift+Alt+U
 MsgBox, 0, ¡Hola!, Hola desde AutoHotkey :)
return

Al pulsar Ctrl+Shift+Alt+U deberías ver el cuadro. Evita robar atajos del sistema o de tus apps (como Ctrl+C) para no pelearte con hábitos o comportamientos nativos.

Remapeos útiles: Administrador de tareas y textos rápidos

Abrir el Administrador de tareas desde Ctrl+Q es un clásico. Solo envías el atajo universal Ctrl+Shift+Esc y listo:

^q::
 SendInput, ^+{Esc}
return

Para escribir tu correo, firma o cualquier texto fijo, usa SendInput: es rapidísimo y no toca el portapapeles:

^!m:: ; Ctrl+Alt+M
 SendInput, micorreo@ejemplo.com
return

Si prefieres dejar el contenido preparado para pegar, asigna al portapapeles: queda listo para un Ctrl+V donde quieras:

^!m::
 Clipboard := "micorreo@ejemplo.com"
return

Fechas automáticas: escribe el mes actual o el anterior sin liarte

Si cada mes tienes que tipear “septiembre”, “octubre” y similares, que lo haga AHK por ti. Este hotkey te escribe el mes actual en español:

; Mes actual (formato completo)
^+!F4::
 time := A_NowUTC
 ; L0x0C0A (es-ES) o L0x080A (es-MX). Ajusta si lo necesitas.
 FormatTime, mes, %time%, L0x0C0A, MMMM
 SendInput, %mes%
return

Y este te saca el mes anterior restando un día al día 1 del mes en curso. Fiable y sin cálculos raros:

; Mes anterior
^+!F5::
 date := (A_YYYY . A_MM . "01")
 date += -1, days
 FormatTime, mesAnterior, %date%, L0x0C0A, MMMM
 SendInput, %mesAnterior%
return

Buscar y reemplazar el mes pasado por el actual en una celda

En Excel o Google Sheets es muy útil copiar un texto del mes pasado y actualizarlo al vuelo. Este atajo copia, transforma y pega sustituyendo el nombre del mes:

^+!F6::
 ; Mes actual y anterior
 time := A_NowUTC
 FormatTime, mesActual, %time%, L0x0C0A, MMMM
 date := (A_YYYY . A_MM . "01")
 date += -1, days
 FormatTime, mesAnterior, %date%, L0x0C0A, MMMM

 ; Copiar y transformar
 SendInput, ^c
 ClipWait, 0.5
 texto := Clipboard
 texto := StrReplace(texto, mesAnterior, mesActual)
 Clipboard := texto
 SendInput, ^v
return

Si lo integras en un líder de “edición”, puedes colgar más utilidades: normalizar mayúsculas, limpiar espacios, corregir tildes… y tener tu caja de herramientas textual a un combo de distancia.

Arrancar scripts con Windows y compilar a EXE

Para que tus hotkeys estén disponibles al iniciar sesión, crea un acceso directo del .ahk en la carpeta de Inicio. Pulsa Win+R, escribe shell:startup y pega ahí el acceso directo. Desde ese momento, cada reinicio cargará tus scripts automáticamente.

Si necesitas llevar el script a otra máquina sin instalar AHK, botón derecho sobre el .ahk y «Compile Script». Obtendrás un .exe autónomo que puedes lanzar donde quieras (útil en equipos bloqueados o gestionados).

Consejos pro: velocidad, estabilidad y contexto

Dale a tu script un “tacto” agradable con dos líneas al inicio: SendMode Input y SetKeyDelay -1,-1. El envío será inmediato y no tendrás retardos molestos entre teclas simuladas.

Cuando un atajo solo deba actuar en una app concreta, usa #IfWinActive para acotarlo. Evitarás interferencias y atajos “robados” fuera de contexto. También recuerda el prefijo $ en hotkeys para prevenir recursión si el propio envío contiene teclas del atajo.

Con modificadores, {Blind} es tu amigo: respeta siempre el estado físico y te garantiza combos “spameables”. Si tienes que usar Down/Up manuales, añade manejadores de liberación para no dejar teclas “atascadas” si el flujo se interrumpe.

Plantilla de líder para abrir apps y proyectos (Ctrl+W)

A modo de ejemplo, aquí tienes un líder centrado en lanzar aplicaciones con variante por doble toque (por ejemplo, perfiles o proyectos). Adáptalo con tus rutas y parámetros:

$^w::
 if (leaderBusy)
  return
 leaderBusy := true

 ; Indicador visual
 SysGet, mon, MonitorWorkArea, 1
 Gui, +AlwaysOnTop -Caption +ToolWindow
 Gui, Color, FF7F00
 Gui, Show, % "x" monRight-28 " y" monTop+10 " w18 h18", Leader

 Input, key, L1 T0.8 V
 Gui, Destroy

 if (ErrorLevel = "Timeout" || key = "") {
  leaderBusy := false
  return
 }

 second := ""
 KeyWait, %key%, T0.3
 if (!ErrorLevel)
  Input, second, L1 T0.3 V

 if (second = key)
  Gosub, Apps_Double_%key%
 else
  Gosub, Apps_Single_%key%

 leaderBusy := false
return

; --- Apps por tecla ---
Apps_Single_c: ; Ctrl+W luego C
 Run, chrome.exe
return

Apps_Double_c: ; Doble toque en C
 Run, chrome.exe --profile-directory=Default
return

Apps_Single_v:
 Run, code.exe
return

Apps_Double_v:
 Run, code.exe "C:\\Proyectos\\Proyecto1"
return

Con varios líderes temáticos tendrás un sistema flexible: uno para trabajo, otro para apps, otro para ocio. En nada estarás lanzando todo lo habitual con dos o tres teclas sin mirar la pantalla.

Buenas prácticas para mantener el orden

Pon nombres legibles a etiquetas y variables (Leader_Single_x, Apps_Double_x, etc.). Cuando vuelvas en dos meses lo agradecerás, sobre todo si has ido sumando acciones nuevas.

No pises combinaciones críticas del sistema (copiar, pegar, deshacer…). Es mejor construir combos propios “neutros” que reeducar tu memoria muscular. También puedes condicionar atajos por ventana con #IfWinActive para despejar conflictos.

Si el archivo crece, separa por módulos y usa #Include. Mantener y depurar será mucho más cómodo. Y, como regla general, prueba primero SendInput y KeyDelay antes de bajar a eventos Down/Up manuales: ganarás fiabilidad.

Para terminar, si te apetece experimentar con flujos creativos (por ejemplo, cargar scripts de juegos con presets distintos, como un “piano” con canciones concretas), el esquema de líderes y doble toque es perfecto. Te permite mapear combinaciones memorables y veloces, y hasta acompañarlas con la mini GUI naranja para ir sobre seguro.

Si pones en práctica este enfoque, tendrás un sistema de atajos que se siente natural, rápido y escalable: una tecla para “armar”, otra para decidir y variantes con doble toque. Entre los remapeos “spameables”, los trucos de portapapeles, los insertos de fechas y los lanzadores por líder, verás que casi todo tu día a día cabe en dos o tres pulsaciones bien pensadas.