Cómo empezar a usar AutoIt: guía completa paso a paso

Si acabas de aterrizar en AutoIt y no sabes por dónde empezar, estás en el sitio adecuado. AutoIt es un lenguaje gratuito y ligero para automatizar Windows, crear pequeñas aplicaciones con ventana y construir macros que hagan clics, escriban, muevan archivos o llenen formularios por ti. Aunque tiene sus años, sigue siendo una navaja suiza muy útil cuando lo que quieres es rapidez para automatizar tareas del entorno Windows sin complicarte la vida.

En esta guía reunimos, ordenamos y traducimos en un lenguaje claro lo esencial para arrancar: desde los conceptos básicos de la ayuda oficial hasta una ruta de prácticas guiadas con ejemplos y una sección completa sobre archivos y directorios. La idea es que en pocas horas seas capaz de instalarlo, entender lo nuclear del lenguaje y poner en marcha scripts reales que te ahorren tiempo.

¿Qué es AutoIt y qué puedes hacer con él?

AutoIt es un lenguaje de scripting centrado en Windows que permite crear scripts y aplicaciones GUI (con ventana) de forma sencilla. Permite automatizar prácticamente cualquier interacción con ventanas, teclado y ratón, así como manipular archivos, procesos y servicios. Las aplicaciones creadas con AutoIt se ven como ventanas nativas de Windows, del estilo de la Calculadora o el Bloc de notas.

Una de sus grandes virtudes es la facilidad: no es difícil de aprender si sigues una progresión lógica, y el propio paquete de ayuda trae ejemplos cortos para cada función, algo perfecto para aprender viendo y tocando. Es gratis, lo que te facilita experimentar sin barreras ni licencias.

Además de aplicaciones con interfaz, AutoIt brilla con las macros. Una macro es un script que realiza operaciones de forma automática: abre programas, espera a que aparezcan ventanas, hace clic donde toca, escribe texto, captura la pantalla cada cierto tiempo, etc. Es ideal para tareas repetitivas o de pruebas.

¿Te va a gustar aprenderlo? Probablemente sí si buscas resultados prácticos desde el primer día. AutoIt recompensa rápido: con pocas líneas haces cosas visibles y eso engancha. Si sigues esta guía paso a paso, tendrás una base sólida para continuar con proyectos más ambiciosos.

Instalación y herramientas que te facilitan la vida

Puedes instalar AutoIt de forma clásica o incluso usarlo en modo portable según prefieras. El combo recomendado para empezar es AutoIt + SciTE4AutoIt3, el editor orientado a este lenguaje que ofrece resaltado de sintaxis, ejecución con un clic, plantillas, snippets y acceso directo a la ayuda.

Para diseñar ventanas sin pelearte con coordenadas, tienes Koda (el GUI designer). Koda te permite arrastrar y soltar controles como botones, cajas de texto, listas o sliders y genera el esqueleto de código para que te centres en la lógica. Es perfecto para ejercicios como calcular áreas, proyectar componentes de un vector o hacer pequeños juegos.

En el terreno de la automatización, dos utilidades te acelerarán mucho: Au3Info y Au3Record. Au3Info te muestra títulos de ventanas, controles y coordenadas de pantalla para dirigir tus clics y tecleos con precisión, mientras que Au3Record puede grabar acciones de ratón y teclado como base de una macro.

Si quieres distribuir tus scripts, es muy sencillo crear ejecutables autónomos. AutoIt compila tus .au3 a .exe con dependencias integradas, de modo que puedes compartirlos con quien no tenga AutoIt instalado. Es una forma rápida de empaquetar utilidades internas o proyectos de aula como un “Pitágoras autoejecutable”.

Domina los fundamentos con la ayuda oficial

La ayuda de AutoIt es tu mejor aliada. Entra por “Tutorials” para un primer vistazo y deja para más adelante el tema de expresiones regulares. Cuando quieras cimentar bien, visita “Language Reference”, donde se explica cómo se manejan los tipos de datos, variables, macros, operadores, estructuras de control, funciones y comentarios.

Empieza por cómo se representa y guarda la información: Datatypes, Variables y Macros. Las macros del sistema (por ejemplo, @DesktopDir, @HomeDrive o @HomePath) te ahorran trabajo al referirte a carpetas y rutas del usuario actual.

Sigue con las operaciones básicas en Operators y, muy importante, con el control de flujo: if/else, select/case y los bucles while/for. Son el esqueleto de cualquier algoritmo que quieras construir.

Las funciones merecen capítulo propio. En “Functions” verás cómo encapsular lógica reutilizable y en “Comments” aprenderás a documentar lo que haces para que tú o quien te ayude entienda el código dentro de unos meses.

Para interfaces, explora “GUI Reference”. Ahí tienes cómo crear ventanas y añadir controles. Si prefieres empezar con un paso a paso, existe un tutorial básico “Mi primer GUI” en la comunidad hispana que resulta muy didáctico. A modo de referencia, también cuentas con el índice de palabras clave/órdenes, útil para consultas puntuales cuando ya sabes qué buscas.

Cómo aprender en comunidad sin morir en el intento

La comunidad de AutoIt es un buen lugar para resolver dudas cuando te atas. Para conseguir respuestas útiles y rápidas, sigue unas normas básicas: busca antes por si tu duda ya está contestada, aporta el trozo de código donde falla (mejor reducido al mínimo) y usa un título descriptivo que resuma el problema.

Evita escribir “en clave SMS”. Un texto claro y sin faltas facilita que otros entiendan tu pregunta, y eso se traduce en mejores respuestas. Recuerda: no pidas que te hagan el programa completo; demuestra que lo has intentado y precisarás ayuda concreta.

Otra pista: en la ayuda de cada función encontrarás un mini programa de ejemplo. Ejecútalo, modifícalo, rómpelo y vuelve a montarlo. Aprenderás muchísimo. Si te apetece profundizar aún más, circula por Internet un PDF muy extenso de AutoIt (varios cientos de páginas) que recopila conceptos y prácticas.

Ruta de prácticas recomendadas: del “hola mundo” a proyectos con GUI, automatización, Bluetooth e Internet

Para que avances con buen ritmo, aquí tienes una ruta práctica inspirada en un índice de ejercicios muy completo. Está organizada por bloques temáticos y cubre desde operaciones básicas hasta integraciones con Android. Puedes seguirla en orden o saltar al bloque que más te motive.

• Primeros pasos y ejercicios base: 1) instalación portable y un ejercicio matemático tipo Pitágoras con ejecutable; 2) lectura “léeme”, trucos y nociones de sintaxis esenciales; 3) conversor Celsius/Fahrenheit usando un while; 5) conversión km/h ⇄ mi/h con opciones; 6) conversión m/s ⇄ km/h con opciones y bucle; 8) acciones de sistema (apagar, hibernar), ejecutar apps, usar MsgBox y InputBox.
• Diseño de GUIs con Koda: 9) insertar controles y calcular el área de un rectángulo; 10) descomponer un vector en componentes horizontal y vertical; 11) juego “acierta el número” con aleatoriedad; 12) ruleta rusa (aleatorio); 13) tres en raya con imágenes; 15) selector con CheckBox y Radio; 17) listas desplegables: países y capitales; 19) calendario; 20) semáforo; 21) slider para tiro parabólico; 22) slider para mezclar colores RGB; 23) slider para sumar números e importar código Koda; 24) archivos: crear, borrar, modificar y guardar; 25) sustituir cadenas en archivos; 26) Select Case e If/ElseIf; 27) bucles For/Next y While/Wend; 28) fases de la luna; 29) texto a voz; 30) reconocimiento de voz; 31) menú y submenú; 33) temporizador con TimerInit/TimerDiff; 34) listar archivos y carpetas; 35) usar 7-Zip para extracción.
• Macros y automatización avanzada: 40) instalación en PC con SciTE4AutoIt y primeras macros con Au3Record; 42) construir una macro sobre el Bloc de notas y usar Au3Info; 44) mover el ratón automáticamente y sumar en la Calculadora; 46) captura de pantalla, HotKeySet y ToolTip; 47) detectar teclas pulsadas con _IsPressed y mostrar en consola.
• Funciones y gráficos: 50) envío automático de teclas con Send, teclas de control, hibernación y captura con atajos; 52) listar funciones definidas por el usuario; 53) llamadas a DLL; 54) dibujar cuadrados y círculos con GUICreateCtrlGraphic/GUICtrlSetGraphic; 55) más dibujo en pantalla; 56) ejemplo de HotKeySet, MouseClick, ToolTip y manejo de contraseñas; 57) buscar píxeles por color con PixelSearch e ImageSearch; 58) seguir el ratón y leer coordenadas/colores con PixelGetColor.
• Bluetooth y Arduino: 60) bases de Bluetooth; 62) enviar datos desde el PC al Arduino por Bluetooth; 64) enviar datos del Arduino al PC; 66) simplificación del flujo Arduino → PC; 67) botones y LEDs; 68) sensor DHT11 con gráfico; 68B) consulta de humedad y temperatura con DHT11; 69) intercambio de datos con Android mediante App Inventor; 69B) intercambio Android ↔ ordenador por Bluetooth; 69C) chat Android ↔ ordenador por Bluetooth con App Inventor; 69D) enviar una imagen desde Android al ordenador por Bluetooth.
• Internet y servicios: 70) crear, subir, bajar y modificar un archivo de texto en un servidor; 71) ejercicio reservado para ampliación; 72) seleccionar un archivo local y subirlo; 73) descargar un archivo de Internet y mostrarlo si es imagen; 74) enviar correo; 75) CRUD en MySQL (subir, bajar, borrar, ver datos); 78) registro y autenticación con MySQL y correo; 79) enviar datos a Firebase y leerlos, también desde una web.
• Scripts interesantes de sistema: 100) hibernar y reanudar automáticamente; 102) apagar/encender monitor; 103) deshabilitar botones del Bloc de notas; 105) gestionar la bandeja del sistema (tray); 108) ocultar/mostrar la barra de tareas y ventanas; 110) capturar pantalla y enviar por FTP; 114) keylogger (con todas las precauciones legales); 116) bloquear ratón y teclado; 117) otro bloqueo de equipo; 118) crear archivos en la carpeta Inicio de Windows; 119) chat por WiFi; 119B) apagar PC por WiFi, lanzar el Bloc de notas y subir archivos al PC con App Inventor; 120) ejecutar comandos ADB en Android por USB.
• Scripts curiosos: 200) recopilación de ejemplos vistos por la red para inspirarte y aprender técnicas.

Si completas este recorrido, tocarás buena parte del ecosistema de AutoIt: GUI, automatización de interfaz, archivos, red, bases de datos y hardware ligero. La clave es practicar, modificar y volver a ejecutar hasta que las piezas encajen.

Trabajar con archivos y directorios en AutoIt: guía esencial con ejemplos

Uno de los ámbitos más prácticos en el día a día es la gestión de archivos y carpetas. A continuación tienes una colección de ejemplos graduales para crear, mover, leer, escribir y borrar, junto con funciones de selección de archivos desde cuadros de diálogo.

1) Crear directorios

Para crear carpetas, puedes utilizar rutas absolutas o variables macro del sistema como @DesktopDir. Estas macros te dan rutas del usuario sin hardcodear nombres. Un ejemplo:

; Crea una carpeta en C y otra en el Escritorio del usuario
DirCreate("C:/Carpeta de AutoIt/")
DirCreate(@DesktopDir & "/La carpeta de AutoIt/")

Si necesitas conocer la carpeta del perfil de usuario, @HomeDrive y @HomePath son útiles. Concatenas con & para unir cadenas y puedes mostrar el resultado con MsgBox si quieres depurar.

2) Borrar y mover directorios

Para eliminar un directorio con todo su contenido, usa el segundo parámetro en 1; si lo pones a 0, solo se borrará si está vacío. Puedes mover un árbol completo con DirMove:

; Borrar con contenido
DirRemove("C:/Carpeta de AutoIt/", 1)
DirRemove(@DesktopDir & "/La carpeta de AutoIt/", 1)

; Mover un directorio completo
DirMove("C:/Origen/", "C:/Destino/Aqui/", 1)

3) Crear un archivo vacío (y modos de apertura)

Al abrir un archivo con FileOpen defines el modo: 0 lectura, 1 escritura y añade al final, 2 escritura reemplazando contenido. Los modos 1 y 2 crean el archivo si no existe:

$carpeta = "C:/Carpeta de AutoIt/"
DirCreate($carpeta)
$archivo = FileOpen($carpeta & "prueba.txt", 1) ; escritura y añadir
FileClose($archivo)

Cuida las rutas; en Windows es habitual usar \ pero con / también funciona en muchos contextos. La limpieza al cerrar con FileClose evita bloqueos del archivo.

4) Escribir texto en un archivo

Puedes escribir líneas con FileWrite o FileWriteLine. @CRLF inserta salto de línea. Si abres con modo 1, las nuevas líneas se acumulan al final:

$carpeta = "C:/Carpeta de AutoIt/"
DirCreate($carpeta)
$archivo = FileOpen($carpeta & "prueba.txt", 1)
FileWrite($archivo, "Esta es la línea 1" & @CRLF)
FileWrite($archivo, "Esta es la línea 2" & @CRLF)
FileWrite($archivo, "Esta es la línea 3" & @CRLF)
FileWriteLine($archivo, "Otra línea 4")
FileWriteLine($archivo, "Otra línea 5")
FileWriteLine($archivo, "Otra línea 6")
FileClose($archivo)

Si necesitas reemplazar el contenido previo en cada ejecución, abre con modo 2. Así evitas que crezca el archivo innecesariamente.

5) Leer parte de un archivo

Para lectura parcial, abre en modo 0 y especifica cuántos caracteres quieres. FileRead admite un segundo parámetro con la longitud a leer:

$carpeta = "C:/Carpeta de AutoIt/"
$archivo = FileOpen($carpeta & "prueba.txt", 0)
$texto = FileRead($archivo, 12) ; lee 12 caracteres
MsgBox(0, "Lectura", $texto)
FileClose($archivo)

6) Leer un archivo completo: tres técnicas

AutoIt permite leer el archivo entero carácter a carácter, línea a línea o de una vez. En los dos primeros casos @error = -1 indica fin de archivo.

A) Carácter a carácter con FileRead dentro de un bucle:

$carpeta = "C:/Carpeta de AutoIt/"
$archivo = FileOpen($carpeta & "prueba.txt", 0)
$completo = ""
While 1
    $letra = FileRead($archivo, 1)
    $completo &= $letra
    If @error = -1 Then ExitLoop
WEnd
MsgBox(0, "Archivo completo (FileRead)", $completo)
FileClose($archivo)

B) Línea a línea con FileReadLine y agregando @CRLF para reconstruir el texto. Es cómodo para procesar registros por línea:

$carpeta = "C:/Carpeta de AutoIt/"
$archivo = FileOpen($carpeta & "prueba.txt", 0)
$completo = ""
While 1
    $linea = FileReadLine($archivo)
    $completo &= $linea & @CRLF
    If @error = -1 Then ExitLoop
WEnd
MsgBox(0, "Archivo completo (FileReadLine)", $completo)
FileClose($archivo)

C) Todo de una vez con FileRead sin bucle. La forma más directa cuando solo necesitas el contenido entero:

$carpeta = "C:/Carpeta de AutoIt/"
$archivo = FileOpen($carpeta & "prueba.txt", 0)
$completo = FileRead($archivo)
MsgBox(0, "Archivo completo", $completo)
FileClose($archivo)

7) Borrar archivos (y usar la Papelera)

Para eliminar un archivo directamente, FileDelete. Si prefieres enviarlo a la Papelera, usa FileRecycle, y para vaciarla, FileRecycleEmpty. Es recomendable reciclar en pruebas para evitar pérdidas accidentales:

$carpeta = "C:/Carpeta de AutoIt/"
FileDelete($carpeta & "prueba.txt")
; A la Papelera
autoit
FileRecycle($carpeta & "prueba.txt")
FileRecycleEmpty()

8) Comprobar si un archivo existe o se puede abrir

Una forma rápida de comprobar existencia/permisos es intentar abrir y validar el handle. Si FileOpen devuelve -1, no se pudo abrir o no existe:

$carpeta = "C:/Carpeta de AutoIt/"
$h = FileOpen($carpeta & "prueba.txt", 1)
If $h = -1 Then
    MsgBox(0, "Error", "El archivo no existe o no se pudo abrir.")
    Exit
EndIf
FileClose($h)

9) Copiar y mover archivos

Para copiar, especifica origen y destino. Puedes construir rutas de usuario con @DesktopDir para copiar al Escritorio. Para mover, emplea FileMove:

$carpeta = "C:/Carpeta de AutoIt/"
FileCopy($carpeta & "prueba.txt", @DesktopDir & "/La carpeta de AutoIt/prueba.txt")
; Mover genérico
; FileMove("origen", "destino")

10) Seleccionar archivos y carpetas con cuadros de diálogo

AutoIt trae funciones para abrir diálogos de selección estándar: FileOpenDialog, FileSaveDialog y FileSelectFolder. Son muy útiles para herramientas interactivas:

$msg = "Pulsa Ctrl o Shift para seleccionar más de uno"
$sel = FileOpenDialog($msg, "C:/Windows/", "Imágenes (*.jpg;*.bmp)", 1 + 4)
If @error Then
    MsgBox(4096, "", "No hay archivos seleccionados")
Else
    $sel = StringReplace($sel, "|", @CRLF)
    MsgBox(4096, "", "Seleccionado:" & @CRLF & $sel)
EndIf

$doc = "::{450D8FBA-AD25-11D0-98A8-0800361B1103}"
$save = FileSaveDialog("Elige un nombre", $doc, "Scripts (*.aut;*.au3)", 3)
If @error Then
    MsgBox(4096, "", "Guardado cancelado")
Else
    MsgBox(4096, "", "Guardado en: " & $save)
EndIf

$carp = FileSelectFolder("Selecciona una carpeta", "", 0)

11) Usar comodines

Los comodines te permiten operar sobre múltiples archivos a la vez. El patrón *.* recicla todos los archivos de una carpeta concreta:

$carpeta = "C:/Carpeta de AutoIt/"
FileRecycle($carpeta & "*.*")

Con esta colección ya puedes cubrir la mayoría de tareas de gestión de archivos. Añade validaciones, logs y cuadros de diálogo para convertirlo en una utilidad que puedas usar a diario.

Consejos finales para seguir avanzando

Planifica tu aprendizaje combinando lectura y práctica: revisa la ayuda, clona ejemplos, modifica parámetros y prueba en distintos entornos. Si te interesan interfaces, céntrate en Koda y la GUI Reference; si te tira la automatización, practica con Au3Info y HotKeySet.

Cuando el cuerpo te pida más, explora bloques como Bluetooth + Arduino, bases de datos MySQL o Firebase y los scripts curiosos. Todo suma para convertirte en alguien resolutivo con AutoIt dentro de tu equipo o para tus proyectos personales.

Y por si necesitas algo de chispa para no perder la motivación, recuperamos una frase atribuida a Mafalda (Quino): “¿Y no será que en este mundo hay cada vez más gente y menos personas?”. La comunidad se construye ayudando y compartiendo; cuando aprendas algo, vuelve y deja tu aportación para el siguiente que llega.

Esta guía reúne los puntos imprescindibles para arrancar en AutoIt, enlaza fundamentos con práctica guiada y aporta ejemplos listos para ejecutar. Con AutoIt ganarás velocidad resolviendo tareas en Windows, ya sea mediante macros, pequeñas aplicaciones con GUI o utilidades que manejen archivos y servicios; con constancia y curiosidad, irás de lo sencillo a lo potente sin darte cuenta.