DEV Community: JADEx

I started an open source project instead of begging on the street

JADEx — Wed, 22 Apr 2026 09:51:31 +0000

I'm a software developer in Java and backend systems. I hold a bachelor's and master's degree in computer science.

My life, which had seemed to be moving forward steadily, collapsed in an instant. I won't go into the details, but I can say that alcohol, cigarettes, drugs, and gambling have never been part of my life — the reasons are unrelated to any of those.

What I was left with: a worn-out set of clothes, a sleeping bag with a broken zipper, a tent, and my laptop — the one thing I refused to give up, because it's my only tool as a developer.

Every morning I head to the public library, which opens at 10 AM. For over six months now, I've been going there every day — weekends included — to build a project I designed from scratch. Sometimes I coded late into the night inside my tent.

About a year ago, my money started running out. For several months I survived on a €1 bag of chips a day, until even that wasn't possible. I had to think of something. Sitting in my tent one evening, with winter closing in fast, I asked myself: what can I actually do?

The answer I came up with: instead of begging on the street, I would design a meaningful open source project, contribute something real to the developer community, and hopefully receive donations in return.

I had tried job hunting before this, but a long gap in my employment history and a background spread across backend systems, compilers, and databases made it hard to land even a part-time position.

So I started thinking — cold mornings in the tent, walking outside, sitting in the library. I'm a Java developer, so I wanted to contribute to the Java ecosystem. At some point, null safety came to mind. Every Java developer knows the pain. Java doesn't officially support null safety today, and even when Project Valhalla eventually ships, the support will be opt-in. I wanted to build something where non-null is the default and nullable is the exception — an extension of Java's type system, not a replacement for it.

Before designing anything, I set two principles for myself:

The result should have almost no learning curve for existing Java developers.
It should add null safety to legacy Java codebases without requiring rewrites.

The approach that made sense was TypeScript's: a superset of the original language. I designed JADEx (Java Advanced Development Extension) to be Java-compatible by default, adding only null safety syntax on top — following Kotlin's syntax conventions. The name was a deliberate choice: I wanted Java developers to see it as a tool, not a foreign language.

The project is split into three parts: JADEx Compiler, IntelliJ Plugin, and Gradle Plugin.

The compiler is the core — it converts .jadex files (Java + null safety syntax) to .java, and performs static null safety analysis. Building the static analyzer took the most time; I had never built one before, so I learned as I went. I could have used NullAway or CheckerFramework, but JADEx's own syntax required a custom solution with room to grow.

After six months, I got it to the point where it supports Spring Boot — including static analysis that accounts for code auto-generated by Lombok.

When I first posted on r/java, the response was encouraging. But finding contributors has been difficult, and the more I promoted the project, the more pushback I got just for promoting it. I understand that — I just couldn't explain my situation to everyone.

I've also kept trying to find part-time work, without success so far.

If you see potential in this project, I'd be grateful for your support through GitHub Sponsors. And if you have work you'd like to offer, feel free to DM me — I'll send my resume. I'll take it seriously.

I'll be honest: unlike most of you, I've spent years benefiting from open source without contributing back. I deeply regret that.

Thank you for reading this far.

JADEx GitHub

JADEx GitHub Sponsors
JADEx PayPal.Me

Why I Built JADEx Instead of Switching to Kotlin

JADEx — Wed, 08 Apr 2026 17:14:38 +0000

Every Java team eventually has that conversation.

Someone opens a PR, there's a NullPointerException in production, and someone says: "We should just migrate to Kotlin."

I've had that conversation. And I get it — Kotlin is genuinely good. But every time I looked at a migration seriously, the same problems came up: existing codebase, team familiarity, Spring Boot annotation processing quirks, and Lombok everywhere. The cost wasn't just technical. It was organizational.

So I asked a different question: What if Java just had null-safety syntax?

Not annotations. Not a linter. Actual syntax — String?, ?., ?: — that gets checked at compile time and disappears into plain Java before the JVM ever sees it.

That's how JADEx started.

The "Obvious" Solutions Weren't Enough

I looked at NullAway and JSpecify first. They're solid tools, but they work through annotations — you end up writing @Nullable String name everywhere, and it still doesn't give you the concise chained access that makes null-safe code actually readable. You're still writing null checks by hand in most cases.

Kotlin solves this elegantly. But Kotlin solves it by being a different language. That's the tradeoff I wasn't willing to make.

And honestly, null-safety wasn't the only problem.

Every Java developer has felt it at some point — wanting to mark something final but having to do it manually every single time. Immutability should be the default, but in Java, mutability is the default and final is the opt-in. Kotlin flipped this. val is the default, var is the exception.

JADEx goes the same direction. Just without a new language, and without forcing anything. Declare apply readonly at the top of a file, and every field, local variable, and parameter in that file is automatically treated as final. Only mark something mutable when you explicitly need it to change. No need to rewrite the entire codebase at once — apply it file by file, at whatever pace works for your team.

So What Is JADEx, Exactly?

One sentence: Keep your Java code as-is, and change the language-level defaults for writing safe code.

Non-null and final are the defaults in the type system. If you want to allow null, you declare it explicitly. If you need mutability, you choose it intentionally. Everything else is plain Java — same JVM, same ecosystem, same build pipeline. .jadex files are transformed into .java files at compile time, and javac takes it from there. No runtime overhead, no new language to learn.

If Kotlin solved these problems by creating a new language, JADEx solves them while keeping Java exactly as Java.

Why Not Just Use Kotlin?

Not because Kotlin is bad. Quite the opposite — Kotlin solved these problems beautifully. Null-safety, val/var, data classes. Everything Java ignored for decades, Kotlin addressed at the language design level.

But migrating to Kotlin isn't just changing syntax.

Right now, countless companies are running hundreds of thousands of lines of Java legacy code. Lombok annotations are scattered everywhere. Spring Boot configurations are built around Java. Real services are running on top of all of it. Migrating to Kotlin isn't just a matter of time and money — it means taking on risk against systems that are stable and in production. That's not a decision most teams can make lightly.

The cost of migration isn't just in the code. It's in the team's time, focus, and risk tolerance.

So in practice, Kotlin migration discussions usually end the same way: "Good idea, but not right now." And that conversation gets forgotten until the next NPE hits production.

JADEx is for the teams stuck at "not right now." Unlike a Kotlin migration, there's no new language for the whole team to learn, no need to flip the entire codebase at once. .jadex files coexist alongside existing .java files. You can start with a single new file today. Migration happens at the source file level, incrementally, at whatever pace the team is ready for.

No migration. Existing codebase intact. Safer code starting today.

How It Works

JADEx is a source-to-source compiler. It reads .jadex files, parses the new syntax, and transforms them into plain .java files. Then javac takes over. The JVM has no idea JADEx exists.

The grammar extension is built on ANTLR4. Starting from the official Java grammar, JADEx adds ? type annotations, ?. safe calls, ?: Elvis operator, the mutable keyword, and apply readonly declarations. The parser converts .jadex files into an AST, and a visitor walks the tree, replacing new nodes with equivalent Java code.

But syntax transformation alone wasn't enough.

Replacing String? with @Nullable String is straightforward. The hard part is verifying that the nullable type flows correctly throughout the entire codebase. Passing a String? to a method that expects String should be a compile error. The result of a ?. access should automatically become nullable. This isn't a text substitution problem — it's a type system problem.

So I built a static analyzer from scratch.

JADEx's NullabilityChecker walks the AST and tracks the nullability of each expression. Variable declarations, method return types, parameters — all type information is recorded in a symbol table, and every assignment and call site is checked to ensure nullable/non-null flow is correct. Null safety is guaranteed at the JADEx level, before javac ever runs.

Lombok makes this more complicated. Lombok annotations generate code at compile time, which means the generated code doesn't exist yet at static analysis time. JADEx runs Delombok as a separate JVM process to obtain the expanded code first, maps the offsets back to the original source, and then proceeds with analysis. This ensures null-safety works correctly even in codebases heavy with Lombok.

I Want to Build This Together

JADEx is still early. But it works — null-safety syntax, apply readonly, Lombok integration, a Gradle plugin published to Maven Central, and an IntelliJ plugin.

I want to make JADEx a polished, production-ready tool and give it to Java developers for free. This isn't about commercialization. It's about giving teams that can't migrate to Kotlin, won't migrate to Kotlin, or simply love Java — a real choice for writing safer code.

But I'll be honest. I'm currently unemployed. I'm putting everything into this project without any income. Working alone, every day, at a public library. Continuing to build JADEx requires financial support. That's not a preference — it's a reality.

If you think this project matters, and if you think the Java ecosystem needs tools like this — please consider supporting development through GitHub Sponsors. As long as the support continues, so does JADEx.

If you'd like to contribute with code:

Browse the repo and open an issue on GitHub
Try it out and share your feedback
Or just leave a star

Any form of support is welcome. I want to build the day when Java developers are finally free from NullPointerExceptions.

JADEx GitHub

JADEx GitHub Sponsors

What if Java had Kotlin-style null-safety without migrating your Spring Boot project to Kotlin?

JADEx — Sat, 04 Apr 2026 11:29:24 +0000

I've been building JADEx — a source-to-source compiler that adds two things Java has always been missing: null-safety and final-by-default semantics. No JVM changes, no runtime dependency, just safer Java.

The problem

If you've worked on a large Spring Boot codebase, you've seen this everywhere:

public String getUsername(User user) {
    if (user == null) return null;
    if (user.getProfile() == null) return null;
    return user.getProfile().getUsername();
}

The usual options:

@NonNull / @Nullable annotations — opt-in, unenforced at the language level
Migrate to Kotlin — cost-prohibitive for large, widely-used legacy Java codebases

What JADEx does: Null-Safety

JADEx introduces .jadex source files. Non-null is the default. Type? is the explicit opt-in for nullable.

// UserService.jadex
public String? getUsername(User? user) {
    return user?.profile?.username;
}

The ?. operator chains safely. The ?: Elvis operator provides a fallback:

String? name = repository.findName(id);
String display = name?.toUpperCase() ?: "UNKNOWN";

If you try to access a nullable variable without ?., the compiler stops you. Null bugs shift from runtime crashes to compile-time feedback.

What JADEx does: Final-by-Default

The second feature is readonly mode — one directive makes fields, local variables, and parameters final by default:

apply readonly;

public class OrderService {
    private int total = 0;        // final — accidental reassignment is a compile error
    private mutable int retries;  // explicitly mutable when you need it
}

In large codebases, accidental reassignment is a silent bug category that final fixes — but Java requires you to write it everywhere manually, so nobody does. JADEx inverts the default.

It works in real Spring Boot projects

These aren't just toy examples. JADEx has a full Spring Boot CRUD example project showing both features working together across controllers, services, and repositories — the kind of layered architecture where null propagation and mutable state cause the most damage in practice.

The generated output is plain Java with JSpecify annotations, so it's fully compatible with NullAway, Checker Framework, and everything else in the ecosystem.

Full description: JADEx Spring Boot Example
Source repository: jadex-springboot-example

Who is JADEx for?

JADEx is a solution designed to enhance null-safety in existing Java codebases. Its key advantage is that Java developers can adopt null-safety and final-by-default semantics with zero learning curve. For the large legacy Java codebases that many companies continue to operate, migrating everything to Kotlin is rarely cost-effective — JADEx offers a much more practical path to meaningfully improving codebase stability without abandoning the investment already made in Java.

JADEx v0.59: Java Advanced Development Extension

JADEx — Thu, 19 Mar 2026 16:40:02 +0000

JADEx (Java Advanced Development Extension) is a practical Java safety layer that enhances the safety of your code by providing null-safety and readonly(final-by-default) enforcement. It strengthens Java’s type system without requiring a full rewrite, while fully leveraging existing Java libraries and tools.

As of v0.59, JADEx now ships a Gradle plugin alongside the existing IntelliJ plugin.

What JADEx does

JADEx extends Java at the source level with two core safety mechanisms:

Null-Safety

Type → non-nullable by default
Type? → nullable
?. → null-safe access operator
?: → Elvis operator (fallback value)

String? name = repository.findName(id);
String upper = name?.toLowerCase() ?: "UNKNOWN";

Compiles to standard Java:

@Nullable String name = repository.findName(id);
String upper = SafeAccess.ofNullable(name).map(t0 -> t0.toLowerCase()).orElseGet(() -> "UNKNOWN");

Readonly (Final-by-Default)

A single apply readonly; directive makes fields, local variables, and parameters final by default
Explicit mutable modifier for intentional mutability
Violations reported as standard Java compile-time errors

What's new in v0.59 - Gradle Plugin

The JADEx Gradle plugin (io.github.nieuwmijnleven.jadex) integrates .jadex compilation into the standard Gradle build lifecycle via a compileJadex task.

plugins {
    id 'io.github.nieuwmijnleven.jadex' version '0.59'
}

Default source directory: src/main/jadex
Default output directory: build/generated/sources/jadex/main/java
Optional jadex {} DSL block for custom configuration
IntelliJ plugin now integrates with the Gradle plugin via the Gradle Tooling API for consistent path resolution between IDE and build pipeline

jadex {
    sourceDir = "src/main/jadex"
    outputDir = "build/generated/sources/jadex/main/java"
}

Other Improvements

IntelliJ Plugin - Gradle Plugin Integration
- The IntelliJ plugin now integrates with the JADEx Gradle plugin via the Gradle Tooling API.
- Source and output directory resolution is now delegated to the Gradle plugin configuration, ensuring consistency between the IDE and the build pipeline.
Parser Performance Optimization
- Improved parser speed by optimizing parser rules.
- Reduces analysis latency in the IDE, providing a smoother editing experience for large .jadex files.

Design philosophy

JADEx is not a new language. It does not modify the JVM. It operates purely at the source level and generates standard Java code, meaning it is fully compatible with existing Java libraries, tools, and workflows. The goal is to make null-safety and readonly(final-by-default) enforcement practical and incremental, applicable file by file to existing codebases without a full rewrite.

Links

GitHub: https://github.com/nieuwmijnleven/JADEx
Gradle Plugin Portal: https://plugins.gradle.org/plugin/io.github.nieuwmijnleven.jadex
Tutorial: Making Your Java Code Null-Safe without Rewriting it
Real-world example: Applying JADEx to a Real Java Project
Release note for v0.59: https://github.com/nieuwmijnleven/JADEx/releases/tag/v0.59

Feedback and questions welcome.

JADEx: A New Practical Null-Safety Solution for Java

JADEx — Thu, 12 Mar 2026 18:44:25 +0000

JADEx (Java Advanced Development Extension) is a safety layer that makes Java safer by adding Null-Safety and Final-by-Default semantics without modifying the JVM.

Null-Safety

NullPointerException (NPE) is one of the most common sources of runtime failures in Java applications.

Although modern Java provides tools such as Optional and static analysis, null-related bugs are still fundamentally a runtime problem in most Java codebases.

JADEx addresses this problem by introducing explicit nullability into the type system and enforcing safe access rules at compile time.

In JADEx:

Type → non-nullable by default
Type? → nullable
?. → null-safe access operator
?: → Elvis operator (fallback value)

This design ensures that developers must explicitly acknowledge and handle nullable values before accessing them.

For example:

String? name = repository.findName(id);
String upper = name?.toLowerCase() ?: "UNKNOWN";

When compiled by JADEx, this code is translated into standard Java:

JADEx compiles null-safe expressions into standard Java using a small helper API(SafeAccess).

@Nullable String name = repository.findName(id);
String upper = SafeAccess.ofNullable(name).map(t0 -> t0.toLowerCase()).orElseGet(() -> "UNKNOWN");

In this example:

name is explicitly declared as nullable.

The ?. operator safely accesses toLowerCase() only if name is not null.

The ?: operator provides a fallback value if the result is null.

Instead of writing repetitive null-check logic such as:

if (name != null) {
    upper = name.toLowerCase();
} else {
    upper = "UNKNOWN";
}

JADEx allows the same logic to be expressed safely and concisely.

Most importantly, JADEx prevents unsafe operations at compile time.
If a nullable variable is accessed without using the null-safe operator, the compiler will report an error.

This approach shifts null-related problems from runtime failures to compile-time feedback, helping developers detect issues earlier and build more reliable software.

Readonly (Final-by-Default)

JADEx also introduces optional readonly semantics through a final-by-default model.

In large Java codebases, accidental reassignment of variables or fields can lead to subtle bugs and make code harder to reason about. While Java provides the final keyword, it must be manually applied everywhere, which often results in inconsistent usage.

JADEx simplifies this by allowing developers to enable readonly mode with a single directive:

apply readonly;

Once enabled:

Fields, local variables, and parameters become final by default
JADEx automatically applies final where appropriate
Reassignment attempts are reported as compile-time errors

Example:

apply readonly;  

public class Example {  
    private int count = 0;  

    public static void main(String[] args) {  
        var example = new Example();  
        example.count = 10; // compile-time error  
    }  
}

Since count is generated as final, the reassignment results in a standard Java compile-time error.

If mutability is intentionally required, developers can explicitly opt in using the mutable modifier:

private mutable int counter = 0;

This approach encourages safer programming practices while keeping the code flexible when mutation is necessary.

When compiled, JADEx generates standard Java code with final modifiers applied where appropriate, ensuring full compatibility with the existing Java ecosystem.

//apply readonly;

@NullMarked
public class Example {
    private final int count = 0;

    public static void main(final String[] args) {
        final var example = new Example();
        example.count = 10; // compile-time error
    }
}

Summary

JADEx introduces two complementary safety mechanisms:

Null-Safety

Non-null by default
Explicit nullable types
Safe access operators (?., ?:)
Compile-time detection of unsafe null usage

Readonly (Final-by-Default)

Final by default
Explicit opt-in for mutability
Automatic final generation
Prevention of accidental reassignment

Together, these features strengthen Java’s type system while remaining fully compatible with existing Java libraries, tools, and workflows.

JADEx does not replace Java.

It simply adds a safety layer that makes Java safer while keeping full compatibility with the existing ecosystem.

Making your Java code null-safe without rewriting it

JADEx — Thu, 06 Nov 2025 11:16:40 +0000

Null-pointer exceptions are a common error in Java, causing inconvenience for many developers. Preventing null pointer exceptions in advance is important, but for developers who want to focus solely on logic, handling them can be tedious. Moreover, it’s not always easy to account for every scenario. Typically, static analysis tools are used to detect potential null pointer issues, but developers still have to find and fix the code themselves. JPlus reduces that burden. Let’s write null-safe Java code with JPlus.

1. Access the JPlus GitHub repository and download the IntelliJ plugin

https://github.com/nieuwmijnleven/JPlus

2. Install the JPlus IntelliJ plugin

Open IntelliJ
Go to File > Settings > Plugin > ⚙️ > Install Plugin from Disk
Select the downloaded intellij-plugin-0.1-mvp-alpha.zip
Restart IntelliJ

3. Open the example project in IntelliJ

Go to File > New > Project from Version Control
Enter https://github.com/nieuwmijnleven/JPlusExample
Click the Clone button

4. Create a JPlus file for User.java in the Project View

Right-click User.java in the Project View
Select Convert Java File to JPlus File from the menu

5. Making Java code null-safe with JPlus

User.jplus

package jplus.example;

class User {
    // Name is required
    String name;        
    // Address can be null
    Address address;   

    User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    //remain codes
}

Opening the generated User.jplus file, you can see error messages in the Problems tab.

By default, JPlus assumes all reference types are non-nullable, which causes these errors. The problematic parts are where the constructors of the User and Address classes are called.

User(String name, Address address) {
    this.name = name;
    this.address = address;
}

Address(String city) {
    this.city = city;
}

User user1 = new User("Jeroen", new Address("New Amsterdam"));
User user2 = new User("Jane Smith", null);
User user3 = new User(null, new Address(null));

The constructor parameters for User and Address are all non-nullable. Passing null violates the null-safety rules.
Therefore, errors occur for user2 and user3.

Making Java code null-safe with JPlus

(1) Assume the name field is required

Add final to the name field
Use apply constructor(required) to auto-generate the required constructor
Press Ctrl + S to save, so changes reflect in User.java.

User.jplus

package jplus.example;

apply constructor(required);

class User {
    // Name is required
    final String name;        
    // Address can be null
    Address address;   

    User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    //remain codes
}

At the end, the generated User.java includes a constructor for the final name field.

(2) Assume the address field is nullable

Add ? to the Address type
Also mark the constructor parameter as nullable

package jplus.example;

apply constructor(required);

class User {
    // Name is required
    final String name;
    // Address can be null
    Address? address;

    User(String name, Address? address) {
        this.name = name;
        this.address = address;
    }

The Problems tab shows:

address is a nullable variable. But it directly accesses city. Consider using null-safe operator(?.)

Use the null-safe operator ?.:

    // Safely get the city name of the address
    String getCity() {
        return address?.city;
    }

Then only the constructor-related error for name remains.

Replace null with "No Name" because name field is required.

User user3 = new User("No Name", new Address(null));

Now only one error remains:

The 1st argument of the Address constructor is a non-nullable variable, but a null value is assigned to it.

(3) Assume city in Address is nullable

Add ? to String type and constructor parameter

static class Address {
    // City can be null
    String? city;

    Address(String? city) {
        this.city = city;
    }
}

All nullability errors disappear. Save the file (Ctrl + S) to generate new User.java.

User.java made null-safe by JPlus

package jplus.example;

//apply constructor(required);

class User {
    // Name is required
    final String name;
    // Address can be null
    Address address;    

    public User(String name) {
        this.name = name;
    }

    User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    // Safely get the city name of the address
    String getCity() {
        return (((address)!=null)?(address.city):null);
    }

    // Get the display name of the user
    String getDisplayName() {
        return name;
    }

    // Address class
    static class Address {
        // City can be null
        String city;

        Address(String city) {
            this.city = city;
        }
    }

    public static void main(String[] args) {
        // Null-safe object creation
        User user1 = new User("Jeroen", new Address("New Amsterdam"));
        User user2 = new User("Jane Smith", null);
        User user3 = new User("No Name", new Address(null));

        // Null-safe access
        System.out.println(user1.getDisplayName() + "'s city: " + user1.getCity()); // Jeroen's city: New Amsterdam
        System.out.println(user2.getDisplayName() + "'s city: " + user2.getCity()); // Jane Smith's city: No Address
        System.out.println(user3.getDisplayName() + "'s city: " + user3.getCity()); // No Name's city: No Address
    }
}

Run the program:

Go to User.java
Select Run > 'Run User.java'

No NullPointerException occurs, but some outputs are null. Use the Elvis operator ?: to provide default values.

Edit getCity() in User.jplus:

class User {
    //...
    // Safely get the city name of the address
    String getCity() {
        return address?.city ?: "No City";
    }
   //...
}

Also, be sure to press Ctrl + S to save. This ensures that the new Java code is saved in User.java.

User.java made null-safe by JPlus

package jplus.example;

//apply constructor(required);

class User {
    // Name is required
    final String name;
    // Address can be null
    Address address;    

    public User(String name) {
        this.name = name;
    }

    User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    // Safely get the city name of the address
    String getCity() {
        return ((((((address)!=null)?(address.city):null))!=null)?((((address)!=null)?(address.city):null)):("No City"));
    }

    // Get the display name of the user
    String getDisplayName() {
        return name;
    }

    // Address class
    static class Address {
        // City can be null
        String city;

        Address(String city) {
            this.city = city;
        }
    }

    public static void main(String[] args) {
        // Null-safe object creation
        User user1 = new User("Jeroen", new Address("New Amsterdam"));
        User user2 = new User("Jane Smith", null);
        User user3 = new User("No Name", new Address(null));

        // Null-safe access
        System.out.println(user1.getDisplayName() + "'s city: " + user1.getCity()); // Jeroen's city: New Amsterdam
        System.out.println(user2.getDisplayName() + "'s city: " + user2.getCity()); // Jane Smith's city: No Address
        System.out.println(user3.getDisplayName() + "'s city: " + user3.getCity()); // No Name's city: No Address
    }

}

Run the program:

Go to User.java
Select Run > 'Run User.java'

All null values are replaced with "No City"

Summary

With JPlus, you can easily enforce null-safety in Java code. JPlus fully supports Java syntax, making it accessible for Java developers. The final code is converted to Java, allowing developers to review it. JPlus is still in its early stages and needs support from the Java community. Even small, regular contributions will help complete this project. Your support can make a real impact.

Become a Sponsor via Github

Become a Sponsor via PayPal.me

Making Java Code Null-Safe With JPlus

JADEx — Wed, 05 Nov 2025 15:50:16 +0000

1. Access the JPlus GitHub repository and download the IntelliJ plugin

https://github.com/nieuwmijnleven/JPlus

2. nstall the JPlus IntelliJ plugin

Open IntelliJ
Go to File > Settings > Plugin > ⚙️ > Install Plugin from Disk
Select the downloaded intellij-plugin-0.1-mvp-alpha.zip
Restart IntelliJ

3. Open the example project in IntelliJ

Go to File > New > Project from Version Control
Enter https://github.com/nieuwmijnleven/JPlusExample
Click the Clone button

4. Create a JPlus file for User.java in the Project View

Right-click User.java in the Project View
Select Convert Java File to JPlus File from the menu

5. Making Java code null-safe with JPlus

User.jplus

package jplus.example;

class User {
    // Name is required
    String name;        
    // Address can be null
    Address address;   

    User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    //remain codes
}

Opening the generated User.jplus file, you can see error messages in the Problems tab.

By default, JPlus assumes all reference types are non-nullable, which causes these errors. The problematic parts are where the constructors of the User and Address classes are called.

User(String name, Address address) {
    this.name = name;
    this.address = address;
}

Address(String city) {
    this.city = city;
}

User user1 = new User("Jeroen", new Address("New Amsterdam"));
User user2 = new User("Jane Smith", null);
User user3 = new User(null, new Address(null));

The constructor parameters for User and Address are all non-nullable. Passing null violates the null-safety rules.
Therefore, errors occur for user2 and user3.

Making Java code null-safe with JPlus

(1) Assume the name field is required

Add final to the name field
Use apply constructor(required) to auto-generate the required constructor
Press Ctrl + S to save, so changes reflect in User.java.

User.jplus

package jplus.example;

apply constructor(required);

class User {
    // Name is required
    final String name;        
    // Address can be null
    Address address;   

    User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    //remain codes
}

At the end, the generated User.java includes a constructor for the final name field.

(2) Assume the address field is nullable

Add ? to the Address type
Also mark the constructor parameter as nullable

package jplus.example;

apply constructor(required);

class User {
    // Name is required
    final String name;
    // Address can be null
    Address? address;

    User(String name, Address? address) {
        this.name = name;
        this.address = address;
    }

The Problems tab shows:

address is a nullable variable. But it directly accesses city. Consider using null-safe operator(?.)

Use the null-safe operator ?.:

    // Safely get the city name of the address
    String getCity() {
        return address?.city;
    }

Then only the constructor-related error for name remains.

Replace null with "No Name" because name field is required.

User user3 = new User("No Name", new Address(null));

Now only one error remains:

The 1st argument of the Address constructor is a non-nullable variable, but a null value is assigned to it.

(3) Assume city in Address is nullable

Add ? to String type and constructor parameter

static class Address {
    // City can be null
    String? city;

    Address(String? city) {
        this.city = city;
    }
}

All nullability errors disappear. Save the file (Ctrl + S) to generate new User.java.

User.java made null-safe by JPlus

package jplus.example;

//apply constructor(required);

class User {
    // Name is required
    final String name;
    // Address can be null
    Address address;    

    public User(String name) {
        this.name = name;
    }

    User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    // Safely get the city name of the address
    String getCity() {
        return (((address)!=null)?(address.city):null);
    }

    // Get the display name of the user
    String getDisplayName() {
        return name;
    }

    // Address class
    static class Address {
        // City can be null
        String city;

        Address(String city) {
            this.city = city;
        }
    }

    public static void main(String[] args) {
        // Null-safe object creation
        User user1 = new User("Jeroen", new Address("New Amsterdam"));
        User user2 = new User("Jane Smith", null);
        User user3 = new User("No Name", new Address(null));

        // Null-safe access
        System.out.println(user1.getDisplayName() + "'s city: " + user1.getCity()); // Jeroen's city: New Amsterdam
        System.out.println(user2.getDisplayName() + "'s city: " + user2.getCity()); // Jane Smith's city: No Address
        System.out.println(user3.getDisplayName() + "'s city: " + user3.getCity()); // No Name's city: No Address
    }
}

Run the program:

Go to User.java
Select Run > 'Run User.java'

No NullPointerException occurs, but some outputs are null. Use the Elvis operator ?: to provide default values.

Edit getCity() in User.jplus:

class User {
    //...
    // Safely get the city name of the address
    String getCity() {
        return address?.city ?: "No City";
    }
   //...
}

Also, be sure to press Ctrl + S to save. This ensures that the new Java code is saved in User.java.

User.java made null-safe by JPlus

package jplus.example;

//apply constructor(required);

class User {
    // Name is required
    final String name;
    // Address can be null
    Address address;    

    public User(String name) {
        this.name = name;
    }

    User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    // Safely get the city name of the address
    String getCity() {
        return ((((((address)!=null)?(address.city):null))!=null)?((((address)!=null)?(address.city):null)):("No City"));
    }

    // Get the display name of the user
    String getDisplayName() {
        return name;
    }

    // Address class
    static class Address {
        // City can be null
        String city;

        Address(String city) {
            this.city = city;
        }
    }

    public static void main(String[] args) {
        // Null-safe object creation
        User user1 = new User("Jeroen", new Address("New Amsterdam"));
        User user2 = new User("Jane Smith", null);
        User user3 = new User("No Name", new Address(null));

        // Null-safe access
        System.out.println(user1.getDisplayName() + "'s city: " + user1.getCity()); // Jeroen's city: New Amsterdam
        System.out.println(user2.getDisplayName() + "'s city: " + user2.getCity()); // Jane Smith's city: No Address
        System.out.println(user3.getDisplayName() + "'s city: " + user3.getCity()); // No Name's city: No Address
    }

}

Run the program:

Go to User.java
Select Run > 'Run User.java'

All null values are replaced with "No City"

Summary

Become a Sponsor via Github

Become a Sponsor via PayPal.me

🌟 Introducing JPlus – A Modern Java Superset Language

JADEx — Fri, 31 Oct 2025 13:22:14 +0000

JPlus is a Java superset language running on the JVM that enhances developer productivity while staying fully compatible with the Java ecosystem.

🚀 Why Support JPlus?

JPlus fills a unique gap in the Java ecosystem:

Maintains 100% Java syntax compatibility
Introduces null safety(?), null-safety operator(?.), boilerplate code generating syntax(apply), and Elvis Operator(?:) features
Allows gradual adoption alongside existing Java code
Compiles directly to plain Java code

🎥 Watch the demo video:

Currently, there is no other language that extends Java in this way while keeping the syntax familiar to Java developers.

✨ Key Features

Strict Null Checking – Prevent null reference errors at compile time
Null-safety Operator – Use ?. operators to safely access nullable variables without risking NullPointerException
boilerplate code generating syntax – Replace common boilerplate like getters, setters, constructors, and builders without Lombok
Elvis Operator - Simplify null checks with ?: to provide default values when a variable is null

✅ Example ① — Combining `?.` and `?:` Operators

JPlus supports combining the null-safe access operator (?.) and the Elvis operator (?:)

to simplify complex null-handling logic into clean and concise expressions.

📄 Example – `NullsafeWithElvisOperator.jplus`

package jplus.example;

public class Main {
    public static void main(String[] args) {
        String? s1 = null;
        String s2 = s1 ?: "jplus";
        System.out.printf("the length of s1 : %d\n", s1?.length() ?: 0);
        System.out.printf("the length of s2 : %d\n", s2.length());
    }
}

s1 is a nullable variable.
s1 ?: "jplus" → assigns "jplus" if s1 is null.
s1?.length() ?: 0 → safely calls length() on s1, returns 0 if s1 is null.
By combining both operators, null handling becomes safe and concise.

✅ Output (Java code generated by JPlus)

package jplus.example;

public class Main {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = (((s1) != null) ? (s1) : "jplus");
        System.out.printf(
                "the length of s1 : %d\n",
                (((((s1 != null) ? s1.length() : null)) != null)
                        ? (((s1 != null) ? s1.length() : null))
                        : 0));
        System.out.printf("the length of s2 : %d\n", s2.length());
    }
}

The expression s1?.length() ?: 0 is translated into a nested conditional check in Java:

((s1 != null) ? s1.length() : null) != null ? ... : 0, ensuring safe execution.

✅ Example ② — Using apply for Data Class and Nested Class Boilerplate Elimination

JPlus introduces the apply keyword to replace common Java boilerplate code such as getters, setters, constructors, builders, and more.
It serves as a language-level alternative to Lombok annotations, offering a clean and declarative syntax.

📄 Example – `ApplyStatement.jplus`

package com.example;

apply data, constructor(required, all, no), builder;
apply {
    User.Profile: getter, setter, equality, constructor(all);
}

public class User {
    private String name;
    private int age;

    public class Profile {
        String nickname;
    }
}

data: Automatically generates getters, setters, equals(), hashCode(), and toString()
builder: Generates a User.Builder class for fluent object creation
constructors(required, all, no):Generates a constructor with all/required fields and a no-argument constructor
equality: Generates equals() and hashCode() methods
apply { User.Profile: ... }: Applies boilerplate generation specifically to the Profile inner class

✅ Output (Java code generated by JPlus)

package com.example;

//apply data, constructor(required, all, no), builder;
//apply {
//    User.Profile: getter, setter, equality, constructor(all);
//}

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public User() {}

    public class Profile {
        String nickname;

        public Profile(String nickname) {
            this.nickname = nickname;
        }

        public String getNickname() {
            return nickname;
        }

        public void setNickname(String nickname) {
            this.nickname = nickname;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Profile profile = (Profile) o;
            return java.util.Objects.equals(nickname, profile.nickname);
        }

        @Override
        public int hashCode() {
            return java.util.Objects.hash(nickname);
        }
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" + "name=" + name+ ", " + "age=" + age + "}";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age
                && java.util.Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return java.util.Objects.hash(name, age);
    }

    public static class Builder {
        private String name;
        private int age;

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public User build() {
            return new User(name, age);
        }
    }

    public static Builder builder() {
        return new Builder();
    }
}

This allows developers to keep code DRY and expressive even with deeply nested structures.

🛠️ Current Status

MVP (Minimum Viable Product) stage
IntelliJ Plugin 0.1 MVP Alpha released with:
- Syntax highlighting, code completion, and error checking
- Nullability checks
- Seamless integration with existing Java projects

🔗 Github repository

🎥 Watch the demo video

📥 Download: intellij-plugin-0.1-mvp-alpha.zip

💡 Why Your Support Matters

JPlus is actively developed and community contributions and sponsorships are critical:

Help us improve stability, add features, and polish the language
Gain early access to new releases and features
Receive recognition as a valued sponsor and contributor

Your sponsorship accelerates development and helps bring safer, cleaner, and more productive Java development to the community.

💸 How to Sponsor

Even a small contribution helps shape the future of JPlus!

Thank you for supporting JPlus – together, we can make Java development safer, more productive, and enjoyable. 🔗 Github repository

🚀 Introducing JPlus – A Java Superset with Null Safety and Boilerplate Elimination

JADEx — Wed, 22 Oct 2025 11:50:04 +0000

JPlus is a modern programming language and compiler that acts as a superset of Java —

bringing the benefits of null safety, concise syntax, and powerful declarative features

while remaining fully interoperable with existing Java code and libraries.

✨ Why JPlus?

Java is a powerful and battle-tested language, but developers often face:

Verbose boilerplate (getters/setters, constructors, etc.)
Dangerous NullPointerExceptions
Lack of modern language features like ?: (Elvis), smart casts, or pattern matching

JPlus solves this by introducing modern features on top of Java — without breaking compatibility.

JPlus code compiles to standard JVM bytecode, enabling full use of Java libraries and frameworks.

🔐 Null Safety & Modern Syntax Features

JPlus enforces strict null checks at compile-time and introduces Kotlin-style operators:

Feature	Description
`Type` vs `Type?`	Explicit non-nullable and nullable types
`?.`	Null-safe access operator
`?:`	Elvis operator for default/fallback values
Smart Casts	Safe type narrowing after null checks
Type Inference	Reduce verbosity, no need to declare obvious types
Pattern Matching	Clean `switch`/`if` logic with type-safe guards
Async Syntax (planned)	Future-ready syntax with `async`/`await` support

🔧 NEW: `apply` Syntax for Replacing Lombok

JPlus introduces the new apply statement — a powerful declarative alternative to Lombok annotations.

🔁 Replace This:

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class User {
    private String name;
    private int age;
}

✅ With This:

apply data, builder, constructors(all, no);  

public class User {     
    private String name;     
    private int age; 
}

💡 Even Nested Classes:

apply data, constructor(required, all, no), builder;  
apply {  
    User.Profile: getter, setter, equality, constructor(all);
}  

public class User {  
    private String name;    
    private int age;  

    public class Profile {        
        String nickname;    
    }
}

All boilerplate — constructors, getters/setters, toString, equals, builder — generated as plain Java.

For full code and output, see:

Go to Example 6

🔭 Coming Soon: IntelliJ Plugin

We are actively developing an IntelliJ IDEA plugin to provide:

🔍 Syntax highlighting and autocomplete for .jplus files
⚠️ Real-time null-check error detection
🚀 One-click compile-to-Java and build integration

Stay tuned — the plugin will make JPlus production-ready for real-world development!

💝 Support Development

JPlus is a one-person open-source project under active development.

If you find value in this work and want to help shape the future of Java development:

👉 Github Sponsors

👉 Support the Project via PayPal

Your contribution supports language tooling, plugin development, and community outreach.

The benefits will ripple across the entire Java community.

💬 Get Involved

⭐ Star the project on GitHub
🐛 Report bugs and suggest features
🧠 Contribute code or docs
💬 Join the community discussions (coming soon)

🔗 Learn More

JPlus GitHub Repository
License (Apache 2.0)

JPlus is here to modernize Java while respecting its legacy.

Let's build a safer, cleaner, and more expressive future — together.

🚀Introducing JPlus – A Java Superset with Built-in Null Safety and Boilerplate Elimination

JADEx — Wed, 22 Oct 2025 11:47:48 +0000

JPlus is a modern programming language and compiler that acts as a superset of Java —

bringing the benefits of null safety, concise syntax, and powerful declarative features

while remaining fully interoperable with existing Java code and libraries.

✨ Why JPlus?

Java is a powerful and battle-tested language, but developers often face:

Verbose boilerplate (getters/setters, constructors, etc.)
Dangerous NullPointerExceptions
Lack of modern language features like ?: (Elvis), smart casts, or pattern matching

JPlus solves this by introducing modern features on top of Java — without breaking compatibility.

JPlus code compiles to standard JVM bytecode, enabling full use of Java libraries and frameworks.

🔐 Null Safety & Modern Syntax Features

JPlus enforces strict null checks at compile-time and introduces Kotlin-style operators:

Feature	Description
`Type` vs `Type?`	Explicit non-nullable and nullable types
`?.`	Null-safe access operator
`?:`	Elvis operator for default/fallback values
Smart Casts	Safe type narrowing after null checks
Type Inference	Reduce verbosity, no need to declare obvious types
Pattern Matching	Clean `switch`/`if` logic with type-safe guards
Async Syntax (planned)	Future-ready syntax with `async`/`await` support

🔧 NEW: `apply` Syntax for Replacing Lombok

JPlus introduces the new apply statement — a powerful declarative alternative to Lombok annotations.

🔁 Replace This:

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class User {
    private String name;
    private int age;
}

✅ With This:

apply data, builder, constructors(all, no);  

public class User {     
    private String name;     
    private int age; 
}

💡 Even Nested Classes:

apply data, constructor(required, all, no), builder;  
apply {  
    User.Profile: getter, setter, equality, constructor(all);
}  

public class User {  
    private String name;    
    private int age;  

    public class Profile {        
        String nickname;    
    }
}

All boilerplate — constructors, getters/setters, toString, equals, builder — generated as plain Java.

For full code and output, see:

Go to Example 6

🔭 Coming Soon: IntelliJ Plugin

We are actively developing an IntelliJ IDEA plugin to provide:

🔍 Syntax highlighting and autocomplete for .jplus files
⚠️ Real-time null-check error detection
🚀 One-click compile-to-Java and build integration

Stay tuned — the plugin will make JPlus production-ready for real-world development!

💝 Support Development

JPlus is a one-person open-source project under active development.

If you find value in this work and want to help shape the future of Java development:

👉 Github Sponsors

👉 Support the Project via PayPal

Your contribution supports language tooling, plugin development, and community outreach.

The benefits will ripple across the entire Java community.

💬 Get Involved

⭐ Star the project on GitHub
🐛 Report bugs and suggest features
🧠 Contribute code or docs
💬 Join the community discussions (coming soon)

🔗 Learn More

JPlus GitHub Repository
License (Apache 2.0)

DEV Community: JADEx

I started an open source project instead of begging on the street

Why I Built JADEx Instead of Switching to Kotlin

The "Obvious" Solutions Weren't Enough

So What Is JADEx, Exactly?

Why Not Just Use Kotlin?

How It Works

I Want to Build This Together

What if Java had Kotlin-style null-safety without migrating your Spring Boot project to Kotlin?

The problem

What JADEx does: Null-Safety

What JADEx does: Final-by-Default

It works in real Spring Boot projects

Who is JADEx for?

Links

JADEx v0.59: Java Advanced Development Extension

JADEx: A New Practical Null-Safety Solution for Java

Null-Safety

Readonly (Final-by-Default)

Summary

Making your Java code null-safe without rewriting it

1. Access the JPlus GitHub repository and download the IntelliJ plugin

2. Install the JPlus IntelliJ plugin

3. Open the example project in IntelliJ

4. Create a JPlus file for User.java in the Project View

5. Making Java code null-safe with JPlus

User.jplus

Making Java code null-safe with JPlus

User.jplus

(2) Assume the address field is nullable

Summary

Making Java Code Null-Safe With JPlus

1. Access the JPlus GitHub repository and download the IntelliJ plugin

2. nstall the JPlus IntelliJ plugin

3. Open the example project in IntelliJ

4. Create a JPlus file for User.java in the Project View

5. Making Java code null-safe with JPlus

User.jplus

Making Java code null-safe with JPlus

User.jplus

(2) Assume the address field is nullable

Summary

🌟 Introducing JPlus – A Modern Java Superset Language

🚀 Why Support JPlus?

✨ Key Features

✅ Example ① — Combining ?. and ?: Operators

📄 Example – NullsafeWithElvisOperator.jplus

✅ Output (Java code generated by JPlus)

✅ Example ② — Using apply for Data Class and Nested Class Boilerplate Elimination

📄 Example – ApplyStatement.jplus

✅ Output (Java code generated by JPlus)

🛠️ Current Status

💡 Why Your Support Matters

💸 How to Sponsor

🚀 Introducing JPlus – A Java Superset with Null Safety and Boilerplate Elimination

✨ Why JPlus?

🔐 Null Safety & Modern Syntax Features

🔧 NEW: apply Syntax for Replacing Lombok

🔁 Replace This:

✅ With This:

💡 Even Nested Classes:

🔭 Coming Soon: IntelliJ Plugin

💝 Support Development

💬 Get Involved

🔗 Learn More

🚀Introducing JPlus – A Java Superset with Built-in Null Safety and Boilerplate Elimination

✨ Why JPlus?

🔐 Null Safety & Modern Syntax Features

🔧 NEW: apply Syntax for Replacing Lombok

🔁 Replace This:

✅ With This:

💡 Even Nested Classes:

🔭 Coming Soon: IntelliJ Plugin

💝 Support Development

💬 Get Involved

🔗 Learn More

✅ Example ① — Combining `?.` and `?:` Operators

📄 Example – `NullsafeWithElvisOperator.jplus`

📄 Example – `ApplyStatement.jplus`

🔧 NEW: `apply` Syntax for Replacing Lombok

🔧 NEW: `apply` Syntax for Replacing Lombok