A tool to wrap Windows Classic App and then it can be uploaded to Intune - microsoft/Intune-Win32-App-Packaging-Tool. The 1.2.6 version of ExeWrapper for Mac is provided as a free download on our software library. The latest installer occupies 8.8 MB on disk. The program is included in Developer Tools. This software for Mac OS X is an intellectual property of Tim Parnel.

  • WrapperJarApp Integration (Windows)
  1. Software developers who have a setup.exe and want to offer an MSI that wraps their original setup.exe. System administrators with a setup.exe they want to distribute as an MSI to client computers in their organization. Our MSI Wrapper is the tool that makes it easy to convert an executable setup program to an MSI package.
  2. To create a runtime callable wrapper using.NET Framework tools. Run the Tlbimp.exe (Type Library Importer) tool.; This tool creates an assembly that contains run-time metadata for the types defined in the original type library.
  3. Download Launch4j Executable Wrapper for free. Cross-platform Java executable wrapper for creating lightweight Windows native EXEs. Provides advanced JRE search, application startup configuration and better user experience.
WrapperJarApp Integration (Windows)

The fourth and final method is to use the WrapperJarApp helper class to launch the application. This is another simple way to integrate with the Wrapper when the application is already configured to run as an executable jar.

There are some things to be aware of when using this method, however. When the Wrapper shuts down the JVM, there is no direct call to an application requesting that it shuts down cleanly. Rather, the Wrapper will exit the JVM by calling System.exit() from within the JVM. If the application has registered its own Shutdown Hook, it will be invoked, giving the application a chance to shut down cleanly. If, on the other hand, a Shutdown Hook is not registered, then the application will suddenly exit like when pressing CTRL-C in the console (command window). Both cases, with and without a Shutdown Hook, provide the exact same behavior as if the application was running without the Wrapper.

When integrating with this Method 4, the WrapperJarApp helper class replaces an application's main class. This gives the WrapperJarApp class a chance to immediately initialize the WrapperManager and register the JVM with the Wrapper. The WrapperJarApp class then manages all interaction with the Wrapper as well as the life-cycle of an application. When the Wrapper sends a start message to the JVM via the WrapperManager, the jar's manifest is inspected and its configured main class is called. The WrapperJarApp creates a new ClassLoader, which is able to load classes from the executable jar as well as any other jar files referenced within its manifest file.

The WrapperJarApp helper class is told how to launch the application by passing the absolute or relative location of the executable jar file, followed by any additional application parameters to the main method of the WrapperJarApp.

This section will walk you through a detailed explanation of how to configure JBoss to run within the Wrapper. Most other applications deployed as executable jars can be integrated by following the same steps.

This tutorial will start with a clean install of JBoss. We used JBoss EAP 7.0.0, so the exact steps may be slightly different depending on the exact version installed. After downloading JBoss, extract the files somewhere. In this tutorial we will use the folder D:JBoss. Then create the following folders:

Installing Wrapper Files

After downloading the Wrapper, extract the files somewhere, that will be referenced as {WRAPPER_HOME}. There are four directories which are required to be configured in order to be able to use the Wrapper.

First, copy the following files into the JBoss bin directory:

Rename the three batch files to reflect the name of your application. Be sure to remove the .in extensions so that the files all end with .bat.

(Depending on how your file explorer is configured on your computer, you may not be able to see file extensions.)

You should now have:

The wrapper.exe file is the actual Wrapper executable. The three batch files are used to run JBoss in a console, and to install and uninstall it as a Windows Service.

These batch files should not require any modification. They do assume that the wrapper.conf file will be located within a conf directory one level up, ../conf/wrapper.conf. If you wish to place the wrapper.conf file somewhere else, then the three batch files will require appropriate modification.

Copy the following two files into the JBoss lib directory:

The wrapper.dll file is a native library file required by the portion of the Wrapper which runs within the JVM. The wrapper.jar file contains all of the Wrapper classes.

conf directory

The Wrapper requires a configuration file 'wrapper.conf' for each application. The standard location for this file is in a conf directory in the application's home directory. Copy the following template file wrapper.conf.in into the conf directory of JBoss.

Rename the file and be sure to remove the .in extension so that the file is named wrapper.conf.

You should now have:

If you wish to relocate the configuration file wrapper.conf, you are free to do so. You will need to modify the batch files copied into the bin directory above to reflect the new location.

The default configuration file wrapper.conf will place a wrapper.log file into the JBoss logs directory.

If you wish to place the wrapper.log file in another location, you will need to edit the wrapper.conf file and modify the wrapper.logfile property to reflect the new location.

The Java Command Line

The Java command line of an executable jar is quite simple. In the case of JBoss, you would simply go to the JBoss directory and execute:

Any arguments would be passed in as follows:

In order to use the above Java command line with the Wrapper, we need to break up the command line's components into a configuration file. Open the wrapper.conf file into an editor and make the changes below.

For all properties mentioned below, links are provided to their descriptions. Please take the time to review the descriptions of any properties which are modified. In many cases, there are further details on their usage which are not mentioned here.

Java Executable

First, extract the Java executable and assign the location path to the wrapper.java.command property:


Next comes the classpath, which is configured using the wrapper.java.classpath.<n> properties. Java does not actually allow you to specify a classpath when running with the -jar parameter but this integration with the Wrapper works a little differently. The Wrapper requires that its wrapper.jar be specified in the classpath:

Main Class

When using the Wrapper and the WrapperJarApp helper class, Java is not executing the jar directly. It is necessary to specify the helper class as the main class of the application. The main class executed by Java when launched is specified by using the wrapper.java.mainclass property as follows:

Application Parameters

Application parameters are set using the wrapper.app.parameter.<n> properties. In this case, the command line to launch JBoss requires some application parameters. It is necessary to tell the WrapperJarApp helper class which jar to execute. This is done as follows:

Java additional Parameters

Java additional parameters are set using the wrapper.java.additional.<n> properties. Some parameters must be set for the JVM in order to start JBoss correctly.

Library Path

In order to use the Wrapper, one more property must be set. The Wrapper makes use of a native library to control interactions with the system. This library filewrapper.dll needs to be specified on the library path supplied to the JVM.

JBoss does not have any native libraries of its own, but if it did, the directories where they were located would also need to be specified. The library path is set using the wrapper.java.library.path.<n> properties.

Putting It All Together

Putting it all together, we get the following:

Notice, while these configurations will work correctly on our test machine, it is highly dependent on the directory structure and platform. By taking advantage of the fact that the Wrapper always sets the working directory to the location of the wrapper.exe file and by making use of a single environment variable, we are able to modify the above properties so that they are completely platform and machine independent:

(See:Windows Versions supported by Wrapper)

The final step is to set the Windows Service Properties. We will just set the properties which should be changed. But there are several others available, see the documentation for details on their usage. Suggested values for these variables are shown below.

The properties are set in the wrapper.conf file found in the conf folder from the Wrapper installation.

Trying It Out

JBoss can now be run by simply executing the batch file binmyJBoss.bat. Because of the way the Wrapper sets its current directory, it is not necessary to run this batch file from within the bin directory. Please try running the application once as a console application to verify the configuration before attempting to run it as a service.

The first time JBoss starts up, it will create its configuration files within the current user's home directory. Note that this will most likely be a different location when running as a service versus when running in a console window.

Congratulations, your application should now be up and running.

If you have any problems, please take a look at the Troubleshooting section for help with tracking down the problem.


You can create Component Object Model (COM) wrappers by using Visual Studio 2005 features or the .NET Framework tools Tlbimp.exe and Regasm.exe. Both methods generate two types of COM wrappers:

  • A Runtime Callable Wrapper from a type library to run a COM object in managed code.

  • A COM Callable Wrapper with the required registry settings to run a managed object in a native application.

In Visual Studio 2005, you can add the COM wrapper as a reference to your project.

Wrap COM Objects in a Managed Application

To create a runtime callable wrapper using Visual Studio

  1. Open the project for your managed application.

  2. On the Project menu, click Show All Files.

  3. On the Project menu, click Add Reference.

  4. In the Add Reference dialog box, click the COM tab, select the component you want to use, and click OK.

    In Solution Explorer, note that the COM component is added to the References folder in your project.

You can now write code to access the COM object. You can begin by declaring the object, such as with an Imports statement for Visual Basic or a Using statement for C#.


If you want to program Microsoft Office components, first install the Microsoft Office Primary Interop Assemblies Redistributable.

To create a runtime callable wrapper using .NET Framework tools

  • Run the Tlbimp.exe (Type Library Importer) tool.

This tool creates an assembly that contains run-time metadata for the types defined in the original type library.

Wrap Managed Objects in a Native Application

To create a COM callable wrapper using Visual Studio

  1. Create a Class Library project for the managed class that you want to run in native code. The class must have a parameterless constructor.

    Verify that you have a complete four-part version number for your assembly in the AssemblyInfo file. This number is required for maintaining versioning in the Windows registry. For more information about version numbers, see Assembly Versioning.

  2. On the Project menu, click Properties.

  3. Click the Compile tab.

  4. Select the Register for COM interop check box.


When you build the project, the assembly is automatically registered for COM interop. If you are building a native application in Visual Studio 2005, you can use the assembly by clicking Add Reference on the Project menu.

To create a COM callable wrapper using .NET Framework tools

Run the Regasm.exe (Assembly Registration Tool) tool.

This tool reads the assembly metadata and adds the necessary entries to the registry. As a result, COM clients can create .NET Framework classes transparently. You can use the assembly as if it were a native COM class.

You can run Regasm.exe on an assembly located in any directory, and then run the Gacutil.exe (Global Assembly Cache Tool) to move it to the global assembly cache. Moving the assembly does not invalidate location registry entries, because the global assembly cache is always examined if the assembly is not found elsewhere.

Lto-wrapper.exe Fatal Error

See also

Coments are closed

Recent News

  • DueFocus
  • BC Studio
  • BPM Analyzer 1.0.1
  • Hogwasher
  • BF IDE

Scroll to top