DukeScript

Archetypes Release

Fri, 27 Jun 2025 05:52:17 +0000

DukeScript Maven Archetypes 0.41 Released!

We’re excited to announce the release of DukeScript Maven Archetypes version 0.41! This release brings improvements and updates to help you quickly bootstrap your cross-platform Java applications.

What is DukeScript?

DukeScript is a technology that allows you to write applications in Java and HTML5 that run everywhere - on desktop (Windows, Mac, Linux), mobile (iOS, Android), and in the browser. Write once, run anywhere has never been more real!

What’s New in 0.41?

This release includes:

Updated dependencies to the latest stable versions
Improved project templates for faster development starts
Better integration with modern IDEs
Enhanced documentation and examples
Bug fixes and performance improvements

Getting Started

To create a new DukeScript project using the Maven archetypes, simply run:

    mvn archetype:generate \
      -DarchetypeGroupId=com.dukescript.archetype \
      -DarchetypeArtifactId=knockout4j-archetype \
      -DarchetypeVersion=0.41

Maven will prompt you for:

groupId: Your organization’s ID (e.g., com.yourcompany)
artifactId: Your project name
version: Your project version (default: 1.0-SNAPSHOT)
package: Base package for your Java classes

Available Archetypes

1. knockout4j-archetype

The standard archetype for creating DukeScript applications:

    mvn archetype:generate \
      -DarchetypeGroupId=com.dukescript.archetype \
      -DarchetypeArtifactId=knockout4j-archetype \
      -DarchetypeVersion=0.41

2. crud4j-archetype

For creating CRUD (Create, Read, Update, Delete) applications:

    mvn archetype:generate \
      -DarchetypeGroupId=com.dukescript.archetype \
      -DarchetypeArtifactId=crud4j-archetype \
      -DarchetypeVersion=0.41

3. visual-archetype

For applications with rich visual components:

    mvn archetype:generate \
      -DarchetypeGroupId=com.dukescript.archetype \
      -DarchetypeArtifactId=visual-archetype \
      -DarchetypeVersion=0.41

Building and Running Your Project

After creating your project, navigate to the project directory and run:

    cd your-project-name
    mvn clean install
    mvn -f client/pom.xml process-classes exec:exec

This will compile your project and launch it in the default desktop browser view.

Multi-Platform Deployment

To build for different platforms:

Desktop (JavaFX)

    mvn -f client-javafx/pom.xml clean package

Web Browser

    mvn -f client-web/pom.xml clean package
``
### Android
```bash
    mvn -f client-android/pom.xml clean package

iOS

mvn -f client-ios/pom.xml clean package

Example: Quick Hello World

Here’s a simple example of what your main view model might look like:

    package com.example;

    import net.java.html.json.Model;
    import net.java.html.json.Property;

    @Model(className = "HelloWorld", targetId = "", properties = {
        @Property(name = "message", type = String.class)
    })
    public class HelloWorldModel {
        
        public static void onPageLoad() {
            HelloWorld model = new HelloWorld("Hello from DukeScript 0.41!");
            model.applyBindings();
        }
    }
``
And the corresponding HTML:
````html
    <!DOCTYPE html>
    <html>
    <head>
        <title>DukeScript Hello World</title>
        <meta charset="UTF-8">
    </head>
    <body>
        <h1 data-bind="text: message"></h1>
    </body>
    </html>

Resources and Support

Documentation: https://dukescript.com/documentation/
GitHub: https://github.com/dukescript
Community Forum: https://dukescript.com/forum/
Examples: https://github.com/dukescript/dukescript-demos

Migration from Previous Versions

If you’re upgrading from an earlier version, update your parent POM version:

<parent>
    <groupId>com.dukescript</groupId>
    <artifactId>maven-parent</artifactId>
    <version>0.41</version>
</parent>

Conclusion

DukeScript Maven Archetypes 0.41 makes it easier than ever to create cross-platform Java applications. Whether you’re building enterprise applications, mobile apps, or web services, DukeScript provides the tools you need to write once and deploy everywhere.

Happy coding with DukeScript!

Have questions or feedback? Join our community forum or file issues on GitHub. We’d love to hear about what you’re building with DukeScript!

Apache NetBeans 12.0 and 0.33 Archetypes

Sat, 20 Jun 2020 05:52:17 +0000

Apache NetBeans 12.0 has been released including improved Maven archetypes with better dependencies. Rather than using “external” wrappers around HTML/Java API, artifacts like

<dependency>
  <groupId>org.netbeans.html</groupId>
  <artifactId>boot</artifactId>
  <version>1.7</version>
  <scope>compile</scope>
</dependency>

are used directly. Excellent simplification!

As a result the DukeScript Archetypes 0.33 could be greatly simplified. The pom.xml for the “package as NetBeans” subproject uses NetBeans bits from RELEASE120-1 and no longer needs to specify huge exclusion sections.

Today’s thanks go to the NetBeans team for improving their Maven artifact dependencies! Don’t forget to give the 0.33 Archetypes a try - without or with NetBeans!

RoboVM Presenter Update in 0.32 Archetypes

Tue, 10 Mar 2020 23:11:42 +0000

Just a quick note. The RoboVM iOS presenter version 1.7 Maven artifact had wrong dependencies. It missed dependency on org.netbeans.html:generic:1.7 artifact.

As a result the 0.31 archetypes were broken - DukeScript application wasn’t able to launch with RoboVM. One could always fix the missing dependency manually:

<dependency>
  <groupId>org.netbeans.html</groupId>
  <artifactId>generic</artifactId>
  <version>1.7</version>
  <scope>compile</scope>
</dependency>

Yet there is no longer need for patching theclient-ios/pom.xml by hand. The RoboVM iOS presenter version 1.7.1 is out. Use it instead of 1.7 version.

There are also 0.32 Maven archetypes using it. Newly generated applications are going to be correct. Enjoy and talkback if something else isn’t working for you when using DukeScript!

Using AAR dependencies in API library projects

Sat, 07 Mar 2020 05:36:57 +0000

Android uses the AAR format for distributing libraries. By default Maven cannot handle this format as a dependency type. Fortunately the android-maven-plugin adds some support. If you use this library you can declare dependencies like this:

        <dependency>
            <groupId>com.obt</groupId>
            <artifactId>sdk</artifactId>
            <version>1.0.3</version>
            <type>aar</type>
        </dependency>

This works fine with some restrictions as long as your projects packaging is either AAR or APK. It doesn’t work, when developing a cross platform API. These APIs are usually packaged as a single JAR, that contains the implementations for all platforms, so there’s no AAR support at all. The solution to this is to add an extra Maven module to your project, which unpacks an AAR dependency and deploys the classes.jar to your local repository. Here’s an example, where we take an AAR dependecy (org.apache.cordova:framework:8.1.0) and redeploy it:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.dukescript.api</groupId>
        <artifactId>bluetooth</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>deploy-cordova-platform</artifactId>
    <packaging>aar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <build>
        <plugins>
            <plugin>
                <groupId>com.simpligility.maven.plugins</groupId>
                <artifactId>android-maven-plugin</artifactId>
                <version>4.6.0</version> 
                <extensions>true</extensions>
                <executions>
                    <execution>
                        <id>unpack-dependecy</id>
                        <phase>package</phase>
                        <goals>
                            <goal>unpack</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <!-- install  the jar -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-install-plugin</artifactId>
                <version>2.5.2</version>
                <executions>
                    <execution>
                        <id>cordova</id>
                        <phase>package</phase>
                        <goals>
                            <goal>install-file</goal>
                        </goals>
                        <configuration>                  
                            <file>target/unpacked-libs/oac_framework_8.1.0/classes.jar</file>
                            <groupId>org.apache.cordova</groupId>
                            <artifactId>framework</artifactId>
                            <version>8.1.0</version>
                            <packaging>jar</packaging>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    <dependencies>        
        <dependency>
            <groupId>org.apache.cordova</groupId>
            <artifactId>framework</artifactId>
            <version>8.1.0</version>
            <type>aar</type>
        </dependency>
    </dependencies>
</project>

The android-maven-plugin provides support for unpacking the AAR, while the “maven-install-plugin” is used to deploy it to th local repo. In our API library, we set a dependency on this project to establish the build order. After that we can use the dependecy from the local repository with no extra hacks.

Admittedly this is not perfect, because we’re ignoring the extra resources that might be packaged in the AAR. But for most dependencies it works just fine as a quick solution. An extra bonus is, that dependencies redeployed as JARS are recognized by IDEs like NetBeans, so you get full code completion and no extra error marks due to “missing” dependencies.

Enjoy writing APIs with DukeScript!

Appium Integration Tests for Android

Sun, 01 Mar 2020 09:57:13 +0000

One of our customers is using DukeScript for controlling iot devices via Bluetooth Low Energy. This works great, but it needs to be tested on multiple real devices. Emulators won’t be sufficient here, because they can’t use Bluetooth.

Appium

The most popular tool for integration testing on mobile devides is Appium. So in this project, we’re using Appium to run our integration tests on iOS and Android devices. Since we thought that might be of interest to many of our users, we created a demo project to document the important steps:

https://github.com/dukescript/appium-demo

Appium Cloud

As you’ll notice when you’re trying to install it first, Appium is a beast with it’s many dependencies. Fortunately there’s several vendors who offer to run your tests in the cloud. So, if you don’t need to interact with real bluettoth devices, an easy way to get your app tested on many different devices is to use one of these “Appium Compatible Clouds”:

… and hundreds more

Using Gradle for Android

Sat, 08 Feb 2020 11:57:13 +0000

Here at Dukehoff we’re big fans of Maven, and for typical DukeScript applications it works just fine. But using Android specific libraries can be painful, because Google provides dependencies via the SDK instead of a repository. Also, if you’d like to use Android Studio for managing Icons, etc. it’s easier with Gradle.

Therefore we created a little demo to get you started, where the Android Module uses Gradle:

https://github.com/dukescript/gradle-android.git

Make sure to build the project with maven first, so all the dependencies are present. Then you can open the project in Android Studio and use all the nice Android specific features to develop your app, add assets, etc.

Using Apache Presenters in 0.31 Archetypes

Mon, 20 Jan 2020 11:57:13 +0000

Version 0.31 of DukeScript Maven Archetypes is using the latest presenters that have been donated to Apache in October 2019. Generate your new (or update existing) projects according to the 0.31 skeleton to benefit from the Apache and DukeHoff co-operation!

The presenters are now part of Apache NetBeans HTML/Java API 1.7 as following packages:

org.netbeans.html.presenters.spi - Includes the prototypical presenter based on textual protocol between JavaScript VM and Java VM.
org.netbeans.html.presenters.render - Can show a browser component.
org.netbeans.html.presenters.browser - Includes generic browser presenter.
org.netbeans.html.presenters.webkit - Provides native WebKitPresenter for smooth integration with Linux and Mac OS X.

All the archetypes are now relying the prototypical presenter either directly via Apache browser and webkit presenters or via iOS and Android presenters which have also been updated to rely on Apache NetBeans HTML/Java API 1.7.

Simply get started via the command line or via Apache NetBeans IDE 11.x as the getting started tutorial shows:

$ mvn archetype:generate \
	-DarchetypeGroupId=com.dukescript.archetype \
	-DarchetypeArtifactId=knockout4j-archetype \
	-DarchetypeVersion=0.31

It is easy to get started with DukeScript and write truly portable applications in Java! Benefit from the support of the great Apache community!

Dukehoff donates core DukeScript presenters to Apache NetBeans

Thu, 31 Oct 2019 10:41:55 +0000

(Munich) On October 11th 2019, Dukehoff GmbH has signed the Apache Corporate Contributor License Agreement for a Software Grant to donate the DukeScript base presenters to Apache NetBeans.

The Apache NetBeans Java/HTMLAPI allows developers to write applications in Java with an HTML-based user interface. These applications can be deployed to any platforms where a presenter is available.

The presenters provide the glue between Java and JavaScript code in such an application. They make sure that Java methods with JavaScriptBody annotation can properly pass their parameters to the JavaScript engine and receive results back. Apache NetBeans solely provides implementations for deployment on desktop via the JavaFX WebView and for static web pages through bck2brwsr.

Since 2015 Dukehoff GmbH has been providing additional presenters for iOS and Android Apps, JXBrowser and to multiple different desktop browsers as part of the DukeScript project.

These commercial quality presenters are based on a common set of libraries which implement common generic tasks and make it easy to create new implementations. With this software grant Dukehoff GmbH donates the following libraries and presenters to Apache NetBeans:

render - a way to start a browser - using native GTK (on Linux and Mac OS X), AWT or CLI
generic - ProtoPresenterBuilder & co. - core implementation of a presenter that handles connection between JavaScript VM and Java VM via a textual protocol - very portable
browser - uses of ProtoPresenterBuilder to start a local server and let a browser connect to it
webkit - native presenter for Linux and Mac OS X that uses WebKit via JNA

The donation has been officially accepted by the Apache community.

Archetypes 0.30 Support NetBeans on JDK 11

Sat, 19 Oct 2019 10:41:55 +0000

New archetypes version 0.30 are out. They fix NETBEANS-3185 - e.g. one can create a DukeScript Maven project and bundle it as NetBeans application and run it on JDK11.

Thanks to Eric Barboni for releasing the necessary Maven plugins.

Classpath Exception for the Presenters

Tue, 13 Aug 2019 19:27:39 +0000

The presenters for iOS as well as Android are (even more) free now! Since version 1.6 we are changing the license of the presenters to GPLv2 with Classpath Exception - e.g. the same license the Java core libraries are using. That means more freedom for the users of these presenters. The viral nature of pure GPLv2 is gone. Use the presenters to build any applications - open source as well as commercial - it is easy to get started:

$ mvn archetype:generate
       -DarchetypeGroupId=com.dukescript.archetype
       -DarchetypeArtifactId=knockout4j-archetype
       -DarchetypeVersion=0.29

Of course you can choose from crud4j-archetype, knockout4j-archetype and visual-archetype as usual - more at getting started page.

So the presenters, as well as associated infrastructure are free for use. Just, in case you fix something in the presenters code itself, obey their GPLv2 license. Btw. a final teaser - the infrastructure (e.g. generic presenter & co.) is under consideration to be donated to Apache NetBeans project sometime in the (near) future.

Time to enjoy the freedom of HTML5 and Java!