Assume you have a product A, installable by IzPack and built by Maven. When you install product A, you may use RegistryInstallerListener to add entry to the registry. In RegistrySpec.xml (where you provide target key where to store information) you use Maven ${project.version} property. Therefore, when the product A will be installed, the Maven version will be stored in the Registry. Next time you install product A you use read that entry from a registry (here I describe how to do that in IzPack 4. This is out-of-the-box in IzPack 5) and then compare the Maven versions (you may use this post information to create a Maven panel) and determine, whereas to install/update a product.

Product A may also be independent installer, launched from another installer. For instance, if product A installer requires administrative rights, and it is included from product B, which doesn' require administrative right, you would like to avoid UAC as much as possible. So from product B you can check version of product A and determine, whereas you need to launch it.

You will of course need to depend on IzPack standalone compiler.

Basically, what do you need to do is to have some directory for staging. This is useful, when you want to run some filtering or putting some additional resources from somewhere else to the installer. You can use %TEMP% directory (File.createTempFile(...)) for that. Do not forget to wipe it afterwards!
When you have all your installer resources in some staging directory and you know the direct path to your install.xml you are ready to build a installer:

CompilerConfig compilerConfig = new CompilerConfig(installXmlPath, stagingDirPath, null, targetFilePath);
compilerConfig.executeCompiler();

<registryReader>
  <registry key="SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\myApp"
      name="DisplayVersion" default="null" variable="myApp.version" />
</registryReader>

You may have several registry entries to read multiple keys. name specifies registry key. variable specifies to which variable to store the value. default specifies what should be a default value, when key was not found.

You will also need to provide COI dlls in install.xml:

<native type="3rdparty" name="COIOSHelper.dll" stage="both">
  <os family="windows" />
</native>
<native type="3rdparty" name="COIOSHelper_x64.dll" stage="both">
  <os family="windows" />
</native>

You will need to separate COI package yourself and add it to your Maven repository.

And here is the panel source:izpackExtensions-registryReader

First, if you are using COI tools from IzPack (for example if you have your own custom panel that works with registry or using CheckedHelloPanel) you also have to deliver 64bit dll:

  <native type="3rdparty" name="COIOSHelper.dll" stage="both">
    <os family="windows" />
  </native>
  <native type="3rdparty" name="COIOSHelper_x64.dll" stage="both">
    <os family="windows" />
  </native>

The second thing, if you are using ShortcutPanel, you will also have to deliver 64bit dlls:

  <native type="izpack" name="ShellLink.dll">
    <os family="windows" />
  </native>
  <native type="izpack" name="ShellLink_x64.dll">
    <os family="windows" />
  </native>

You will need to add AutomationHelper class. Here is how you can do it. Assuming you have custom panel with a name MyPanel, create class MyPanelAutomationHelper in the same package. This class has to extend PanelAutomationHelper and implement PanelAutomation. And then you will have to specify how to run the panel silently.
Basically, you can just repeat all the routine from panelActivate method in MyPanel panel (or if you do not want to repeat yourself, invoke/call MyPanel smartly). But you cannot use UI stuff like emitWarning or emitError. If you need to inform user about something -- write it directly to the output. Silent installer should be silent.

Here is AutomationHelper class for MyPanel panel, which we developed previously:

package com.izforge.izpack.panels;

import java.util.List;

import com.coi.tools.os.win.MSWinConstants;
import com.izforge.izpack.adaptator.IXMLElement;
import com.izforge.izpack.installer.AutomatedInstallData;
import com.izforge.izpack.installer.InstallerException;
import com.izforge.izpack.installer.PanelAutomation;
import com.izforge.izpack.installer.PanelAutomationHelper;

public class MyPanelAutomationHelper extends PanelAutomationHelper implements PanelAutomation {

  @Override
  public void makeXMLData(AutomatedInstallData installData, IXMLElement panelRoot) {
    //
  }

  @Override
  public void runAutomated(AutomatedInstallData installData, IXMLElement panelRoot) throws InstallerException {
    System.out.println("Hello, IzPack");
  }
}

CheckedHelloPanel is an example of interaction with a registry. If you decide to go that way, you will need to do some additional things too besides writing the code.

First of all, you will need to define a COIOSHelper.dll in your install.xml:

<native type="3rdparty" name="COIOSHelper.dll" stage="both">
  <os family="windows"/>
</native>

The second thing is that if you take a look into CheckedHelloPanel code, you will see, that it also uses some com.coi.tools code. You will need to include that into your panel jar too.
Here is the way how we do it. First, we took this com.coi.tools and put it to our maven repository. For each our custom IzPack panel we have a separate maven module nesting some common parent routine (I have already described it in one of the previous posts. Then during package phase of our custom panel code we use Maven Shade Plugin to combine sources of com.coi.tools and our panel code.

The third thing deals with development cycle. If you develop your own custom panel to work with registry using the way , you will need to place dlls inside "izpack" project.
Create src\native folder and copy dlls from bin\native directory in IzPack installation. Then you could use them inside install.xml:

<native type="3rdparty" name="COIOSHelper.dll" stage="both">
  <os family="windows"/>
</native>

First, you have to reference your configuration file from resources section in install.xml file:

<resources>
  <res id="mySpec.xml" src="mySpec.xml" />
</resources>

Then you would need to create such file in your IzPack resources.

And then you can read your file from your custom panel:

@Override
public void panelActivate() {
  InputStream is = ResourceManager.getInstance().getInputStream("mySpec.xml");
...

Moreover, you can read xml using IzPack capabilities. Not that convenient, but anyway:

    String xml = inputStreamToString(is);    // I omit this peace of code, since it is not relevant. "is" -- is InputStream

    IXMLParser parser = new XMLParser();
    IXMLElement rootEl = parser.parse(xml);

    Vector<IXMLElement> els = rootEl.getChildrenNamed("myElements");
    Iterator<IXMLElement> it = els.iterator();
    while (it.hasNext()) {
      IXMLElement el = it.next();

      String myAttribute = el.getAttribute("myAttribute");
      ...

First go and download IzPack. We will use 4.3.3 vesion here.
After installation you will find source directory src\lib in installation location. Import it into Eclipse. Or create a Java project in Eclipse and copy sources afterwards. Obviously, project has some dependencies, so in Java Build Path add all external jars from IzPack installation folder lib. Now you should not have any errors. IzPack code is now browsable.

You can have a maven project for your custom IzPack panels. It is straight forward creation of Maven project, so I will omit it here. I will just assume, that you have a Java project for your panel.

Link you Java project to IzPack libraries, which are located in lib folder of IzPack installation. Please note, that you should not link to imported IzPack project in your Eclipse, because we will need it later on for debugging the panel -- in this case you would have cyclic dependency. Do that in project properties Java Build Path.

According to documentation, panels classes have to be created in com.izforge.izpack.panels. In your project create a package with that name. Now in that package create class MyPanel:

package com.izforge.izpack.panels;

import com.izforge.izpack.installer.InstallData;
import com.izforge.izpack.installer.InstallerFrame;
import com.izforge.izpack.installer.IzPanel;

public class MyPanel extends IzPanel {

  private static final long serialVersionUID = -2686831922771063920L;

  public MyPanel(InstallerFrame parent, InstallData idata) {
    super(parent, idata);
  }

  @Override
  public void panelActivate() {
    System.out.println("Hello, IzPack");
  }
}

Let's create a test IzPack installation, which would use our new panel. Basically, just create "install.xml" file in any folder. I will do that in c:\projects\test25\src\main\resources. Here are the internals of install.xml:

<?xml version="1.0" encoding="UTF-8"?>

<installation version="1.0">

  <info>
    <appname>Test 25</appname>
    <appversion>1.0</appversion>
    <uninstaller write="no" />
    <javaversion>1.6</javaversion>

    <pack200 />
  </info>

  <guiprefs resizable="yes" width="500" height="340">
    <modifier key="allXGap" value="5" />
    <modifier key="allYGap" value="5" />
    <modifier key="paragraphYGap" value="15" />
    <modifier key="useHeadingPanel" value="yes" />
    <modifier key="headingLineCount" value="1" />
    <modifier key="headingFontSize" value="2" />
    <modifier key="headingBackgroundColor" value="0x00ffffff" />
    <modifier key="headingPanelCounter" value="text" />
    <modifier key="headingPanelCounterPos" value="inHeading" />
  </guiprefs>

  <locale>
    <langpack iso3="eng" />
  </locale>

  <panels>
    <panel classname="MyPanel" />
    <panel classname="SimpleFinishPanel" />
  </panels>

  <packs>
    <pack name="main" required="yes">
      <description>Test 25 Installation</description>
    </pack>
  </packs>

</installation>

Now, here is the development flow. You modify the panel code. Then you run IzPack compiler from Eclipse and IzPack installer, also from Eclipse. Just two button clicks!

Here is how you configure it. Navigate to com.izforge.izpack.compiler.Compiler class in imported IzPack project in Eclipse. In menu choose "Run->Profile Configurations..". In "Java Application" on the left create new application entry. In "Main" tab in "Project" choose "izpack" in Main class choose "com.izforge.izpack.compiler.Compiler". In "Arguments" tab write "c:\projects\test25\src\main\resources\install.xml -b c:\projects\test25\src\main\resources -o c:\projects\test25\target\out -h "c:/Program Files/Izpack-4.3.3"", where you specify path to install.xml, where installer jar will be outputed and home path to IzPack installation.

Now, all we need is to tell IzPack, which installer we want to debug. In "Compiler" run configuration we specified the output of Compiler. Right-click "izpack" project and in Build Path specify that jar (which you specified in -o option).

Now you can simply call main class com.izforge.izpack.installer. GUI installer will be launched and you will be able to see all the output in the console. You can run in Debug mode as well.

So again, first modify the code. Then run Compiler and then run Installer.