JEP 544: Ahead-of-Time Code Compilation

A command‑line tool that automates Leyden training runs: it generates a representative workload, executes training, and outputs an AOT cache ready for inclusion in a Maven/Gradle build.
Core value proposition: eliminates the manual, bespoke setup required to reap Leyden’s startup‑time benefits, giving Java developers a “one‑click” performance boost comparable to native images.

Key	Value
Target Audience	Java library/application maintainers using OpenJDK 21+ who want faster startup without switching to full native compilation
Core Feature	Auto‑generates training workload (via JUnit/Testcontainers or a simple harness), runs the Leyden training JVM, and writes the AOT cache artifact (`leyden-cache`) into the project’s build output
Tech Stack	Java 21, Maven/Gradle plugins, JVMTI agent for training, Picocli for CLI, optional integration with GitHub Actions
Difficulty	Medium
Monetization	Hobby

HN commenters complained about the “hard burden to setup” for Leyden training runs and the lack of tooling (cogman10, jgon). Leydenify directly addresses that pain.
By providing a shareable cache artifact, teams can commit it to version control and reproduce performance gains across CI/CD pipelines, sparking discussion on best practices for hybrid AOT/JIT workloads.

A wrapper around jlink, jpackage, and optional GraalVM Native Image that produces a single, self‑contained executable (or app bundle) from a Java project, automatically performing module tree‑shaking and configuring launch parameters.
Core value proposition: gives Java developers the same “throw a binary to the user” experience as Go or Rust, drastically simplifying distribution of CLI tools, desktop apps, and serverless functions.

Key	Value
Target Audience	Developers building Java CLI tools, desktop apps, or lightweight microservices who currently rely on Docker or complex installers
Core Feature	One‑command build (`javakit build`) that detects required modules, creates a minimal custom runtime, bundles it with `jpackage` (or outputs a native binary via GraalVM), and yields a distributable artifact (`.exe`, AppImage, deb/rpm, or standalone binary)
Tech Stack	Java 21, jlink/jpackage APIs, GraalVM Native Image (optional), Kotlin DSL for configuration, native‑image‑maven‑plugin, multi‑platform build via GitHub Actions
Difficulty	Medium
Monetization	Revenue‑ready: SaaS CI/CD integration tier ($10/mo per private repo)

jgon highlighted that Java distribution “still sucks” compared to Go/Rust static binaries and wished for easier tooling. Javakit delivers that simplicity while still leveraging the JDK’s module system.
The tool can be positioned as a drop‑in replacement for jpackage in CI pipelines, encouraging discussion on reducing Java’s deployment friction and making the language more attractive for utilities and CLI projects.

A Java agent and Gradle/Maven plugin that records reflective access during test or benchmark runs and automatically generates the configuration files (reflect-config.json, jni-config.json, etc.) required by GraalVM Native Image.
Core value proposition: removes the manual, error‑prone step of maintaining native‑image reflection configuration, enabling more projects to adopt ahead‑of‑time compilation with minimal friction.

Key	Value
Target Audience	Java teams evaluating or using GraalVM Native Image who struggle with reflection configuration (layer8, invalidname)
Core Feature	Instruments bytecode at runtime to capture calls to `Class.forName`, `MethodHandles`, reflection APIs, serialization frameworks, and outputs ready‑to‑use native‑image config files; includes incremental mode for CI
Tech Stack	Java Agent (ByteBuddy or ASM), Maven/Gradle plugin, JSON configuration output, optional integration with Quarkus/Micronaut extensions
Difficulty	Low
Monetization	Hobby

Commenters noted that “third‑party libraries that don’t support AOT” are a major barrier (layer8, jasomill). ReflectGen mitigates this by automatically handling reflection for both application code and popular libraries, encouraging broader AOT adoption.
By reducing the configuration overhead, teams can more easily experiment with native image for serverless functions or CLI tools, a topic frequently discussed in the thread regarding startup time vs. JIT performance trade‑offs.

🚀 Project Ideas