Gluon Client Plugin

This goal performs AOT compilation by executing the native-image command and builds the shared object file. It is a very intensive and lengthy task (several minutes, depending on your project and CPU), so it should be called only when the project is ready and runs fine on a VM.

The results will be available at target/client/$arch-$os/gvm.

Links the object file to create a native executable file or shared library.

The results will be available at target/client/$arch-$os/$AppName.

This goal simply combines client:compile and client:link.

Packages the executable or shared library into a target specific package that includes all the necessary dependencies.

The list of platform specific packages are as follows:

Installs the package on the host system or attached device.

Runs either the executable generated by client:link on the host system or runs the application that was installed on the device (iOS or Android).

Let’s run HelloWorld with the Gluon Client plugin for Maven.

Now let’s run HelloFX, a simple JavaFX application.

Run the application to make sure everything works with Java 11:

A string that defines the target platform. The default is host, which refers to the platform that currently hosts the process. It can be set also to ios to create native images for iOS devices (Aarch64), or android to create native images for Android devices (Aarch64).

Default: host

List of fully qualified resource bundles that will be added to the default list of resource bundles. By default, the list already includes the JavaFX bundles, like:

For more advanced usage, read the Resource bundles section.

List of additional resource patterns or extensions that will be added to the default resource list that already includes:

We keep adding extensions to this list. Please check the source code for the latest list.

For more advanced usage, read the Resources section.

List of additional full qualified classes that will be added to the default reflection list, that already includes most of the JavaFX classes.

Note: The current list is added to a file that can be found under target/client/$arch-$os/gvm/reflectionconfig-$arch-$os.json.

For more advanced usage, read the JNI and Reflection section.

List of additional full qualified classes that will be added to the default jni list, that already includes most of the JavaFX classes.

Note: The current list is added to a file that can be found under target/client/$arch-$os/gvm/jniconfig-$arch-$os.json.

For more advanced usage, read the JNI and Reflection section.

If you want to include Gluon Attach services to your project, you can use attachList to including the name of the services, like:

By default the attachVersion is 4.0.9.

After saving the changes, the dependencies for the defined services will be resolved to include those for defined target, and when the native compile goal is executed, the native services implementations will be added to the reflection and JNI lists.

Note: Attach platform implementations will be added only to the goals of the Client plugin, but not to the JavaFX plugin. It is convenient to use Maven profiles to overcome this issue.

List of additional arguments that will be added to the native image creation.

Set to true will generate a more verbose output to the console, useful when having errors, to identify possible issues.

Also, you can get a more verbose output for these goals running with -X:

Default: false

Note: Regardless the verbose value, the full logs can be found under target/client/$arch-$os/gmv/log.

Path to GraalVM installation directory. This is only required when GRAALVM_HOME is not set.

Since: 0.1.3

The version of the Java static libraries. These will be located under: ~/.gluon/substrate/javaStaticSdk/$javaStaticSdkVersion/$target-$arch/labs-staticjdk/lib.

Default: 11_ea+1

The version of the JavaFX SDK and its static libraries. These will be located under: ~/.gluon/substrate/javafxStaticSdk/$javaStaticSdkVersion/$target-$arch/sdk/lib.

Default: 15_ea+gvm22

JavaFX applications can use software rendering when the graphics hardware on a system is insufficient to support hardware accelerated rendering. To enable software rendering set the enableSWRendering parameter to true in plugin configuration.

Note: Enabling software rendering will result in a longer compile time and larger native image.

Default: false

Since: 0.1.14

For every class that is defined in jniList or reflectionList, it is included in the configuration files target/client/$arch-$os/gvm/jniconfig-$arch-$os.json and target/client/$arch-$os/gvm/reflectionconfig-$arch-$os.json respectively, with a definition like the following:

This has an impact on both compilation time and memory footprint, because all methods and fields are opened. Ideally, it is better to open only the minimal list of fields and methods that are required for your application to run.

You can create the following files:

The files must contain the fully qualified name of classes, together with some attributes (like allDeclaredFields), methods and/or fields that will be invoked via reflection and that are not already part of the list.

For instance, the configuration below only adds the method named valueOf of the MaterialDesignIcon class to the final reflection configuration:

For more information, see Reflection use in Native Images.

The resourcesList configuration option can also be defined in a configuration file:

For more information, see Accessing resources in Native Images.

For instance, the configuration below includes a pattern to load all *.txt files found:

The bundlesList configuration option can also be defined in a configuration file:

For instance, below are the fully qualified name of two given resource bundles that will be included:

If you need to set a class or list of classed to be initialized at build time, you can add their fully qualified name to the following configuration files:

This can be especially convenient for enums that have a large list of values.

For more information, see Class initialization in Native Image.

Open Xcode and go to File → New → Project…​, and select a simple template for iOS, like Single View App.

Go to the Developer portal, and access Certificates, Identifiers & Profiles. Select Certificates from the left, and press +, to create a Development certificate (for testing). Later on you will need a Distribution certificate for distribution through the App Store.

To generate a certificate, you need a Certificate Signing Request (CSR) file from your Mac.

Go to the Developer portal, and access Certificates, Identifiers & Profiles. Select Identifiers from the left, and press +, to create a new app identifier.

You can enable app services when you create the App ID or modify these settings later on.

Provide a name and make sure you use the exact Bundle ID from your app, the one listed in your Default-Info.plist file under the CFBundleIdentifier key.

Alternatively, you can use a wildcard that will let you use a single App ID to match multiple apps. It is recommended to use your domain name, to filter out other apps.

Select any of the required services (if you are using an explicit Bundle ID), and click continue to create the App ID.

To create a provisioning profile for development, the devices that are allowed to run the application have to be identified.

To add your testing devices, you need to provide their UDID.It can be found from Xcode → Window → Devices and Simulators. Plug your device, select it from Connected devices, and then select its identifier and copy it.

Go to the Developer portal, and access Certificates, Identifiers & Profiles. Select Devices from the left, and press +, to add a new device.

Add a name and paste the devices’s identifier.

Go to the Developer portal, and access Certificates, Identifiers & Profiles. Select Profiles from the left, and press +, to add a new provisioning profile.

To add a Development profile (later on you will need a Distribution one), select iOS App Development, and press continue.

From the drop down list, select a valid App ID:

Press continue and select one or more certificates that should be included in this provisioning profile.

Press continue and select one or more devices that should be include in this provisioning profile.

Press continue and finally, give a name to the provisioning profile, it will be used to identify the profile in the portal. Then press Generate.

When finished, download it and install it by double clicking on the file.

You can get it from here, or you can directly install it from IntelliJ IDEA: click File→Settings…​ (or IntelliJ IDEA→Preferences…​) and select Plugins on the left. You will see the installed plugins on your system.

Now click Marketplace, type Gluon, select the result and click Install.

The Gluon Plugin will be downloaded and installed. Then press Restart IDE or simply press OK to close the plugins dialog, and restart the IDE when asked.

Once the plugin is installed, we can use it to create a sample application.

In IntelliJ IDEA, click File → New → Project…​ and select Gluon on the left, and one of the available projects on the right. For instance, Gluon Mobile - Single View Project. Press Next.

The first time you use the plugin, you will be asked to enter your email address.

If you already have a Gluon Mobile key for your projects, you can insert it here as well, so it will be added by default to your new projects. If you don’t, you will be using the free (trial) version. Please find more about Gluon Mobile licenses.

You can access these settings later on from File→Settings→Gluon (or IntelliJ IDEA→Preferences…​→Gluon):

Once you have completed this first-time-only form, click Next.

Type the package name and the main class name. Select the platforms to deploy the application, and the build tool of your choice. For this tutorial, we will use the Maven build tool. Press Next.

From the list, select a valid Java JDK (11+) and press Next.

Now add a name and a location for the project and press Finish.

The project will be imported and opened.

The plugin already adds some default code in the main folder, so we’ll be able to run it without adding a single line of code.

The Maven project has a dependency on the OpenJFX Maven Plugin and the Gluon Client Maven plugin to the project.

These plugins add a series of goals and to access them we just need to open Maven tool window in IntelliJ IDEA. The Maven tool window shows all the available Maven plugins along with their respective goals.

Before creating a native image, it’s easier to run the application first and verify that there are no errors.

Select Plugins → javafx → javafx:run from the Maven tool window. Verify that all the tasks are executed without errors, and the project runs fine on your desktop. Alternatively you can open the terminal (View→Tool Windows→Terminal) and run mvn javafx:run.

Now let’s make a slight change to the code. In the BasicView class, update the text of the label on line 20 to the following:

Run it again to see that the new message shows up on your desktop when you click the button.

In order to run the native image steps it is better to use a system terminal or the embedded terminal from your IDE. However, it is still possible to use the IDE’s Maven window for this.

The Gluon Client plugin provides us various goals which are explained in detail earlier in the documentation. For this tutorial, we will be using the client:build goal to create a native image of the application.

Execute mvn client:build from the terminal, or, select Plugins → client → client:build goal from the Maven tool window.

This goal typically takes a couple of minutes to complete and may vary depending on the system. Once the goal is executed successfully, the native image can be run by executing client:run goal.

Now we are ready to deploy the same application on an Android device.

Go to Maven tool window, expand Profiles and check android. Make sure that all other profiles are unchecked. This will activate the pre-existing android profile.

Run mvn -Pandroid client:build from the terminal, or alternatively, execute the client:build goal from the Maven plugins section.

Once the native image is created, we need to package it into an apk before we can install it on a physical Android device.

Execute mvn -Pandroid client:package to create an apk. Once the goal is executed successfully, connect a physical device and install the native image by executing the mvn -Pandroid client:install goal.

When the installation ends successfully, run mvn -Pandroid client:run or find the application on your device and open it up:

Now we are ready for deploying the same application on an iOS device.

Go to Maven tool window, expand Profiles and check ios. Make sure that all other profiles are unchecked. This will activate the pre-existing ios profile. All client goals will now target iOS platform.

Run mvn -Pios client:build from the terminal, or alternatively, execute the client:build goal from the Maven plugins section.

Once the goal is executed successfully, connect a physical device and run the native image on it by executing by executing mvn -Pios client:run.

If you have made it here without problems, congratulations!

If you have found any difficulties along the way, please review the lists of prerequisites and try again. In case you have any questions, your first stop should be the Gluon support page, where you can access the latest documentation. Gluon also recommends the community to support each other over at the Gluon StackOverflow page. Finally, Gluon offers commercial support as well, to kick start your projects.

We encourage you to start developing new projects and creative native images that can be targeted for desktop, Android and iOS devices using the Gluon plugin on your favorite IDE. :imagesdir: images/ide

You can get it from the Apache NetBeans plugin portal, or you can directly install it from NetBeans: click Tools → Plugins. Now select Available Plugins…​ and find Gluon Plugin.

Select the plugin, click Install and follow the steps:

Accept the license and click Install. Click Continue when prompted:

Wait until the Gluon Plugin is installed and click Finish.

You will find the plugin under the Installed tab in the Plugins window.

Once the plugin is installed, we can use it to create a sample application.

In NetBeans, click File → New → Project…​ and select Gluon on the left, and one of the available projects on the right. For instance, Gluon Mobile - Single View Project. Press Next.

The first time you use the plugin, you will be asked to enter your email address.

If you already have a Gluon Mobile license key for your projects, you can insert them here as well, so they will be added by default to your new projects. If you don’t, you will be using the free (trial) version. Please find more about Gluon Mobile licenses.

You can access these settings later on from Tools→Options→Miscellaneous→Gluon (or NetBeans→Preferences…​→Miscellaneous→Gluon):

Once you have completed this first-time-only form, click Next.

Type the name of the project, find a proper location, add the package name and change the main class name if required. Select the platforms to deploy the application, and the build tool of your choice. For this tutorial, we will use the Maven build tool.

Press Finish and the project will be created and opened.

You will notice that a Maven project has been created with the pom containing profiles for the platforms you selected. These profiles make it easier to create native images targeted to each of these platforms.

The plugin already adds some default code in the main folders, so we’ll be able to run it without adding a single line of code.

The Maven project has a dependency on the OpenJFX Maven Plugin and the Gluon Client Maven plugin to the project.

These plugins add a series of goals and to access them we just need to switch to the Navigator panel in NetBeans. The Navigator panel shows all the available Maven goals.

Before creating a native image, it’s easier to run the application first and verify that there are no errors.

Select Run project (F6) or select javafx:run from the Navigator. Verify that all the tasks are executed without errors, and the project runs fine on your desktop. Alternatively you can open the terminal (Tools→Open in Terminal) and run mvn javafx:run.

Let’s make a slight change to the code. In the BasicView class, update the text of the label on line 21 to the following:

Run it again to see that the new message shows up on your desktop when you click the button.

In order to run the native image steps it is better to use a system terminal or the embedded terminal from your IDE. However, it is still possible to use the IDE’s Navigator window for this.

The Gluon Client plugin provides us various goals which are explained in details, earlier in the documentation. For this tutorial, we will be using the client:build goal to create a native image of the application.

Execute mvn client:build from the terminal, or, run the client:build goal from the Navigator with modifiers, and add Env.GRAALVM_HOME=/path/to/GraalVM.

This goal typically takes a couple of minutes to complete and may vary depending on the system. Once the goal is executed successfully, the native image can be run by executing client:run goal.

Now we are ready for deploying the same application on an Android device.

Right-click on the project and select Set Configuration and select android. This will activate the pre-existing android profile.

Run mvn -Pandroid client:build from the terminal, or alternatively, execute the client:build goal from the Navigator with modifiers, adding profile android, and Env.GRAALVM_HOME=/path/to/GraalVM.

Once the native image is created, we need to package it into an apk before we can install it on a physical Android device.

Execute mvn -Pandroid client:package to create an apk. Once the goal is executed successfully, connect a physical device and install the native image by executing the mvn -Pandroid client:install goal.

When the installation ends successfully, run mvn -Pandroid client:run or find the application on your device and open it up:

Now we are ready for deploying the same application on an iOS device.

Right-click on the project and select Set Configuration and select ios. This will activate the pre-existing ios profile.

Run mvn -Pios client:build from the terminal, or alternatively, execute the client:build goal from the Navigator with modifiers, adding profile ios, and Env.GRAALVM_HOME=/path/to/GraalVM.

Once the goal is executed successfully, connect a physical device and run the native image on it by executing by executing mvn -Pios client:run.

If you have made it here without problems, congratulations!

If you have found any difficulties along the way, please review the lists of prerequisites and try again. In case you have any questions, your first stop should be the Gluon support page, where you can access the latest documentation. Gluon also recommends the community to support each other over at the Gluon StackOverflow page. Finally, Gluon offers commercial support as well, to kick start your projects.

We encourage you to start developing new projects and creative native images that can be targeted for desktop, Android and iOS devices using the Gluon plugin on your favorite IDE. :imagesdir: images/ide

Now that the plugin is installed, we can use it to create a sample application.

In Eclipse, click File → New → Project… and select one of the available projects under the Gluon category, for instance, Gluon Mobile - Single View Project and click Next.

The first time you use the plugin, you will be asked to enter your email address.

If you already have a Gluon Mobile license key for your projects, you can insert them here as well, so they will be added by default to your new projects. If you don’t, you will be using the free (trial) version. Please find more about Gluon Mobile licenses.

You can access these settings later on from Window→Preferences→Gluon (or Eclipse→Preferences…​→Gluon):

Once you have completed this first-time-only form, click Next.

Provide a name for the project, optionally choose a custom location to store the project and click Next.

The plugin will generate a JavaFX application class. In the following step you can configure the name of the package and the name of the class that will be generated. Select the platforms to deploy the application, and the build tool of your choice. For this tutorial, we will use the Maven build tool.

Click Finish to complete the creation of the Gluon project.

You will notice that a Maven project has been created with the pom containing profiles for the platforms you selected. These profiles make it easier to create native images targeted to each of these platforms.

The plugin already adds some default code in the main folders, so we’ll be able to run it without adding a single line of code.

The Maven project has a dependency on the OpenJFX Maven Plugin and the Gluon Client Maven plugin to the project. These plugins add a series of goals which will be used to run and create native images of the application.

Before creating a native image, it’s easier to run the application first and verify that there are no errors.

Right-click on the project, select Run As → Maven Build…​. An "Edit Configuration" window opens. In the Goals textfield, type javafx:run and click Run. Verify that all the tasks are executed without errors, and the project runs fine on your desktop.

Let’s make a slight change to the code. In the BasicView class, update the text of the label on line 20 to the following:

Run the application again to verify that the text inside the label has changed.

In order to run the native image steps it is better to use a system terminal or the embedded terminal from your IDE. However, it is still possible to use the IDE’s Run Configurations dialog for this.

The Gluon Client plugin provides us various goals which are explained in details, earlier in the documentation. For this tutorial, we will be using the client:build goal to create a native image of the application.

Execute mvn client:build from the terminal, or, open the Run Configurations…​ window and update the Goal to client:build and click Run.

This goal typically takes a couple of minutes to complete and may vary depending on the system. Once the goal is executed successfully, the native image can be run by executing client:run goal.

Now we are ready for deploying the same application on an Android device.

Right-click on the project and open Maven → Select Maven Profiles…​ window. Check android checkbox and uncheck all others. This will activate the pre-existing android profile. All the client goals will now target android platform instead of desktop.

Run mvn -Pandroid client:build from the terminal, or alternatively, execute the client:build goal again, this time the android profile should be selected by default, else add it to the profiles field.

Once the native image is created, we need to package it into an apk before we can install it on a physical Android device.

Execute mvn -Pandroid client:package goal to create an apk. Once the goal is executed successfully, connect a physical device and install the native image by executing client:install goal.

Once the goal is executed successfully, connect a physical device and install the native image by executing the mvn -Pandroid client:install goal.

When the installation ends successfully, run mvn -Pandroid client:run or find the application on your device and open it up:

Now we are ready for deploying the same application on an iOS device.

Right-click on the project and open Maven → Select Maven Profiles…​ window. Check ios checkbox and uncheck all others. This will activate the pre-existing ios profile. All client goals will now target iOS platform.

Run mvn -Pios client:build from the terminal, or alternatively, execute the client:build goal again, this time the ios profile should be selected by default, else add it to the profiles field.

Once the goal is executed successfully, connect a physical device and run the native image on it by executing mvn -Pios client:run.

If you have made it here without problems, congratulations!

If you have found any difficulties along the way, please review the lists of prerequisites and try again. In case you have any questions, your first stop should be the Gluon support page, where you can access the latest documentation. Gluon also recommends the community to support each other over at the Gluon StackOverflow page. Finally, Gluon offers commercial support as well, to kick start your projects.

We encourage you to start developing new projects and creative native images that can be targeted for desktop, Android and iOS devices using the Gluon plugin on your favorite IDE.