User Manual “Installer Creation Using Inno Setup”

This article will focus on Inno Setup – a convenient tool intended to package applications for Windows OS.

Why Inno Setup? “Inno Setup today rivals and even surpasses many commercial installers in feature set and stability,” the developer’s official website says. Indeed, this tool is quite simple to learn and powerful in terms of its capabilities.

At the moment Inno Setup, developers mention the following features as key ones:

You can download the stable version of Inno Setup Compiler for free from the official website. There, you can also find FAQ and documentation in English and third-party libraries that simplify the process of creating Inno Setup Script (.iss).

Inno Setup Compiler classic application has the Help section where you can find FAQ, example scripts, and documentation.

When you first start the program, you are greeted with a dialog that offers to look at examples, create your first Inno Setup Script (.iss) using the script wizard, or open an existing .iss script.

You can use the Inno Setup script wizard to create an installation file.

The wizard will offer to enter the following data:

When the wizard collects all the necessary information, it will offer to compile the resulting script. The file ready for installation will be in the folder that was selected for the final distribution package.

If you need to customize the installer interface, work with the registry, or configure actions during the uninstallation process, then you will have to modify the installer script.

Inno Setup scripts are divided into sections, each of which is responsible for its own functionality. It also sometimes happens that different sections may be suitable for the same purpose. The order of section’s execution is strictly defined and does not depend on the section’s location in the script.

All sections of the script, except for [Setup], [Messages], [CustomMessages], [LangOptions] and [Code], contain strings divided into parameters. Each parameter has its name followed by a colon and then a value. Unless otherwise noted, parameters are optional, as they assume a default value if not specified. Several parameters in a string are separated by a semicolon and can be listed in any order.

Inno Setup script example

Comments are supported in the script, for this you need to start a string with a semicolon (“;”).

Define the necessary constants at the very beginning of the script, before all the sections:

#define MyAppName “Example”

#define MyAppVersion “0.0.1”

#define MyAppPublisher “example developer”

#define URL “http://www.example.com”

#define MyAppURL “example.exe”

In this case, MyAppName is the name of the application, MyAppVersion is the version of the application, and MyAppPublisher is the developer. These constants will be available in any part of the script, and if it is required to modify something, you just need to do it once in one place.

This section contains global options used by the installer and uninstaller.

AppId={{9E594ED6-EBDC-4D98-990E-F3F6B9AB9ACE}

AppName={#MyAppName}

AppVersion={#MyAppVersion}

AppPublisher={#MyAppPublisher}

AppPublisherURL={#MyAppURL}

AppSupportURL={#MyAppURL}

Description of possible directives in the Setup section:

This section is used, if the developer wants to provide the user with some installation options. Please remember that the [Types] section itself only describes installation options for a given program and shall be combined with other sections.

Name: “full”; Description: “Full installation”

Name: “compact”; Description: “Compact installation”

Name: “custom”; Description: “Custom installation”; Flags: iscustom

This section is optional. It defines all the components that will be displayed on the wizard’s “Select components” page to configure the installation type. It is combined with the [Types] section. If the [Components] section lists components and the [Types] section does not exist, the installation types will be created automatically by the installer and may differ from what you expect.

Name: “main”; Description: “Main Files”; Types: full compact custom; Flags: fixed

Name: “help”; Description: “Help Files”; Types: full

Name: “help\english”; Description: “English”; Types: full

Name: “help\dutch”; Description: “Dutch”; Types: full

Optional section. It provides you with an option to mark the tasks you would like to complete during installation. These tasks are displayed as check boxes and toggle buttons on the “Select additional tasks” page. Tasks themselves do nothing. It is necessary to mark some actions in other sections with the Task code: taskName. Such actions will be performed, only if the user selected the task on the corresponding page

[Task] Name: desktopicon;

Description: “Create a &desktop icon”;

GroupDescription: “Additional icons:”;

Components: main;

Flags: exclusive unchecked

[Icon]Name: “{commondesktop}\{#MyAppName}”;

Filename: “{app}\{#MyAppExeName}”; Tasks: desktopicon

Tasks are described in the [Tasks] section. They will be displayed in the installer window after successful application installation before the “Installation complete” page and will look like a string, the value of which will be defined by the Description parameter. The task will be completed, if the user clicks the checkbox at the beginning of this string.

The [Icons] section describes where the shortcut should be placed, how the shortcut will be titled, how it will look (option), and for which particular file it is created. The Task’s parameter of the [Icons] section calls the task described in the [Tasks] section.

The [Tasks] section does not run any files. There is the [Run] section for files running.

This optional section defines any additional directories besides the application directory, which is automatically generated.

Note that you do not need to explicitly create directories before installing files in them using the [Files] section, so this section is primarily useful for creating empty directories. The example below creates empty “data” and “bin” folders in the application folder.

Name: “{app}\data”

Name: “{app}\bin”

This section defines any files that should be installed on the user’s system. Sometimes it is enough to specify the executable file that launches the application being installed. But often other resources are needed.

If the file to be installed is a ReadMe file, the installer may prompt you to read this file after successful installation of the application. The isreadme flag of the [Files] section is used for this purpose, but you can read the ReadMe file, only if the computer does not restart after installation.

Files in the [Files] section can also have the following attributes: “system”, “readonly” and “hidden”. The Attribs parameter is responsible for file attributes, and if it is not specified, then the file will not have any attributes at all.

Source: “CTL3DV2.DLL”; DestDir: “{sys}”; Flags: onlyifdoesntexist uninsneveruninstall
Source: “MYPROG.EXE”; DestDir: “{app}”
Source: “C:\example.exe”; DestDir: “{app}”; Attribs: system hiddenSource: “README.TXT”; DestDir: “{app}”; Flags: isreadme

The section defines the application shortcuts to be created in the Start menu and/or other places, for example, on the desktop. It should be remembered, if shortcuts are specified only in the [Icons] section, they will always be created. If the Task’s parameter is also specified for the shortcut in the [Tasks] section, then the shortcut will be created, only if the user selects the corresponding task when installing the program.

Name: “{group}\My Program”; Filename: “{app}\MYPROG.EXE”; WorkingDir: “{app}”
Name: “{group}\Uninstall My Program”; Filename: “{uninstallexe}”

It is an optional section that defines which records will be added to the INI file. If the INI file with the specified name does not exist in the specified folder, the installer will create it. If the INI file already exists, it can add, delete or modify entries in it, as well as delete the existing INI file and create a new one with the same name, but with different content.

Filename: “MyProg.ini”; Section: “InstallSettings”; Flags: uninsdeletesection
Filename: “MyProg.ini”; Section: “InstallSettings”; Key: “InstallPath”; String: “{app}”

In this example, Filename is the name of the INI file (with an .ini extension). Section is the name of the INI file section (it will be enclosed in square brackets in the resulting INI file). Key is the INI file key. String is the Key value (string).

This section is optional and defines which files or folders should be deleted during uninstallation.

Type: files; Name: “{win}\log.txt”

You can use the following “mask” to avoid listing all the files of the same type that should be deleted when installing or uninstalling the program:

Type: files; Name: “{app}\*.ini”

All files with the .ini extension will be deleted in this example. “Masks” for the installer are the same as for Windows: * – prefix (suffix) of any length, ? – prefix (suffix) of one character, etc.

The section sets languages available in the installer.

Name: “en”; MessagesFile: “compiler:Default.isl”
Name: “nl”; MessagesFile: “compiler:Languages\Dutch.isl”

Installer messages can be overridden by creating this section in the script file.

ButtonNext=&Forward >

The section is used to set message values for constants {cm:…}.

[CustomMessages]
CreateDesktopIcon=Create a &desktop icon
[Tasks]
Name: desktopicon; Description: “{cm:CreateDesktopIcon}”

The section is used to customize language settings such as fonts used by the installer and uninstaller. Typically, you do not need to create the [LangOptions] section in your script file, since by default language specific settings are retrieved from the Default.isl file included in the Inno Setup.

LanguageName=English
LanguageID=$0409
LanguageCodePage=0
DialogFontName=
DialogFontSize=8
WelcomeFontName=Verdana
WelcomeFontSize=12
TitleFontName=Arial
TitleFontSize=29
CopyrightFontName=Arial
CopyrightFontSize=8
RightToLeft=no

If the language identifier is not specified before the [LangOptions] section parameter, the installer will apply them to all the languages specified in the [Languages] section (except for the LanguageName and LanguageID parameters). If you want changes to affect only a specific language, a prefix (language identifier and point) should be specified before the parameter:

rus.TitleFontSize=29

This optional section determines any registry keys/values that shall be created, modified, or deleted from the user’s system during installation.

By default, registry keys and values created by the installer are not deleted during uninstallation. To delete keys or values during uninstallation, add one of the following uninsdelete flags.

Root: HKCU; Subkey: “Software\My Company”; Flags: uninsdeletekeyifempty
Root: HKCU; Subkey: “Software\My Company\My Program”; Flags: uninsdeletekey
Root: HKLM; Subkey: “Software\My Company”; Flags: uninsdeletekeyifempty
Root: HKLM; Subkey: “Software\My Company\My Program”; Flags: uninsdeletekey
Root: HKLM; Subkey: “Software\My Company\My Program\Settings”; ValueType: string; ValueName: “InstallPath”; ValueData: “{app}”
Root: HKU; Subkey: {UserSid}\Software\Microsoft\Windows\CurrentVersion\Policies\System; ValueName: DisableRegistryTools; ValueType: dword; ValueData: 1

ValueType is the type of the value. It can be as follows:

If the ValueType parameter is string, expandsz or multisz, it will be a string that can contain constants.

If the data type is dword, it will be decimal (“123”), hexadecimal (“$7B”) or a constant representing an integer.

If the data type is binary – the sequence of hexadecimal – decimal bytes will look as follows: “00 ff 12 34”.

If the data type is none, the parameter is ignored.

This section is optional. In this section, you can specify any number of programs to run after the program has been successfully installed, but before the installer displays the final dialog. The [UninstallRun] section is also optional and specifies any number of programs to run as the first step of uninstallation. Both sections have the same syntax, unless otherwise noted.

The programs are executed in the order in which they appear in the script. By default, when processing the [Run] / [UninstallRun] entry, the installer / uninstaller will wait for the program to end before moving on to the next one, unless the nowait, shellexec or waituntilidle flags are used.

Filename: “{app}\INIT.EXE”; Parameters: “/x”
Filename: “{app}\README.TXT”; Description: “View the README file”; Flags: postinstall shellexec skipifsilent
Filename: “{app}\MYPROG.EXE”; Description: “Launch application”; Flags: postinstall nowait skipifsilent unchecked

Pascal scripting (modern Delphi-like Pascal) adds many new options to customize the process of installation or uninstallation. For example:

Pascal scripting does almost everything that the Inno program does and can do even more.

Most sections support the Flags parameter. This parameter represents a set of additional options. Several flags separated by spaces can be used in the same string. Basically, each section has its own specific flags.

Most script entries can contain constants. These are predefined strings enclosed in curly brackets {}. The installer or uninstaller converts constants to their literal values, depending on the user choice and system configuration.

There is a list of constants used in the Inno Setup below:

When all the necessary sections are filled out, the Inno Setup script is compiled, and an executable installer file is generated in the folder that was specified in the OutputDir directive in the Setup section. To compile the script, select Build -> Compile in the editor menu as shown in the screenshot below:

You can also select Run -> Run, then the script will be compiled and the installation of the application will start immediately.

In the Help -> Inno Setup Example Scripts menu you can find several examples of how this tool allows customizing the installer to make it complete a specific task.

In general, the documentation and FAQ that are attached to the script editor are compiled in a very clear and detailed manner. There you can find solutions to most basic tasks. There are also forums where installer scripts and features of their creation are discussed. There you can find many interesting examples or ask for advice. And when you get some positive results, you can share your knowledge and maybe even brag about your success.

Link to discussion

Link to FAQ forum