Is JPlus likely to become a mainstream JVM language as a Java superset?

[nieuwmijnleven]

Select Topic Area

Question

Body

I’m currently working on a project called JPlus (GitHub: https://github.com/nieuwmijnleven/JPlus
) —a modern programming language that runs on the JVM and is designed as a superset of Java.

The goal is to maintain full compatibility with Java (allowing existing Java code to run unchanged), while adding modern features like null safety, type inference, data classes/immutables, higher‑order functions, pattern matching, async/await style syntax, and a new apply syntax to reduce boilerplate (see the demo of the IntelliJ plugin here: https://www.youtube.com/watch?v=0z_aIyBpJso
).

Here’s a quick summary of what JPlus offers:

• Full Java compatibility — existing Java libraries and frameworks work without modification.

• Null safety at the language level (nullable types, safe‑access operator etc.).

• Type inference, lambda/higher‑order functions, pattern matching.

• Boilerplate elimination via an apply syntax (for things like data classes, builders, constructors).

• Gradual adoption model — you can keep using plain Java, and selectively adopt JPlus features.

• Compilation to plain Java code, so you run on the JVM and benefit from its ecosystem/performance.

My question for the JVM‑community here is:

• Given the current JVM ecosystem (Java, Kotlin, Scala, Groovy, etc.), what are the realistic chances that a language like JPlus could gain mainstream adoption?

• Are there historical patterns for Java superset languages becoming widely adopted?

• What factors might accelerate or hinder adoption for a language that stays close to Java syntax while adding modern features?

I’d love to hear thoughts from people experienced with JVM language evolution, adoption patterns, or designing new JVM languages.

[adriel03-dp]

Honestly, JPlus looks interesting, especially since it stays close to Java while fixing a lot of long standing pain points. But getting mainstream traction as a new JVM language is really tough.

Kotlin only took off because it had JetBrains behind it, great tooling, and later Google’s Android endorsement. Most other “Java but better” attempts like Xtend or Ceylon never made it past niche use.

If JPlus keeps full Java compatibility, has solid IntelliJ and Gradle integration, and offers a smooth migration path, it could attract curious developers, especially those tired of Java boilerplate but not sold on Kotlin or Scala.

That said, Java itself is catching up fast with records, pattern matching, and virtual threads, so the window for a new superset language is getting smaller. You’ll probably need one killer feature or niche that Java or Kotlin don’t already cover to stand out.

[nieuwmijnleven]

We completely agree. Gaining mainstream adoption in the JVM ecosystem is definitely challenging, especially with how much Java itself has evolved and how strong Kotlin’s ecosystem has become.

Our focus with JPlus is to stay fully compatible with Java while introducing modern features that reduce developer pain without changing the language’s familiar feel. We’re also working hard on IntelliJ integration, Gradle support, and ensuring that migration from Java is as smooth as possible.

We really appreciate your insight and hope you’ll continue to follow the project’s progress!

[Aqib121201]

probably not mainstream anytime soon. java and kotlin already cover most developer needs on the jvm. new languages only take off when they fix a big missing piece. scala did that for functional programming, kotlin did it for cleaner syntax and null safety. jplus looks nice, but unless it solves a real pain point that java and kotlin don’t, people won’t switch.
the best chance is making it feel like upgraded java. if it runs old java code without issues and adds features people immediately find useful, you might get some adoption in teams that don’t want to move to kotlin. keep it stable, make the tooling good, and let people try it without big changes.

[nieuwmijnleven]

We completely agree with your points. JPlus aims to make it easy for existing Java developers to adopt by focusing on seamless compatibility with existing Java code, tangible productivity improvements, and stable tooling support.

We truly appreciate your insights and hope you’ll continue to follow and support the growth of JPlus!