General Questions

What is jDeploy?

jDeploy is a multi-modal application platform for Java developers. It allows you to deploy desktop GUI apps, CLI commands, background services, system tray helpers, and MCP servers for AI tool integration — all from a single package.json configuration. You can publish your app to the cloud using npm or GitHub releases, and jDeploy provides a download page with links to native installers for Mac, Windows, and Linux. For more information about jDeploy and its features see the jDeploy website.

Can I deploy Command-line Apps using jDeploy?

Yes. jDeploy supports two approaches for CLI distribution:

Native CLI Commands (jDeploy 6.0+)

Define CLI commands in your package.json that are installed to the user’s PATH alongside your GUI app. The installer creates platform-appropriate wrapper scripts. See the CLI Commands section of the manual for details.

npm-based CLI Distribution

Users can install your CLI app globally using the npm command-line tool. See Getting Started with jDeploy CLI edition for more information.

Can I deploy CLI commands alongside my GUI app?

Yes. In jDeploy 6.0+, you can define named CLI commands in your package.json that are installed to the user’s PATH when they install your app. Each command can have its own description and arguments. Your Java code can detect which mode it’s running in via the jdeploy.mode system property (gui or command).

{
  "jdeploy": {
    "commands": {
      "myapp-cli": {
        "description": "Run My App in command-line mode"
      }
    }
  }
}

See the CLI Commands section of the manual for details.

Can I deploy background services?

Yes. Add "implements": ["service_controller"] to any CLI command to enable service lifecycle management. Users can run commands like myapp-server service install, start, stop, status, and uninstall. The native launcher registers it as a system service (systemd on Linux, launchd on macOS, Windows Service Manager).

{
  "jdeploy": {
    "commands": {
      "myapp-server": {
        "description": "Web server for My App",
        "implements": ["service_controller"]
      }
    }
  }
}

See the Service Controllers section of the manual for details.

Can I deploy an MCP server for AI tools?

Yes. jDeploy 6.0 can register your application as a Model Context Protocol (MCP) server. During installation, jDeploy configures your MCP server in the user’s AI tool configurations (Claude Desktop, VS Code Copilot, Cursor, Windsurf, and others).

{
  "jdeploy": {
    "commands": {
      "myapp-mcp": {
        "description": "MCP server for AI integration"
      }
    },
    "ai": {
      "mcp": {
        "command": "myapp-mcp",
        "defaultEnabled": true
      }
    }
  }
}

See the AI Integrations section of the manual for details.

Does jDeploy include a system tray helper?

Yes. When your app includes background services (via service_controller), jDeploy automatically installs a system tray helper that provides service management (start, stop, view logs) and uninstallation from the tray icon.

You can add custom menu items to the system tray by configuring helper.actions. These appear alongside the built-in service controls and can open URLs, files, or custom protocol URLs to deep-link into your GUI app.

{
  "jdeploy": {
    "commands": {
      "myapp-server": {
        "description": "Web server",
        "implements": ["service_controller"]
      }
    },
    "helper": {
      "actions": [
        {
          "label": "Dashboard",
          "description": "Open the web dashboard",
          "url": "http://localhost:8080/dashboard"
        }
      ]
    }
  }
}

See the Background Helper section of the manual for details.

What is singleton mode?

When "singleton": true is set in your jdeploy config, only one instance of your GUI application runs at a time. If the user launches the app again (by double-clicking a file, clicking a custom URL, or running the launcher command), the existing window is activated and the new file or URI is forwarded to it.

This is useful when combined with custom URL schemes and background services. A service or web app running on localhost can open myapp://settings to bring the GUI to the front and navigate to a specific view, rather than spawning a duplicate instance.

For complete implementation details including code examples, see the deep linking tutorials:

What is jdeploy-desktop-lib?

jdeploy-desktop-lib is a Java library for receiving forwarded files, URIs, and activation events in singleton mode. Without this library, your app will not receive forwarded URIs or file-open events from subsequent launches.

Available for Swing (ca.weblite:jdeploy-desktop-lib-swing) and JavaFX (ca.weblite:jdeploy-desktop-lib-javafx).

For implementation examples, see the Swing and JavaFX deep linking tutorials.

Can CLI commands self-update?

Yes. Add "implements": ["updater"] to any CLI command and users can run <command> update to trigger the jDeploy auto-update mechanism.

{
  "jdeploy": {
    "commands": {
      "myapp-cli": {
        "description": "Run My App CLI",
        "implements": ["updater"]
      }
    }
  }
}

How much does jDeploy cost?

jDeploy is free and open source (Apache v2). Currently the hosting of the download page for apps is also free. If hosting/bandwidth costs get onerous, it is possible that the pricing model for the download page may change. In such a case, you can still deploy apps using jDeploy without using the download page, by generating your installers locally, and hosting them yourself.

How Big Are the Native Installer Bundles?

The installer bundle for apps deployed using jDeploy are around 3 megabytes. This is constant for all apps, since the installer bundle simply contains an installer app. Your app, and appropriate JRE/JDK is downloaded at installation time.

What versions of Java are Supported?

Java versions 8, 11, 17, and 21 are currently supported. Currently (at time of writing), jDeploy uses Azul’s Zulu distribution of OpenJDK for most target platforms, so version availability will follow its availability. For Mac OS 10.10-10.13, Adoptium’s JDK is used because Zulu’s minimum supported Mac OS version is 10.14.

Currently the default version used is "21".

What if my app requires the full JDK, not just the JRE?

If your app requires a JDK, and not just a JRE, you can specify this in the package.json file, by adding "jdk" : true in the jdeploy settings. Then the launcher will automatically download the full JDK instead of just a JRE.

Are JavaFX apps supported?

Yes. If your application requires JavaFX, you can add "javafx" : true to your package.json file to specify this. Then your app will automatically download a JRE/JDK with JavaFX at launch time, if required.

Which platforms are supported?

Mac, Windows, and Linux are supported.

Do you support ARM/M1/M2/M3/M4 Macs?

Yes. jDeploy supports both Intel and ARM Macs. The appropriate JRE/JDK is downloaded at launch time.

Do you support ARM64 Windows builds?

Yes. jDeploy supports both x86_64 and ARM64 Windows builds. The appropriate JRE/JDK is downloaded at launch time.

Do you support ARM64 Linux builds?

Yes. jDeploy supports both x86_64 and ARM64 Linux builds. The appropriate JRE/JDK is downloaded at launch time.

Is it possible to exclude certain platforms from the download page?

Yes. See the manual for details.

Can I get AI to help me set up my jDeploy configuration?

Yes. jDeploy 6.0 ships with its own MCP server, allowing AI coding agents like Claude Code to create, configure, and publish jDeploy projects directly. When you install jDeploy, the installer detects which AI tools you have installed and lets you choose which ones to integrate with.

Once connected, you can say things like "Set up jDeploy for this project with a CLI command and a background service" and the agent will analyze your project, configure the appropriate settings, and guide you through publishing.

See AI Integrations for details.

What is winAppDir?

winAppDir is a Windows-only setting that lets you install app executables into a conventional location such as %USERPROFILE%\AppData\Local\Programs instead of the default .jdeploy\apps directory. This can help avoid Windows Defender warnings about executables running from non-standard locations.

{
  "jdeploy": {
    "winAppDir": "AppData\\Local\\Programs"
  }
}

What is the difference between jDeploy and jpackage/graal native image?

jDeploy is similar to tools like jpackage and graal native image in that it produces native bundles, but it differs in several important ways:

Cross-platform

With jpackage, each format (e.g. .dmg, .exe, etc..) must be built on the platform that it runs on. I.e., you need a Windows machine to build a Windows app, a Mac to build a Mac app, etc…​. jDeploy, in contrast, can produce bundles for all platforms from any platform. You don’t need a Windows or a Mac.

Mac Code-Signing and Notarization

jDeploy apps don’t need to be signed or notarized for deployment on Mac. The installer produced by jDeploy is signed and notarized by jDeploy so you don’t need to futz with your own certificates and notarization steps. You don’t even need to have a Mac developer account - which you would need to distribute apps built by jpackage.

Windows Code-Signing

jDeploy Windows installers are signed using jDeploy’s code-signing certificate, which is recognized by all versions of Windows, so you don’t have to deal with the painful process of purchasing a certificate and setting signing your installers.

Smart JVM Downloading

jpackage bundles the entire Java Virtual machine inside the app bundle. App installers produced by jDeploy, by contrast, only include a slim native app (3mb compressed). A compatible Java Virtual Machine is downloaded automatically at run-time, but only if a compatible JVM can’t be found yet. This results in major savings for updates, and when you have multiple apps installed that use jDeploy, since the JVM only needs to be downloaded once.

Auto-Updates

jDeploy apps include a custom native launcher, written in Go and C, which downloads any available app updates before launching your app. This way you can be sure that your users are always working with the latest version of your app.

Download Page

jDeploy provides a turn-key download page for users to download your app as soon as you’ve published it. If you don’t want to use this download page, you don’t have to. You can just generate your bundles locally, and distribute them in your own way.

File-type and URL Associations

jDeploy apps can be associated with custom mimetypes, file extensions, and URL schemes easily - without having to delve into any platform-specific configuration. This feature is supported on Mac, Windows, and Linux.

Multi-Modal Deployment

jDeploy 6.0 supports deploying CLI commands, background services, system tray helpers, and MCP servers alongside your GUI app — all from a single package. This is not possible with jpackage or graal native image.

Not for the Appstore

Because jDeploy includes its own auto-update and JVM management features, the apps produced aren’t appropriate for distribution in the Mac App store. If you are looking to distribute your app in the Mac Appstore, you should use a solution like jpackage.

Can I self-host my app instead of using npm?

Yes. jDeploy supports GitHub hosting as well. See the developer guide for details on how to publish your application as GitHub releases.

Can I publish my bundles in my GitHub Release?

Yes. See the developer guide for details on how to publish your application as GitHub releases.

Can I use a private npm registry?

Currently only the main public npm registry is supported. I may add support for private registries if there is demand. If this is important to you, please let me know, either in the support forum, the issue tracker, or directly via email.

As an alternative, you might want to consider See hosting on GitHub, which doesn’t use npm at all.

Is there jDeploy Plugin for My IDE?

Check out the jDeploy IntelliJ Plugin, which provides a project wizard with plug-and-play templates for Codename One, Swing, and JavaFX, that automatically deploys your application using GitHub actions.

Mac Questions

Do I need a Mac to deploy a native Mac App?

No. You can deploy for all platforms (Mac, Windows, and Linux) from any of jDeploy’s supported platforms (Mac, Windows, and Linux).

Do I need an Apple Developer Account to Distribute My App on Mac OS?

No. You don’t require an Apple Developer account to distribute your app on Mac OS.

Do I need to Sign or Notarize My App for Mac OS?

No. The jDeploy installer is signed and notarized so that users will be able to download and install your app without the dreaded "This app appears to have been tampered with warnings". You don’t need to worry about signing or notarizing your app. Just publish it via jdeploy publish and your users can download and install your app via your app’s download page on jdeploy.com.

What versions of Mac are Supported?

Mac 10.10 and higher are supported, including the latest macOS versions.

Will My App Be Accepted by the Mac App Store

No. Apps submitted to the Mac appstore must bundle all components (e.g. JRE) as part of the app bundle, and be able to run inside the Mac sandbox. jDeploy apps bundle only the bare minimum required to launch your app, and required components such as a JRE and app updates are downloaded at runtime. This would not be possible in the Mac app store.

One of the benefits of the jDeploy approach is that your apps are only a couple of megabytes (multiple applications can share the same JRE), vs a full app-store bundle that may tip 150MB.

If you want to build native Mac apps for the purpose of distributing in the Mac app store you should use an alternative solution such as jpackage.

Other Questions

If you think of other questions, please post them in the Support forum.