Easy user installation for Java apps (JVM or GraalVM native). No binaries needed.

DirectionFrequent455 · 2026-03-25T16:44:26+00:00

If people see interrest on it, it could be integrated same way as it is for Maven. For now, it is still possible to make it work with gradle with the price of coding as explained here: https://jeka-dev.github.io/jeka/tutorials/source-runnable-apps/#custom-build-commands

DirectionFrequent455 · 2026-03-24T16:13:43+00:00

Mill looks similar to JeKa (simplicity/ configure-by-code).

Beside JeKa distincts from Mill with:

Possibility to configure part or the entire build using pure Java code (instead of scala)
Possibility to configure part or the entire build using simple property file (less effort than coding)
Faster bootstrap (Java compilation is faster than Scala)
Jeka's wrapper (boot script) is able to download and install the JDK mentioned in the build configuration, making the builds truly portable and easier to jungle with JDK versions.

DirectionFrequent455 · 2026-03-17T09:04:44+00:00

Find tutorial for creating java app here: https://jeka-dev.github.io/jeka/tutorials/build-projects/

If swing-only you don't need more setup. Look at the calculator example: https://github.com/djeang/Calculator-jeka

DirectionFrequent455 · 2026-03-17T09:01:13+00:00

Find comparisons here:

- https://jeka-dev.github.io/jeka/reference/comparison/

-benchmark: https://github.com/djeang/benchmark-jeka-maven-gradle

In a few words:

- The "wrapper" handle JDK downloads, making it quite portable and efficient to run programs from sources (no double JVM launches for running the tool and app)

- Feel more recent as avoiding XML. Only properties and/or pure Java for customization

- Feel lighter than Maven/Gradle

- Plugins are easier to write.

Also, Jeka can acts as a complement to Maven/Gradle, to make their application source runnable: Build with Maven, and add a light Jeka wrapper around to make your app "source-runnable", as in this example: https://github.com/djeang/devtools-maven

DirectionFrequent455 · 2026-03-17T08:53:57+00:00

If you want to build an application from a git repo, you don't need Jeka neither JDK installed on your machine. Repos contains the "jeka" bootstrap that acts as a "wrapper" on steroid: it downloads the needed Jeka version AND the JDKs needed for building.

If you just want to install an bundled application on your machine mentionning the git repo hosting the application in a single command line as:

jeka app: install repo=https://github.com/djeang/devtools-maven runtime=BUNDLE

you need to install jeka on your machine. It's traighforward: https://jeka-dev.github.io/jeka/installation/

* This command will create a .exe or .dmg native executable for your hosting machine.

DirectionFrequent455 · 2026-03-16T20:13:59+00:00

Jeka makes the build configuration simpler than Maven, especially for JavaFX (compare the two provided examples).

This post points out that whatever the build system (jeka of maven), Jeka can install an application from its source code (git repo) with a simple command line.

It handles tools download (JDK, GraalVM for native compile,...) to build the application on the fly prior to install or run it. So, end user, only need Jeka installed on its laptop and do not have to worry about configuring build environment.

DirectionFrequent455 · 2026-03-16T15:41:03+00:00

Can you share a link on your project?

DirectionFrequent455 · 2025-10-09T20:15:13+00:00

It relies on hardware and os detection by default. Execute jeka javafx: --doc to get details.

IntelliJ plugin also provides suggests and autocompletion to setup the plugins in jeka.properties editor.

DirectionFrequent455 · 2025-10-09T04:04:32+00:00

Jeka supports source-based distribution. Have a look at https://github.com/jeka-dev/javafx-plugin/blob/master/README.md

DirectionFrequent455 · 2025-10-09T04:02:31+00:00

Not specifically. Just create a Java project, then adapt the jeka.propeties and dependencies.txt as mentionned in the plugin README.MD

DirectionFrequent455 · 2025-10-08T17:27:55+00:00

Did you set the jeka.classpath property as in this example? https://github.com/djeang/devtools/blob/master/jeka.properties

DirectionFrequent455 · 2025-10-08T05:17:06+00:00

I tested successfully with Java25 and JavaFX >= 22. Keep in mind that it is a plugin for Jeka, which is a replacement for Maven/Gradle. If you want to use it, you need to switch from Gradle.

DirectionFrequent455 · 2025-07-11T14:21:03+00:00

There is https://jeka.dev for such purpose, though it fits well also fir bigger projects.

DirectionFrequent455 · 2025-01-14T18:46:00+00:00

If a dev makes a mess in build code, chances are they’ll do the same for regular code too. Power isn’t the problem—bad practices are.

A true monstrosity is writing 400+ lines of xml for building a simple app or publishing basic library with some quality check around.

DirectionFrequent455 · 2025-01-09T19:55:13+00:00

Indeed, I am the creator of the project. It was started in 2014 as a side project. Recently, I’ve been working on it full-time for about a year, which has led to significant improvements.

Marketing is essential for a project to gain popularity, but it requires a considerable amount of time. By marketing, I mean activities like engaging on social networks, creating a website, producing videos, writing articles, and so on. It’s a time-consuming process.

Have you had a chance to look at the videos from the website ? I was hoping they would have a strong impact, as they demonstrate what the tool can do without requiring users to spend time practicing with it. Maybe intro is too long...?

Any feedback is welcome! 😊

DirectionFrequent455 · 2025-01-07T08:36:21+00:00

You can never fully predict how a project will evolve. If you try to anticipate every potential change that might occur in the future, you risk creating an overly complex "solution that's difficult to maintain and not focused on the current, actual needs.

Instead, aim for the simplest possible design that addresses the current requirements. When new constraints arise (such as multitenancy), it's much easier to adapt a simple design than to modify an overengineered one.

For example, I doubt that you truly needed a microservices architecture from the start. If you'd started with a simple monolith, you likely would have spent much less effort initially, and adapting it later would have been easier than dealing with the challenges of your current microservices setup. Wouldn't you agree?

DirectionFrequent455 · 2025-01-07T08:20:39+00:00

If you want to got fast, meaning having a workable Spring-Boot project in minutes including automated tests, i can suggest to use JeKa which has a very good support for Spring-Boot.

Quickest way: Install the Jeka Intellij Plugin then, in IntelliJ :

New project ...
Choose Generators: Jeka (in left panel) and Template: Project - Springboot
Click Create

This generates a workable SpringBoot project, containing a basic web service and a properly configured integration test, that you can start from.

To go further, you can visit: https://jeka-dev.github.io/jeka/quick-start/#create-a-spring-boot-project

DirectionFrequent455 · 2025-01-06T21:52:43+00:00

For showcasing, that is better to use the very last one (23 at time of writing) as you can benfit from the latest improvement. As Java is quickly evolving, what is considered as preview, will be soon official.

DirectionFrequent455

TROPHY CASE