FireGiant WiX v3

https://docs.firegiant.com/wix3/
Admin
FireGiant WiX v3 is a toolset for creating Windows Installer (MSI) packages, bundles, and patches,...
Tokens:309,792
Snippets:2,957
Trust Score:9.7
Update:5 days ago
Show doc for...
Tokens:
Raw
### Run installer with logging (msiexec /i)

Source: https://docs.firegiant.com/wix3/tutorial/getting-started/putting-it-to-use

Start the installer with logging enabled to diagnose failures. The /l* flag creates a verbose log, while /l*v creates an even more detailed log. The log file will pinpoint the error.

```bash
msiexec /i SampleFirst.msi /l* SampleFirst.log
```

```bash
msiexec /i SampleFirst.msi /l*v SampleFirst.log
```

--------------------------------

### Complete WiX Sample for Start Menu Shortcut

Source: https://docs.firegiant.com/wix3/howtos/files_and_registry/create_start_menu_shortcut

A complete WiX project that defines the directory structure, installs the application files, creates a Start Menu shortcut, and references the shortcut component in a Feature. Replace the GUID placeholders with actual GUIDs.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
    <Product Id="*" UpgradeCode="PUT-GUID-HERE" Version="1.0.0.0" Language="1033" Name="My Application Name" Manufacturer="My Manufacturer Name">
        <Package InstallerVersion="300" Compressed="yes"/>
        <Media Id="1" Cabinet="myapplication.cab" EmbedCab="yes" />


        <Directory Id="TARGETDIR" Name="SourceDir">
            <Directory Id="ProgramFilesFolder">
                <Directory Id="APPLICATIONROOTDIRECTORY" Name="My Application Name"/>
            </Directory>
            <!-- Step 1: Define the directory structure -->
            <Directory Id="ProgramMenuFolder">
                <Directory Id="ApplicationProgramsFolder" Name="My Application Name"/>
            </Directory>
        </Directory>


        <DirectoryRef Id="APPLICATIONROOTDIRECTORY">
            <Component Id="myapplication.exe" Guid="PUT-GUID-HERE">
                <File Id="myapplication.exe" Source="MySourceFiles\MyApplication.exe" KeyPath="yes" Checksum="yes"/>
            </Component>
            <Component Id="documentation.html" Guid="PUT-GUID-HERE">
                <File Id="documentation.html" Source="MySourceFiles\documentation.html" KeyPath="yes"/>
            </Component>
        </DirectoryRef>


        <!-- Step 2: Add the shortcut to your installer package -->
        <DirectoryRef Id="ApplicationProgramsFolder">
            <Component Id="ApplicationShortcut" Guid="PUT-GUID-HERE">
                <Shortcut Id="ApplicationStartMenuShortcut"
                          Name="My Application Name"
                          Description="My Application Description"
                          Target="[#myapplication.exe]"
                          WorkingDirectory="APPLICATIONROOTDIRECTORY"/>
                <RemoveFolder Id="ApplicationProgramsFolder" On="uninstall"/>
                <RegistryValue Root="HKCU" Key="Software\MyCompany\MyApplicationName" Name="installed" Type="integer" Value="1" KeyPath="yes"/>
            </Component>
        </DirectoryRef>


        <Feature Id="MainApplication" Title="Main Application" Level="1">
            <ComponentRef Id="myapplication.exe" />
            <ComponentRef Id="documentation.html" />
            <!-- Step 3: Tell WiX to install the shortcut -->
            <ComponentRef Id="ApplicationShortcut" />
        </Feature>
    </Product>
</Wix>
```

--------------------------------

### Create multiple MSI files with different UI languages

Source: https://docs.firegiant.com/wix3/wixui/wixui_localization

Call candle once and then call light multiple times with different culture values to produce a series of MSI files, each with a different setup UI language. The example generates installers for en-us, fr-fr, de-de, it-it, ja-jp, pl-pl, ru-ru, and es-es.

```shell
candle Product.wxs
light -ext WixUIExtension -cultures:en-us Product.wixobj -out Product_en-us.msi
light -ext WixUIExtension -cultures:fr-fr Product.wixobj -out Product_fr-fr.msi
light -ext WixUIExtension -cultures:de-de Product.wixobj -out Product_de-de.msi
light -ext WixUIExtension -cultures:it-it Product.wixobj -out Product_it-it.msi
light -ext WixUIExtension -cultures:ja-jp Product.wixobj -out Product_ja-jp.msi
light -ext WixUIExtension -cultures:pl-pl Product.wixobj -out Product_pl-pl.msi
light -ext WixUIExtension -cultures:ru-ru Product.wixobj -out Product_ru-ru.msi
light -ext WixUIExtension -cultures:es-es Product.wixobj -out Product_es-es.msi
```

--------------------------------

### Sample .wixproj file for building a WiX installer

Source: https://docs.firegiant.com/wix3/msbuild/authoring_first_msbuild_project

A minimal .wixproj file that builds an installer from a single Product.wxs file. It sets default Configuration and Platform, defines the project GUID (which must be changed), and imports the WiX targets. Additional .wxs files can be added with <Compile>, .wxl files with <EmbeddedResource>, and .wxi files with <Content>.

```xml
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <ProductVersion>3.0</ProductVersion>
    <ProjectGuid>{c523055d-a9d0-4318-ae85-ec934d33204b}</ProjectGuid>
    <SchemaVersion>2.0</SchemaVersion>
    <OutputName>WixProject1</OutputName>
    <OutputType>Package</OutputType>
    <WixTargetsPath Condition=" '$(WixTargetsPath)' == '' ">$(MSBuildExtensionsPath)\Microsoft\WiX\v[[Version.Major]].x\Wix.targets</WixTargetsPath>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <OutputPath>bin\$(Configuration)\</OutputPath>
    <IntermediateOutputPath>obj\$(Configuration)\</IntermediateOutputPath>
    <DefineConstants>Debug</DefineConstants>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <OutputPath>bin\$(Configuration)\</OutputPath>
    <IntermediateOutputPath>obj\$(Configuration)\</IntermediateOutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="Product.wxs" />
  </ItemGroup>
  <Import Project="$(WixTargetsPath)" />
</Project>
```

--------------------------------

### Install the 1.0 product with msiexec

Source: https://docs.firegiant.com/wix3/patching/patch_building

Runs the Windows Installer to install the 1.0 product MSI with verbose logging to install.log.

```bash
msiexec.exe /i 1.0\product.msi /l*vx install.log
```

--------------------------------

### Build installer with candle.exe and light.exe

Source: https://docs.firegiant.com/wix3/tutorial/getting-started/putting-it-to-use

Run these commands in the folder containing SampleFirst.wxs to compile and link the WiX source into SampleFirst.msi. No error messages should appear, and the MSI file should be created.

```bash
candle.exe SampleFirst.wxs
light.exe SampleFirst.wixobj
```

--------------------------------

### WiX component for installing and starting a service

Source: https://docs.firegiant.com/wix3/tutorial/net-and-net/services-rendered

This WiX component installs a service executable and configures it to start automatically. The ServiceInstall element defines the service with a display name, service name, and start type 'auto'. The ServiceControl element starts the service on install and stops/removes it on uninstall.

```xml
<Component Id='ServiceExeComponent' Guid='YOURGUID-D752-4C4F-942A-657B02AE8325'
  SharedDllRefCount='no' KeyPath='no' NeverOverwrite='no' Permanent='no' Transitive='no'
  Win64='no' Location='either'>


  <File Id='ServiceExeFile' Name='ServiceExe.exe' Source='ServiceExe.exe'
    ReadOnly='no' Compressed='yes' KeyPath='yes' Vital='yes' Hidden='no' System='no'
    Checksum='no' PatchAdded='no' />


  <ServiceInstall Id='MyServiceInstall' DisplayName='My Test Service' Name='MyServiceExeName'
    ErrorControl='normal' Start='auto' Type='ownProcess' Vital='yes' />


  <ServiceControl Id='MyServiceControl' Name='MyServiceExeName'
    Start='install' Stop='uninstall' Remove='uninstall' />


</Component>
```

--------------------------------

### Build Bundle with candle.exe and light.exe using WixBalExtension

Source: https://docs.firegiant.com/wix3/bundle/wixstdba

Shows the command-line steps to build an example.exe bundle from example.wxs. Both candle.exe and light.exe must be given the -ext WixBalExtension option.

```text
candle.exe example.wxs -ext WixBalExtension
light.exe example.wixobj -ext WixBalExtension

```

--------------------------------

### Burn bundle with registry searches and conditional .NET Framework packages

Source: https://docs.firegiant.com/wix3/tutorial/net-and-net/bootstrapping

A more advanced bundle that uses util:RegistrySearch to detect installed .NET Framework versions and sets DetectCondition and InstallCondition on ExePackage elements to install only when needed. The example includes two .NET Framework setup packages and a main MSI.

```xml
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi"
     xmlns:bal="http://schemas.microsoft.com/wix/BalExtension"
     xmlns:util="http://schemas.microsoft.com/wix/UtilExtension">
  <Bundle Name="..." Version="..." Manufacturer="..." UpgradeCode="..." Copyright="..." IconSourceFile="..." AboutUrl="...">
    <BootstrapperApplicationRef Id="WixStandardBootstrapperApplication.RtfLicense" />


    <util:RegistrySearch Root="HKLM" Key="SOFTWARE\Microsoft\Net Framework Setup\NDP\v4\Full" Value="Version" Variable="Net4FullVersion" />
    <util:RegistrySearch Root="HKLM" Key="SOFTWARE\Microsoft\Net Framework Setup\NDP\v4\Full" Value="Version" Variable="Net4x64FullVersion" Win64="yes" />


    <Chain>
      <ExePackage Id="Net45" Name="Microsoft .NET Framework 4.5.1 Setup" Cache="no" Compressed="yes" PerMachine="yes" Permanent="yes" Vital="yes" InstallCommand="/q"
        SourceFile="NDP451-KB2859818-Web.exe"
        DetectCondition="(Net4FullVersion = &quot;4.5.50938&quot;) AND (NOT VersionNT64 OR (Net4x64FullVersion = &quot;4.5.50938&quot;))"
        InstallCondition="(VersionNT >= v6.0 OR VersionNT64 >= v6.0) AND (NOT (Net4FullVersion = &quot;4.5.50938&quot; OR Net4x64FullVersion = &quot;4.5.50938&quot;))"/>


      <ExePackage Id="Net4Full" Name="Microsoft .NET Framework 4.0 Setup" Cache="no" Compressed="yes" PerMachine="yes" Permanent="yes" Vital="yes" InstallCommand="/q"
        SourceFile="dotNetFx40_Full_setup.exe"
        DetectCondition="Net4FullVersion AND (NOT VersionNT64 OR Net4x64FullVersion)"
        InstallCondition="(VersionNT &lt; v6.0 OR VersionNT64 &lt; v6.0) AND (NOT (Net4FullVersion OR Net4x64FullVersion))"/> />


      <RollbackBoundary />


      <MsiPackage Id="MainPackage" SourceFile="Main_package.msi" DisplayInternalUI="yes" Compressed="yes" Vital="yes" />
    </Chain>
  </Bundle>
</Wix>
```

--------------------------------

### Complete WiX sample

Source: https://docs.firegiant.com/wix3/howtos/files_and_registry/add_a_file

A complete WiX source file that defines the directory structure, adds files as components, and includes a Feature to install them. Replace the GUID placeholders with actual GUIDs. This sample can be compiled to generate an installer.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
    <Product Id="*" UpgradeCode="PUT-GUID-HERE" Version="1.0.0.0" Language="1033" Name="My Application Name" Manufacturer="My Manufacturer Name">
        <Package InstallerVersion="300" Compressed="yes"/>
        <Media Id="1" Cabinet="myapplication.cab" EmbedCab="yes" />


        <!-- Step 1: Define the directory structure -->
        <Directory Id="TARGETDIR" Name="SourceDir">
            <Directory Id="ProgramFilesFolder">
                <Directory Id="APPLICATIONROOTDIRECTORY" Name="My Application Name"/>
            </Directory>
        </Directory>


        <!-- Step 2: Add files to your installer package -->
        <DirectoryRef Id="APPLICATIONROOTDIRECTORY">
            <Component Id="myapplication.exe" Guid="PUT-GUID-HERE">
                <File Id="myapplication.exe" Source="MySourceFiles\MyApplication.exe" KeyPath="yes" Checksum="yes"/>
            </Component>
            <Component Id="documentation.html" Guid="PUT-GUID-HERE">
                <File Id="documentation.html" Source="MySourceFiles\documentation.html" KeyPath="yes"/>
            </Component>
        </DirectoryRef>


        <!-- Step 3: Tell WiX to install the files -->
        <Feature Id="MainApplication" Title="Main Application" Level="1">
            <ComponentRef Id="myapplication.exe" />
            <ComponentRef Id="documentation" />
        </Feature>
    </Product>
</Wix>
```

--------------------------------

### Link installer with WixUtilExtension using light.exe

Source: https://docs.firegiant.com/wix3/tutorial/com-expression-syntax-miscellanea/new-user-on-the-block

Run this command to link the installation package against the WiX extension module. The -ext flag specifies WixUtilExtension, and the output is Sample.msi from Sample.wixobj.

```bash
light.exe -ext WixUtilExtension -out Sample.msi Sample.wixobj
```

--------------------------------

### Component declaration with Id and Guid

Source: https://docs.firegiant.com/wix3/tutorial/getting-started/the-files-inside

Declares a WiX component with a unique Id and GUID. The GUID must be unique and is used by Windows Installer to track the component. The Id is used for cross-referencing within the WiX source.

```xml
<Component Id='MainExecutable' Guid='YOURGUID-83F1-4F22-985B-FDB3C8ABD471'>
```

--------------------------------

### Install the 1.0 product with msiexec

Source: https://docs.firegiant.com/wix3/patching/wix_patching

Installs the 1.0 product MSI with verbose logging to install.log.

```batch
msiexec.exe /i 1.0\product.msi /l*vx install.log

```

--------------------------------

### Auto-generate GUID with asterisk in Product element

Source: https://docs.firegiant.com/wix3/howtos/general/generate_guids

Use an asterisk (*) as the Id attribute value to auto-generate a GUID for the Product element on each build. The GUID is generated based on the install directory and filename of the KeyPath for the component, and remains consistent if those do not change.

```xml
<Product Id="*"
         Version="1.0.0.0"
         Language="1033"
         Name="My Application Name"
         Manufacturer="My Manufacturer Name">
```

--------------------------------

### Build the upgrade layout with Candle and Light

Source: https://docs.firegiant.com/wix3/patching/wix_patching

Compiles product.wxs with version 1.1 and links the resulting product.wixobj into 1.1\product.msi.

```batch
candle.exe -dVersion=1.1 product.wxs
light.exe product.wixobj -out 1.1\product.msi

```

--------------------------------

### Create sample root directory

Source: https://docs.firegiant.com/wix3/patching/wix_patching

Creates the directory C:\sample that will serve as the sample root for the WiX patch example.

```cmd
md C:\sample
```

--------------------------------

### Add InternetShortcut to installer component

Source: https://docs.firegiant.com/wix3/howtos/files_and_registry/create_internet_shortcut

Adds a util:InternetShortcut element to an existing shortcut component, creating a shortcut to a webpage in the Start Menu folder.

```xml
<DirectoryRef Id="ApplicationProgramsFolder">
  <Component Id="ApplicationShortcut" Guid="PUT-GUID-HERE">
    <Shortcut Id="ApplicationStartMenuShortcut"
              Name="My Application Name"
              Description="My Application Description"
              Target="[#MyApplicationExeFileId]"
              WorkingDirectory="APPLICATIONROOTDIRECTORY"/>
    <util:InternetShortcut Id="OnlineDocumentationShortcut"
                           Name="My Online Documentation"
                           Target="http://wixtoolset.org/"/>
    <RemoveFolder Id="ApplicationProgramsFolder" On="uninstall"/>
    <RegistryValue Root="HKCU" Key="Software\MyCompany\MyApplicationName" Name="installed" Type="integer" Value="1" KeyPath="yes"/>
  </Component>
</DirectoryRef>
```

--------------------------------

### Create Sample.txt for version 1.1

Source: https://docs.firegiant.com/wix3/patching/wix_patching

Creates a text file Sample.txt in the 1.1 directory with content indicating it is version 1.1.

```cmd
echo This is version 1.1 > C:\sample\1.1\Sample.txt
```

--------------------------------

### Run minor upgrade with msiexec REINSTALL=ALL REINSTALLMODE=vomus

Source: https://docs.firegiant.com/wix3/tutorial/upgrades-and-modularization/checking-for-oldies

Use this command to start a minor upgrade or small update .msi file. Without it, the installer fails with 'Another version of this product is already installed.' The command forces reinstallation of all features and uses the vomus reinstall mode.

```bash
msiexec /i SampleUpgrade.msi REINSTALL=ALL REINSTALLMODE=vomus
```

--------------------------------

### Build commands for SampleWixUI

Source: https://docs.firegiant.com/wix3/tutorial/user-interface/first-steps

Compile and link the SampleWixUI.wxs file, using the WixUIExtension to enable the user interface.

```bash
candle.exe SampleWixUI.wxs
light.exe -ext WixUIExtension SampleWixUI.wixobj
```

--------------------------------

### SampleFirst.wxs: Product and Package elements

Source: https://docs.firegiant.com/wix3/tutorial/getting-started/the-software-package

The initial part of the SampleFirst.wxs file defines the Product and Package elements. It includes placeholder GUIDs (YOURGUID) that must be replaced with real ones, and uses an asterisk for the Package Id to autogenerate a package GUID. This snippet is the foundation for the WiX installer.

```xml
<?xml version='1.0' encoding='windows-1252'?>
<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>
    <Product Name='Foobar 1.0' Manufacturer='Acme Ltd.'
        Id='YOURGUID-86C7-4D14-AEC0-86416A69ABDE'
        UpgradeCode='YOURGUID-7349-453F-94F6-BCB5110BA4FD'
        Language='1033' Codepage='1252' Version='1.0.0'>
    <Package Id='*' Keywords='Installer' Description="Acme's Foobar 1.0 Installer"
        Comments='Foobar is a registered trademark of Acme Ltd.' Manufacturer='Acme Ltd.'
        InstallerVersion='100' Languages='1033' Compressed='yes' SummaryCodepage='1252' />
```

--------------------------------

### Add UIRef element for WixUI_InstallDir

Source: https://docs.firegiant.com/wix3/wixui/wixui_dialog_library

Add a UIRef element with an Id matching the desired dialog set name to your setup authoring. This example uses WixUI_InstallDir.

```xml
<Product ...>
    <UIRef Id="WixUI_InstallDir" />
</Product>
```

--------------------------------

### Complete WiX installer with post-install launch

Source: https://docs.firegiant.com/wix3/howtos/ui_and_localization/run_program_after_install

This is the complete WiX installer script. It defines a product, adds two files (an executable and a documentation HTML file), includes a minimal UI with an optional checkbox to launch the application, and triggers a custom action (LaunchApplication) that runs the installed executable after the installer exits. The custom action uses the WixShellExec DllEntry from the WixCA binary key.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
    <Product Id="*"
             UpgradeCode="PUT-GUID-HERE"
             Version="1.0.0.0"
             Language="1033"
             Name="My Application Name"
             Manufacturer="My Manufacturer Name">
    <Package InstallerVersion="300" Compressed="yes"/>
    <Media Id="1" Cabinet="myapplication.cab" EmbedCab="yes" />


    <!-- The following three sections are from the How To: Add a File to Your Installer topic-->
    <Directory Id="TARGETDIR" Name="SourceDir">
        <Directory Id="ProgramFilesFolder">
            <Directory Id="APPLICATIONROOTDIRECTORY" Name="My Application Name"/>
        </Directory>
    </Directory>


    <DirectoryRef Id="APPLICATIONROOTDIRECTORY">
        <Component Id="myapplication.exe" Guid="PUT-GUID-HERE">
            <File Id="myapplication.exe" Source="MySourceFiles\MyApplication.exe" KeyPath="yes" Checksum="yes"/>
        </Component>
        <Component Id="documentation.html" Guid="PUT-GUID-HERE">
            <File Id="documentation.html" Source="MySourceFiles\documentation.html" KeyPath="yes"/>
        </Component>
    </DirectoryRef>


    <Feature Id="MainApplication" Title="Main Application" Level="1">
        <ComponentRef Id="myapplication.exe" />
        <ComponentRef Id="documentation.html" />
    </Feature>


    <!-- Step 2: Add UI to your installer / Step 4: Trigger the custom action -->
    <UI>
        <UIRef Id="WixUI_Minimal" />
        <Publish Dialog="ExitDialog"
            Control="Finish"
            Event="DoAction"
            Value="LaunchApplication">WIXUI_EXITDIALOGOPTIONALCHECKBOX = 1 and NOT Installed</Publish>
    </UI>
    <Property Id="WIXUI_EXITDIALOGOPTIONALCHECKBOXTEXT" Value="Launch My Application Name" />


    <!-- Step 3: Include the custom action -->
    <Property Id="WixShellExecTarget" Value="[#myapplication.exe]" />
    <CustomAction Id="LaunchApplication"
        BinaryKey="WixCA"
        DllEntry="WixShellExec"
        Impersonate="yes" />
    </Product>
</Wix>
```

--------------------------------

### Directory root with TARGETDIR and SourceDir

Source: https://docs.firegiant.com/wix3/tutorial/getting-started/the-files-inside

Starts the directory hierarchy with the root destination folder TARGETDIR, which is set to the source directory SourceDir. This links the installation source and destination.

```xml
<Directory Id='TARGETDIR' Name='SourceDir'>
```

--------------------------------

### Create Sample.txt for version 1.0

Source: https://docs.firegiant.com/wix3/patching/wix_patching

Creates a text file Sample.txt in the 1.0 directory with content indicating it is version 1.0.

```cmd
echo This is version 1.0 > C:\sample\1.0\Sample.txt
```
Tokens:
Raw