# compiler.build.standaloneApplication

Create a standalone application for deployment outside MATLAB

## Syntax

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

## Description

example

````compiler.build.standaloneApplication(AppFile)` creates a deployable standalone application using a MATLAB® function, class, or app specified by `AppFile`. The executable type is determined by your operating system. The generated executable does not include MATLAB Runtime or an installer.```

example

````compiler.build.standaloneApplication(AppFile,Name,Value)` creates a standalone application with additional options specified using one or more name-value arguments. Options include the executable name, help text, and icon image.```

example

````compiler.build.standaloneApplication(opts)` creates a standalone 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.standaloneApplication(___)` 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 standalone application using a function file that generates a magic square.

In MATLAB, locate the MATLAB code that you want to deploy as a standalone application. For this example, compile using the file `magicsquare.m` located in `matlabroot\extern\examples\compiler`.

`appFile = fullfile(matlabroot,'extern','examples','compiler','magicsquare.m');`

Build a standalone application using the `compiler.build.standaloneApplication` command.

`compiler.build.standaloneApplication(appFile);`

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

• `includedSupportPackages.txt` — Text file that lists all support files included in the application.

• `magicsquare.exe` or `magicsquare` — Executable file that has the `.exe` extension if compiled on a Windows® system, or no extension if compiled on Linux® or macOS systems.

• `run_magicsquare.sh` — Shell script file that sets the library path and executes the application. This file is only generated on Linux and macOS systems.

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

• `readme.txt` — Text 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.

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

To run `magicsquare` from MATLAB with the input argument `4`, navigate to the `magicsquarestandaloneApplication` folder and execute one of the following commands based on your operating system:

Operating SystemTest in MATLAB Command Window
Windows`!magicsquare 4`
macOS```system(['./run_magicsquare.sh ',matlabroot,' 4']);```
Linux`!./magicsquare 4`

The application outputs a `4`-by-`4` magic square.

``` 16 2 3 13 5 11 10 8 9 7 6 12 4 14 15 1```

To run your standalone application outside of MATLAB, see Run Standalone Application.

Create a standalone application and customize it using name-value arguments.

Write a MATLAB function that uses a subfunction to compute the diagonal components of a magic square. Save the functions to files named `mymagicdiag.m` and `mydiag.m`.

```function out = mymagicdiag(in) X = magic(in); out = mydiag(X);```
```function out = mydiag(in) out = [diag(in)]';```

Build the standalone application using `mymagicdiag.m`. Use name-value pair arguments to specify the executable name, add the `mydiag.m` function file, and interpret command line inputs as numeric doubles.

```compiler.build.standaloneApplication('mymagicdiag.m',... 'ExecutableName','MagicDiagApp',... 'AdditionalFiles','mydiag.m',... 'TreatInputsAsNumeric','On')```

The function generates the following files within a folder named `MagicDiagAppstandaloneApplication` in your current working directory:

• `includedSupportPackages.txt`

• `MagicDiagApp.exe` or `MagicDiagApp`

• `run_MagicDiagApp.sh` (only on Linux and macOS systems)

• `mccExcludedFiles.log`

• `readme.txt`

• `requiredMCRProducts.txt`

To run `MagicDiagApp` from MATLAB with the input argument `4`, navigate to the `MagicDiagAppstandaloneApplication` folder and execute one of the following commands based on your operating system:

Operating SystemTest in MATLAB Command Window
Windows`!MagicDiagApp 4`
macOS```system(['./run_MagicDiagApp.sh ',matlabroot,' 4']);```
Linux`!./MagicDiagApp 4`

The application outputs the diagonal entries of a `4`-by-`4` magic square.

` 16 11 6 1`

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

For this example, use the file `magicsquare.m` located in `matlabroot\extern\examples\compiler`.

`appFile = fullfile(matlabroot,'extern','examples','compiler','magicsquare.m');`

Create a `StandaloneApplicationOptions` object using `appFile`. Use name-value arguments to specify a common output directory, interpret command line inputs as numeric doubles, and display progress information during the build process.

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

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

`compiler.build.standaloneApplication(opts);`

To create a new standalone application using the function file `example2.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.standaloneApplication(opts);```

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

Create a standalone application and save information about the build type, generated files, included support packages, and build options to a `compiler.build.Results` object.

Compile using the file `magicsquare.m` located in `matlabroot\extern\examples\compiler`.

`results = compiler.build.standaloneApplication('magicsquare.m')`
```results = BuildType: 'standaloneApplication' Files: {2×1 cell} IncludedSupportPackages: {} Options: [1×1 compiler.build.StandaloneApplicationOptions] ```

The `Files` property contains the paths to the `magicsquare` standalone executable and `readme.txt` files.

## 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 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 `.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`

Support packages to include, specified as one of the following options:

• `'autodetect'` (default) — The dependency analysis process detects and includes the required support packages automatically.

• `'none'` — No support packages are included. Using this option can cause runtime errors.

• A string scalar, character vector, or cell array of character vectors — Only the specified support packages are included. To list installed support packages or those used by a specific file, see `compiler.codetools.deployableSupportPackages`.

.

Example: ```'SupportPackages',{'Deep Learning Toolbox Converter for TensorFlow Models','Deep Learning Toolbox Model for Places365-GoogLeNet Network'}```

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

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 compiled files

• A list of included support packages

• Build options, specified as a `StandaloneApplicationOptions` object

## Tips

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

`matlab -batch compiler.build.standaloneApplication('mymagic.m')`