Guía práctica para crear instaladores personalizados con Inno Setup

Crear instaladores propios en Windows no es solo cosa de grandes equipos: con la herramienta adecuada, puedes empaquetar tu aplicación y ofrecer una experiencia de instalación pulida en minutos. Aquí te explico, con detalle, cómo aprovechar Inno Setup para construir instaladores personalizados, contemplando requisitos, arquitectura de 64 bits, publicación de proyectos .NET y comprobaciones de dependencias.

En las siguientes líneas encontrarás una guía completa y práctica que abarca desde la preparación del proyecto hasta la compilación y pruebas del instalador. Además, incorporo consejos clave para evitar errores típicos (como el GUID duplicado o olvidar incluir todos los archivos publicados), y te muestro cómo automatizar la instalación de un servicio de Windows si tu app lo necesita.

Qué es Inno Setup

Inno Setup es un creador de instaladores para Windows con licencia freeware, muy veterano y estable, que combina un asistente gráfico con un script central donde defines el comportamiento del instalador (parámetros, tareas, comprobaciones, etc.). A través de ese script puedes controlar desde la ubicación de instalación hasta atajos en el Escritorio o el Menú Inicio, e incluso incluir la instalación de fuentes o recursos adicionales. También existen soluciones complementarias como Ninite para despliegues automatizados de software.

En cuanto a compatibilidad, cubre un rango muy amplio de sistemas: Windows 10, 8, 7, Vista, Server 2003, XP (incluidas ediciones x64), 2000, NT 4.0 y 9x. Además, admite la instalación de aplicaciones de 64 bits y la creación de instaladores específicos para esa arquitectura, algo especialmente relevante si buscas rendimiento y alinearte con las plataformas actuales.

Requisitos previos

Antes de ponernos manos a la obra, asegúrate de contar con estos elementos listos. Cada uno cumple una función concreta y te ahorrará tiempo en pruebas y correcciones, así que revísalos con calma:

• Inno Setup (última versión estable): Instálala o actualízala si ya la tienes. Mantenerte al día es crucial para que ciertos scripts y extensiones funcionen sin problemas.
• Inno Setup Dependency Installer: Descarga el código desde su repositorio (opción Download source) y descomprime. De ahí necesitaremos dos piezas: el archivo CodeDependencies.iss y el ejecutable netcorecheck_x64.exe, que nos ayudarán con la comprobación/instalación de .NET.
• Proyecto .NET 6: Puedes usar el tuyo o crear uno de ejemplo; lo importante es publicarlo correctamente para empaquetar los binarios en el instalador.
• Máquina virtual para pruebas (recomendado): No es obligatoria, pero sí muy aconsejable para evitar efectos indeseados en tu equipo principal mientras iteras el instalador.

Forzar la arquitectura a 64 bits en tu proyecto

Hoy casi todo el parque de ordenadores trabaja en 64 bits, de modo que compilar tu aplicación en x64 suele traer un plus de rendimiento y compatibilidad. En Visual Studio 2022, puedes forzar la arquitectura de forma sencilla y dejar tu app lista para un instalador orientado a 64 bits.

En la barra superior de Visual Studio, al lado del selector de configuración (Debug/Release), haz clic en el desplegable de plataforma (suele poner Any CPU) y entra en el Administrador de configuración. Desde ahí, crea una nueva plataforma eligiendo x64, copia la configuración desde Any CPU y marca la casilla para generar también la plataforma en los proyectos de la solución.

Tras cerrar los diálogos, compilarás ya en x64 al seleccionar esa plataforma. Este cambio es especialmente útil cuando vayas a construir el instalador, pues Inno Setup permite indicar que la instalación se haga en modo 64 bits, coherente con tu binario.

Publicar el proyecto

Para empaquetar tu aplicación, lo idóneo es publicar a carpeta con el perfil correcto. Así te aseguras de que el instalador copiará exactamente los archivos necesarios y no arrastrará recursos de desarrollo. El objetivo es dejar listo un directorio con los binarios que Inno Setup copiará a {app}.

En Visual Studio 2022, haz clic derecho sobre tu proyecto y selecciona Publicar. Elige la opción Carpeta como destino. En la pantalla de configuración, abre Mostrar todas las configuraciones y define el perfil como Release | x64. Puedes ajustar la ruta de publicación si lo deseas; de lo contrario, se usará la ubicación por defecto del perfil de publicación.

Por último, pulsa Publicar. Visual Studio compilará y dejará los ejecutables y dependencias en el directorio indicado. Es ese camino el que usarás más adelante en el script, así que tenlo a mano porque lo referenciarás con una macro que apunte a todos los ficheros.

Preparar el script en Inno Setup

Abre Inno Setup y crea un script vacío. Guárdalo en una carpeta de trabajo junto con dos archivos clave provenientes del paquete de dependencias: CodeDependencies.iss y netcorecheck_x64.exe. De esta forma, tendrás tres elementos iniciales en el mismo directorio: tu script .iss, la librería de dependencias y el comprobador de .NET. Si lo prefieres puedes apoyarte en guías sobre cómo crear un mini instalador con un script .bat para comprender la estructura básica del script.

La estructura del script gira en torno a varias secciones y directivas que controlan cómo se configura, qué archivos se copian, qué accesos directos se crean y qué acciones se ejecutan antes, durante y después de la instalación. A continuación verás los puntos esenciales que debes definir para un instalador moderno, en 64 bits y con comprobación de .NET 6 en el equipo destino.

Sección Setup: identidad, compresión y 64 bits

En Setup defines la identidad del producto, rutas por defecto y parámetros del instalador. Es fundamental asignar un AppId único (GUID). Para obtenerlo, puedes usar la opción del propio Inno Setup: Tools → Generate GUID. Si reutilizas un GUID en diferentes instaladores, el sistema puede confundirlos y tratar una instalación como si fuera una actualización de otra.

Suele emplearse un conjunto de macros para mapear la información principal: por ejemplo, #define MyAppName, #define MyAppVersion, #define MyAppPublisher, #define MyAppURL, #define MyAppExeName, o incluso una macro para el nombre del servicio si tu app lo requiere (como #define MyService). También definirás la carpeta de publicación y la carpeta de instalación objetivo a través de macros del estilo #define PublishFolder y #define InstallationDir.

Con esa información, mapeas los campos del instalador: AppName, AppVersion, AppPublisher, AppPublisherURL, AppSupportURL, AppUpdatesURL, DefaultDirName (normalmente combinando InstallationDir + MyAppName), DefaultGroupName y OutputBaseFilename (el nombre con el que se generará el ejecutable del instalador). Para el empaquetado, suele activarse Compression lzma y SolidCompression yes, con WizardStyle moderno, privilegios de administrador PrivilegesRequired=admin y, si procede, ArchitecturesInstallIn64BitMode=x64 para instalar en 64 bits.

Sección Code: comprobación de .NET 6

Gracias a la librería de dependencias, puedes añadir una llamada durante la inicialización que verifique si .NET 6 Desktop está presente. Si no lo está, el instalador ofrecerá instalarlo automáticamente. En la función de inicialización (InitializeSetup) basta con invocar el procedimiento que aporta la librería, algo como Dependency_AddDotNet60Desktop, y devolver True para continuar.

Recuerda que para que esto funcione, en la misma carpeta del script deben estar el archivo CodeDependencies.iss y el ejecutable netcorecheck_x64.exe. El primero se incluye en tu script y el segundo se distribuye junto con tu app en la carpeta de instalación para poder realizar la comprobación del runtime.

Sección Languages: instalador multilingüe

Inno Setup permite incluir varios idiomas para la interfaz del asistente. Puedes activar los que necesites; por ejemplo: english, catalan, french, portuguese y spanish. Cada idioma referencia su fichero de mensajes, algo como compiler:Default.isl o rutas del estilo compiler:Languages\Spanish.isl. Si no necesitas todos, deja comentados los que no vayas a usar.

Configurar varios idiomas en el instalador mejora la experiencia, pero no olvides revisar que tus textos personalizados (como el nombre de la aplicación o URLs de soporte) estén pensados para un público internacional o claramente localizados, según tu caso.

Sección Files: qué copiar y qué excluir

Aquí indicas el origen de los ficheros (tu carpeta de publicación) y el destino (normalmente {app}). Un detalle crítico: en la macro de publicación, deja el asterisco al final del camino (por ejemplo, una ruta acabada en \publish\*) para que el instalador copie todos los archivos del directorio y subdirectorios. Sin ese comodín, podrías olvidar ficheros necesarios en el empaquetado.

Es habitual añadir una regla de exclusión si no quieres distribuir ciertos ficheros de configuración o temporales. Por ejemplo, puedes excluir conf.xml si esa configuración debe generarse en tiempo de ejecución o distribuirse por otra vía. Aprovecha las flags habituales como ignoreversion, recursesubdirs y createallsubdirs para controlar cómo se copian los ficheros. Ten en cuenta también qué hacer con archivos de instalación tradicionales como los archivos .inf si tu instalación los necesita.

No olvides incluir en esta sección el ejecutable netcorecheck_x64.exe para que quede dentro de la carpeta de la aplicación. Esto va de la mano con la comprobación de dependencias que configuraste en la sección Code y garantiza una instalación robusta.

Sección Icons: accesos directos

Si quieres crear accesos directos en el grupo de programas, define una entrada que apunte a tu ejecutable principal. Por ejemplo, un icono con nombre basado en {#MyAppName} y que lance {app}\{#MyAppExeName}. Puedes crear más accesos (Escritorio, Inicio, etc.) según convenga, pero ten presente que menos es más y conviene no sobrecargar al usuario con demasiadas opciones.

Sección Run y UninstallRun: servicios y tareas

Si tu aplicación corre como servicio de Windows, puedes gestionar su ciclo de vida desde el propio instalador. La idea es detener y eliminar un servicio previo si existe, crear el nuevo servicio apuntando a {app}\{#MyAppExeName} con inicio automático y, finalmente, iniciarlo tras la copia de archivos. Todo esto se hace con sc.exe invocado en modo oculto, pasando los parámetros adecuados (stop, delete, create con binPath y start). Si necesitas ejecutar comandos desde el instalador, consulta cómo abrir CMD desde el instalador para manejar procesos y servicios.

Para la desinstalación, puedes definir acciones que cierren el proceso y detengan y eliminen el servicio. Una orden de taskkill ayuda a cerrar el ejecutable si sigue corriendo, seguida de sc.exe stop y sc.exe delete. Así, te aseguras de que la eliminación es limpia y no quedan restos de servicios activos al finalizar el desinstalador.

Puntos clave del script y errores comunes

Deja el comodín final en la macro de publicación. El clásico fallo es olvidar el asterisco al final de PublishFolder, lo que provoca que no se copien todos los archivos necesarios. Revisa también las exclusiones para no llevarte sorpresas con ficheros que sí necesitas.

Genera siempre un GUID nuevo para AppId. Si compartes el mismo identificador entre distintas aplicaciones, Inno Setup puede interpretar que estás realizando una actualización y no una instalación independiente. Esta es una de las causas más comunes de comportamientos extraños en desinstalaciones o en entradas del Panel de control.

Marca la instalación en 64 bits cuando corresponda. Con ArchitecturesInstallIn64BitMode=x64 alineas el instalador con tu binario x64 y evitas redirecciones de sistema innecesarias. Acompaña esto de PrivilegesRequired=admin si necesitas escribir en ubicaciones protegidas, registrar servicios o instalar recursos de sistema.

Revisa los idiomas incluidos. Si el instalador va dirigido a un público concreto, usa únicamente los idiomas necesarios. Mantener solo los imprescindibles simplifica el paquete, reduce riesgos de inconsistencias y mejora la experiencia de usuario.

Compilación del instalador

Con todo listo, toca compilar. En Inno Setup ve a Build → Compile. Si no hay errores, se generará el ejecutable del instalador con el nombre que pusiste en OutputBaseFilename. Para localizarlo al instante, usa la opción Build → Open Output Folder y comprueba que el archivo está donde esperabas.

Si aparece algún error, revisa primero el include de la librería de dependencias, la presencia de CodeDependencies.iss y netcorecheck_x64.exe, y las rutas de publicación. Muchas veces los fallos se deben a rutas mal escritas, ficheros ausentes o un GUID no válido en AppId.

Pruebas recomendadas

Para verificar que todo va como la seda, lo ideal es instalar en una máquina virtual. Así validas que el instalador copia todos los archivos, crea accesos directos, gestiona dependencias como .NET 6 y, si procede, instala y arranca el servicio sin conflictos con el sistema anfitrión.

Tras ejecutar el instalador, confirma que tu aplicación funciona como esperas. Si es un servicio, revisa el estado con las herramientas de Servicios de Windows o con sc query. Comprueba que realiza su tarea (por ejemplo, escribir un registro en un fichero) y que al reiniciar la máquina el servicio permanece en automático.

Prueba la desinstalación desde el Panel de control. Debe detener y eliminar el servicio, borrar los archivos de la carpeta de instalación (salvo lo que decidas preservar) y retirar accesos directos y entradas del sistema. Si algo no se elimina correctamente, revisa las secciones Run y UninstallRun para ajustar el orden de las operaciones o los parámetros de sc.exe.

Con esta combinación de preparación (x64), publicación cuidada, comprobación de dependencias y control del ciclo de vida del servicio, Inno Setup te permite ofrecer al usuario un instalador profesional. Siguiendo estos pasos y vigilando los puntos críticos (GUID único, comodín en PublishFolder, privilegios y lenguajes), la creación y mantenimiento de instaladores para Windows se vuelve predecible, repetible y sin sorpresas.