Convert JS to JAR

A device or Java-based program may require a .jar package, while the available source is a JavaScript .js file. The correct solution depends on whether you only need to archive the script or need to rewrite and run it through a Java-compatible JavaScript engine.

What the JS format is

A .js file normally contains JavaScript source code used by web browsers, Node.js, Electron, Adobe applications, build systems, or Windows Script Host. JavaScript runs in an engine such as V8, SpiderMonkey, JavaScriptCore, or GraalJS.

JavaScript and Java are different languages. Changing .js to .jar, renaming the file, or placing it in a ZIP archive does not compile it into Java class files. Browser scripts may also depend on APIs such as document and window, while Node.js scripts may depend on require, npm packages, or Node-specific APIs.

What the JAR format is

A JAR, or Java ARchive, is a ZIP-based package for Java class files, libraries, resources, and metadata. Java applications and libraries use JARs because they group many files into one distributable package, support compression, and can include a manifest at META-INF/MANIFEST.MF. JARs can also be signed for integrity and publisher verification.

A JAR may contain JavaScript as an ordinary resource, but a script-only JAR is not automatically executable. A runnable JAR needs a compiled Java entry class and a manifest entry such as Main-Class; that class must then start or interpret the JavaScript.

Package the JS file in a JAR

Use the jar utility included with a JDK when the requirement is simply a JAR archive containing the original script.

1. Install a JDK such as Eclipse Temurin, Oracle JDK, or another compatible distribution; a JRE alone does not provide the normal packaging tools.
2. Put script.js and its assets in a project directory, preserving the paths referenced by the script.
3. Open a terminal in the project directory and run jar --create --file app.jar script.js. Add directories or files as needed, for example jar --create --file app.jar script.js lib config.
4. Check the archive with jar --list --file app.jar.

On older JDK versions, the equivalent command is jar cf app.jar script.js. This process preserves the JavaScript source and packages it; it does not make java -jar app.jar execute the script.

Create a runnable Java wrapper

To distribute a Java application that runs the script, create a Java project with a launcher class. The launcher loads script.js from the JAR, creates a JavaScript engine context, supplies the required arguments or host objects, and evaluates the script.

GraalJS can be embedded through the GraalVM Polyglot API and its Java dependencies. Add the required GraalVM SDK and JavaScript engine dependencies through Maven or Gradle, write the launcher, compile it, and package the launcher class, script, resources, and dependencies. GraalJS setup varies by GraalVM and dependency version, so use the dependency versions supported by the selected runtime rather than copying an obsolete Nashorn example.

Nashorn was removed from standard JDK distributions beginning with JDK 15. Code that depends on Nashorn must use a separately maintained compatibility distribution or be migrated to another engine; a current JDK does not normally supply Nashorn.

In IntelliJ IDEA, an ordinary desktop packaging option is File → Project Structure → Artifacts → JAR → From modules with dependencies. Select the launcher class as the main class, choose whether dependencies should be extracted into a fat JAR or kept beside the application, and build the artifact. A Maven or Gradle build is usually more reproducible for dependency-heavy projects. Run a correctly configured package with java -jar app.jar.

If the original file is a Node.js application, keeping it as a Node.js project is usually the technically correct option. A Java wrapper can start node as an external process, but the target system still needs Node.js and the result is not a conversion to Java bytecode.

Online and desktop options

There is no reputable online converter that reliably translates arbitrary JavaScript into equivalent Java classes or a self-contained executable JAR. Online archive tools can sometimes create a ZIP-like package, but they cannot infer a Java entry point, install a JavaScript engine, resolve npm or browser dependencies, or test runtime behavior.

For a non-sensitive single-file archive, an online ZIP creator may be usable only if the recipient accepts a plain archive and you verify its contents afterward; renaming a downloaded .zip to .jar is not a substitute for creating it with the JDK. Use the local JDK jar command, IntelliJ IDEA, Maven, or Gradle for source code and multi-file projects, and do not upload proprietary scripts to an online service.

Compatibility checks

Test the script in the exact runtime intended for the JAR. Browser globals do not exist in Node.js or GraalJS, Node.js modules do not automatically work in GraalJS, and Java host access may require explicit configuration. Confirm relative paths, file permissions, character encoding, native libraries, network access, environment variables, and all third-party dependencies.

A JAR containing only script.js is an archive. A runnable package requires a Java launcher, a compatible JavaScript engine, a valid Main-Class manifest entry, and a dependency layout that works on the target JDK.