# compiler.build.standaloneWindowsApplication

Create a standalone application for deployment outside MATLAB that does not launch a Windows command shell

## Syntax

``compiler.build.standaloneWindowsApplication(AppFile)``
``compiler.build.standaloneWindowsApplication(AppFile,Name,Value)``
``compiler.build.standaloneWindowsApplication(opts)``
``results = compiler.build.standaloneWindowsApplication(___)``

## Description

example

``` CautionThis function is only supported on Windows® operating systems. `compiler.build.standaloneWindowsApplication(AppFile)` creates a standalone Windows only application using a MATLAB® function, class, or app specified using `AppFile`. The application does not open a Windows command shell on execution, and as a result, no console output is displayed. The generated executable has a `.exe` file extension and does not include MATLAB Runtime or an installer.```

example

````compiler.build.standaloneWindowsApplication(AppFile,Name,Value)` creates a standalone Windows application with additional options specified using one or more name-value arguments. Options include the executable name, version number, and icon and splash images.```

example

````compiler.build.standaloneWindowsApplication(opts)` creates a standalone Windows application with additional options specified using a `compiler.build.StandaloneApplicationOptions` object `opts`. You cannot specify any other options using name-value arguments.```

example

````results = compiler.build.standaloneWindowsApplication(___)` returns build information as a `compiler.build.Results` object using any of the argument combinations in previous syntaxes. The build information consists of the build type, paths to the compiled files, and build options.```

## Examples

collapse all

Create a graphical standalone application on a Windows system that displays a plot.

Write a MATLAB function that plots the values `1` to `10`. Save the function in a file named `myPlot.m`.

```function myPlot() plot(1:10)```

Build a standalone Windows application using the `compiler.build.standaloneWindowsApplication` command.

```compiler.build.standaloneWindowsApplication('myPlot.m'); ```

This syntax generates the following files within a folder named `myPlotstandaloneApplication` in your current working directory:

• `myPlot.exe` — Executable file.

• `mccExcludedFiles.log` — Log file that contains a list of any toolbox functions that were not included in the application. For more information on non-supported functions, see MATLAB Compiler Limitations.

• `readme.txt` — Readme file that contains information on deployment prerequisites and the list of files to package for deployment.

• `requiredMCRProducts.txt` — Text file that contains product IDs of products required by MATLAB Runtime to run the application.

• `splash.png` — File that contains the splash image that displays when the application starts.

• `unresolvedSymbols.txt ` — Text file that contains any unresolved symbols.

To run `myPlot.exe`, navigate to the `myPlotstandaloneApplication` folder and double-click `myPlot.exe` from the file browser, execute `!myPlot` in the MATLAB command window, or execute `myPlot.exe` in the Windows command shell.

The application displays a splash image followed by a MATLAB figure of a line plot.

Figure 1 (myPlot.exe)

Create a graphical standalone application on a Windows system and customize it using name-value arguments.

Create `xVal` as a vector of linearly spaced values between 0 and 2π. Use an increment of π/40 between the values. Create `yVal` as sine values of x. Save both variables in a MAT-file named `myVars.mat`.

```xVal = 0:pi/40:2*pi; yVal = sin(xVal); save('myVars.mat','xVal','yVal');```

Create a function file named `myPlot.m` to create a line plot of the `xVal` and `yVal` variables.

```function myPlot() load('myVars.mat'); plot(xVal,yVal) ```

Build the standalone application using the `compiler.build.standaloneWindowsApplication` function. Use name-value arguments to specify the executable name and version number.

```compiler.build.standaloneWindowsApplication('myPlot.m',... 'ExecutableName','SineWaveApp',... 'ExecutableVersion','2.0') ```

This syntax generates the following files within a folder named `SineWaveAppstandaloneApplication` in your current working directory:

• `SineWaveApp.exe`

• `mccExcludedFiles.log`

• `readme.txt`

• `requiredMCRProducts.txt`

• `splash.png`

• `unresolvedSymbols.txt `

To run `SineWaveApp.exe`, navigate to the `myPlotstandaloneApplication` folder and double-click `SineWaveApp.exe` from the file browser, execute `!SineWaveApp.exe` in the MATLAB command window, or execute `SineWaveApp.exe` at the Windows command prompt.

The application displays a splash image followed by a MATLAB figure of a sine wave.

Figure 1 (SineWaveApp.exe)

Create multiple graphical standalone applications on a Windows system using a `compiler.build.StandaloneApplicationOptions` object.

Write a MATLAB function that plots the values `1` to `10`. Save the function in a file named `myPlot.m`.

```function myPlot() plot(1:10) ```

Create a `StandaloneApplicationOptions` object using `myPlot.m`. Use name-value arguments to specify a common output directory and display progress information during the build process.

```opts = compiler.build.StandaloneApplicationOptions('myPlot.m',... 'OutputDir','D:\Documents\MATLAB\work\WindowsApps',... 'Verbose','On')```
```opts = StandaloneApplicationOptions with properties: ExecutableName: 'myPlot' CustomHelpTextFile: '' EmbedArchive: on ExecutableIcon: 'C:\Program Files\MATLAB\R2021a\toolbox\compiler\resources\default_icon_48.png' ExecutableSplashScreen: 'C:\Program Files\MATLAB\R2021a\toolbox\toolbox\compiler\resources\default_splash.png' ExecutableVersion: '1.0.0.0' AppFile: 'myPlot.m' TreatInputsAsNumeric: on AdditionalFiles: {} AutoDetectDataFiles: on OutputDir: 'D:\Documents\MATLAB\work\WindowsApps' Verbose: on```

Build a graphical standalone application by passing the `StandaloneApplicationOptions` object as an input to the build function.

```compiler.build.standaloneWindowsApplication(opts); ```

To create a new application using the function file `myPlot2.m` with the same options, use dot notation to modify the `AppFile` of the existing `StandaloneApplicationOptions` object before running the build function again.

```opts.AppFile = 'example2.m'; compiler.build.standaloneWindowsApplication(opts);```

By modifying the `AppFile` argument and recompiling, you can compile multiple applications using the same options object.

Create a standalone Windows application on a Windows system and save information about the build type, generated files, and build options to a `compiler.build.Results` object.

Compile using the file `Mortgage.mlapp` located in `matlabroot\examples\matlab\main`.

`results = compiler.build.standaloneWindowsApplication('Mortgage.mlapp')`
```results = Results with properties: BuildType: 'standaloneWindowsApplication' Files: {3×1 cell} Options: [1×1 compiler.build.StandaloneApplicationOptions]```

The `Files` property contains the paths to the following files:

• `Mortgage.exe`

• `splash.png`

• `readme.txt`

## Input Arguments

collapse all

Path to the main file used to build the application, specified as a row character vector or a string scalar. The file must be a MATLAB function, class, or app of one of the following types: `.m`, `.p`, `.mlx`, `.mlapp`, or a valid MEX file.

Example: `'mymagic.m'`

Data Types: `char` | `string`

Standalone application build options, specified as a `compiler.build.StandaloneApplicationOptions` object.

### Name-Value Pair Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside quotes. You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `'EmbedArchive','on'`

Additional files to include in the standalone application, specified as a character vector, a string scalar, a string array, or a cell array of character vectors. File paths can be relative to the current working directory or absolute.

Example: `'AdditionalFiles',["myvars.mat","myfunc.m"]`

Data Types: `char` | `string` | `cell`

Flag to automatically include data files, specified as `'on'` or `'off'`, or as numeric or logical `1` (`true`) or `0` (`false`). A value of `'on'` is equivalent to `true`, and `'off'` is equivalent to `false`. Thus, you can use the value of this property as a logical value. The value is stored as an on/off logical value of type `matlab.lang.OnOffSwitchState`.

• If you set this property to `'on'`, then data files that you provide as inputs to certain functions (such as `load` and `fopen`) are automatically included in the standalone application.

• If you set this property to `'off'`, then you must add data files to the application using the `AdditionalFiles` property.

Example: `'AutoDetectDataFiles','Off'`

Data Types: `logical`

Path to a help file containing help text for the end user of the application, specified as a character vector or a string scalar. The path can be relative to the current working directory or absolute.

Example: `'CustomHelpTextFile','D:\Documents\MATLAB\work\help.txt'`

Data Types: `char` | `string`

Flag to embed the standalone archive, specified as `'on'` or `'off'`, or as numeric or logical `1` (`true`) or `0` (`false`). A value of `'on'` is equivalent to `true`, and `'off'` is equivalent to `false`. Thus, you can use the value of this property as a logical value. The value is stored as an on/off logical value of type `matlab.lang.OnOffSwitchState`.

• If you set this property to `'on'`, then the function embeds the archive in the standalone executable.

• If you set this property to `'off'`, then the function generates the standalone archive as a separate file.

Example: `'EmbedArchive','Off'`

Data Types: `logical`

Path to the icon image, specified as a character vector or a string scalar. The image is used as the icon for the standalone executable. The path can be relative to the current working directory or absolute. Accepted image types are `.ico`, `.jpg`, `.jpeg`, `.png`, `.bmp`, and `.gif`.

The default path is:

`'`matlabroot`\toolbox\compiler\resources\default_icon_48.png'`

Example: `'ExecutableIcon','D:\Documents\MATLAB\work\images\myIcon.png'`

Data Types: `char` | `string`

Name of the generated application, specified as a character vector or a string scalar. The default value is the file name of `AppFile`. Target output names must begin with a letter or underscore character and contain only alpha-numeric characters or underscores.

Example: `'ExecutableName','MagicSquare'`

Data Types: `char` | `string`

Path to the splash screen image, specified as a character vector or a string scalar. The path can be relative to the current working directory or absolute. Accepted image types are `.jpg`, `.jpeg`, `.png`, `.bmp`, and `.gif`. The image is resized to 400 pixels by 400 pixels.

The default path is:

`'`matlabroot`\toolbox\toolbox\compiler\resources\default_splash.png'`

Note

This is only used in Windows applications built using `compiler.build.standaloneWindowsApplication`.

Example: `'ExecutableSplashScreen','D:\Documents\MATLAB\work\images\mySplash.png'`

Data Types: `char` | `string`

Executable version, specified as a character vector or a string scalar.

Note

This is only used on Windows operating systems.

Example: `'ExecutableVersion','4.0'`

Data Types: `char` | `string`

Path to the output directory where the build files are saved, specified as a character vector or a string scalar. The path can be relative to the current working directory or absolute.

The default name of the build folder is the executable name appended with `standaloneApplication`.

Example: `'OutputDir','D:\Documents\MATLAB\work\MagicSquarestandaloneApplication'`

Data Types: `char` | `string`

Flag to interpret command line inputs as numeric values, specified as `'on'` or `'off'`, or as numeric or logical `1` (`true`) or `0` (`false`). A value of `'on'` is equivalent to `true`, and `'off'` is equivalent to `false`. Thus, you can use the value of this property as a logical value. The value is stored as an on/off logical value of type `matlab.lang.OnOffSwitchState`.

• If you set this property to `'on'`, then command line inputs are treated as numeric MATLAB doubles.

• If you set this property to `'off'`, then command line inputs are treated as MATLAB character vectors.

Example: `'TreatInputsAsNumeric','On'`

Data Types: `logical`

Flag to control build verbosity, specified as `'on'` or `'off'`, or as numeric or logical `1` (`true`) or `0` (`false`). A value of `'on'` is equivalent to `true`, and `'off'` is equivalent to `false`. Thus, you can use the value of this property as a logical value. The value is stored as an on/off logical value of type `matlab.lang.OnOffSwitchState`.

• If you set this property to `'on'`, then the MATLAB command window displays progress information indicating compiler output during the build process.

• If you set this property to `'off'`, then the command window does not display progress information.

Example: `'Verbose','On'`

Data Types: `logical`

## Output Arguments

collapse all

Build results, returned as a `compiler.build.Results` object. The `Results` object contains:

• Build type, which is `'standaloneApplication`

• Paths to the following files:

• `ExecutableName.exe`

• `splash.png`

• `readme.txt`

• Build options, specified as a `StandaloneApplicationOptions` object

## Limitations

• This function is only supported on Windows operating systems.

• The application does not open a Windows command shell on execution, and as a result, no console output is displayed.

## Tips

• To create a Windows standalone application from the system command prompt using this function, use the `matlab` function with the `-batch` option. For example:

`matlab -batch compiler.build.standaloneWindowsApplication('myapp.mlapp')`

Introduced in R2020b

Get trial now