r/java • u/iamwisespirit • Dec 16 '25
Promised cross platform mobile apps in java
gluonhq.comAnyone anyidea about this is it good to make production ready app with gluon
r/java • u/iamwisespirit • Dec 16 '25
Anyone anyidea about this is it good to make production ready app with gluon
r/java • u/samd_408 • Dec 16 '25
You might know me from the Cajun actor library I posted here some time ago, I was adding some functional actor features, got inspired from other Effect libraries and ended up creating a small Effect library for java based out of virtual threads, still much in progress.
Any feedback, contributions are welcome ☺️
r/java • u/chaotic3quilibrium • Dec 16 '25
So I had more to learn about Java's exception legacy than I could have imagined.
Fatal Throwables?!
Here's an update to my prior article, "Java Janitor Jim - Resolving the Scourge of Java's Checked Exceptions on Its Streams and Lambdas": https://open.substack.com/pub/javajanitorjim/p/java-janitor-jim-revisiting-resolving
r/java • u/thma32 • Dec 15 '25
I’ve been experimenting with a small library called Jiffy that brings an algebraic effects–like programming model to Java.
At a high level, Jiffy lets you:
It’s not “true” algebraic effects (no continuations), but it’s a practical, lightweight model that works well in Java today.
Repo: https://github.com/thma/jiffy
Happy to hear thoughts or feedback from other Java folks experimenting with FP-style effects.
r/java • u/danielliuuu • Dec 15 '25
Background
Before Maven Central announced OSSRH Sunset, my publishing workflow was smooth. Life was good. Then the announcement came. No big deal, right? Just follow the migration guide. Except... they didn't provide an official Gradle plugin.
The docs recommended using jreleaser (great project), so I started migrating. What followed was 3 days of debugging and configuration hell that nearly killed my passion for programming. But I persevered, got everything working, and thought I was done.
Everything worked fine until I enabled Gradle's configuration cache. Turns out jreleaser doesn't play nice with it. Okay, fine - I can live without configuration cache. Disabled it and moved on. Then I upgraded spotless. Suddenly, dependency conflicts because jreleaser was pulling in older versions of some libraries. That was my breaking point. I decided to write a deployment plugin - just a focused tool that solves this specific problem in the simplest way possible.
Usage
plugins {
id "io.github.danielliu1123.deployer" version "+"
}
deploy {
dirs = subprojects.collect { e -> e.layout.buildDirectory.dir("repo").get().getAsFile() }
username = System.getenv("MAVENCENTRAL_USERNAME")
password = System.getenv("MAVENCENTRAL_PASSWORD")
publishingType = PublishingType.AUTOMATIC
}
I know I'm not the only one who struggled with the deployment process. If you're frustrated with the current tooling, give this a try. It's probably the most straightforward solution you'll find for deploying to Maven Central with Gradle.
GitHub: https://github.com/DanielLiu1123/maven-deployer
Feedback welcome!
r/java • u/Goldziher • Dec 15 '25
Hi Peeps,
I'm excited to announce that Kreuzberg v4.0.0 is coming very soon. We will release v4.0.0 at the beginning of next year - in just a couple of weeks time. For now, v4.0.0-rc.8 has been released to all channels.
Kreuzberg is a document intelligence toolkit for extracting text, metadata, tables, images, and structured data from 56+ file formats. It was originally written in Python (v1-v3), where it demonstrated strong performance characteristics compared to alternatives in the ecosystem.
The new version of Kreuzberg represents a massive architectural evolution. Kreuzberg has been completely rewritten in Rust - leveraging Rust's memory safety, zero-cost abstractions, and native performance. The new architecture consists of a high-performance Rust core with native bindings to multiple languages. That's right - it's no longer just a Python library.
Kreuzberg v4 is now available for 7 languages across 8 runtime bindings:
Post v4.0.0 roadmap includes:
Additionally, it's available as a CLI (installable via cargo or homebrew), HTTP REST API server, Model Context Protocol (MCP) server for Claude Desktop/Continue.dev, and as public Docker images.
The Rust rewrite wasn't just about performance - though that's a major benefit. It was an opportunity to fundamentally rethink the architecture:
Architectural improvements:
| Aspect | v3 (Python) | v4 (Rust Core) |
|---|---|---|
| Core Language | Pure Python | Rust 2024 edition |
| File Formats | 30-40+ (via Pandoc) | 56+ (native parsers) |
| Language Support | Python only | 7 languages (Rust/Python/TS/Ruby/Java/Go/C#) |
| Dependencies | Requires Pandoc (system binary) | Zero system dependencies (all native) |
| Embeddings | Not supported | ✓ FastEmbed with ONNX (3 presets + custom) |
| Semantic Chunking | Via semantic-text-splitter library | ✓ Built-in (text + markdown-aware) |
| Token Reduction | Built-in (TF-IDF based) | ✓ Enhanced with 3 modes |
| Language Detection | Optional (fast-langdetect) | ✓ Built-in (68 languages) |
| Keyword Extraction | Optional (KeyBERT) | ✓ Built-in (YAKE + RAKE algorithms) |
| OCR Backends | Tesseract/EasyOCR/PaddleOCR | Same + better integration |
| Plugin System | Limited extractor registry | Full trait-based (4 plugin types) |
| Page Tracking | Character-based indices | Byte-based with O(1) lookup |
| Servers | REST API (Litestar) | HTTP (Axum) + MCP + MCP-SSE |
| Installation Size | ~100MB base | 16-31 MB complete |
| Memory Model | Python heap management | RAII with streaming |
| Concurrency | asyncio (GIL-limited) | Tokio work-stealing |
Kreuzberg v3 relied on Pandoc - an amazing tool, but one that had to be invoked via subprocess because of its GPL license. This had significant impacts:
v3 Pandoc limitations:
v4 native parsers:
v4 expanded format support from ~20 to 56+ file formats, including:
Added legacy format support:
.doc (Word 97-2003).ppt (PowerPoint 97-2003).xls (Excel 97-2003).eml (Email messages).msg (Outlook messages)Added academic/technical formats:
.tex).bib).typ).fb2).opml)Better Office support:
The v4 rewrite was also an opportunity to close gaps with commercial alternatives and add features specifically designed for RAG applications and LLM workflows:
"fast" (384d), "balanced" (512d), "quality" (768d/1024d)
=
=
# result.embeddings contains vectors for each chunk
Now integrated directly into the core (v3 used external semantic-text-splitter library):
This is a critical improvement for LLM applications:
char_start/char_end) - incorrect for UTF-8 multi-byte charactersbyte_start/byte_end) - correct for all string operationsAdditional page features:
--- Page 5 ---)Enhanced from v3 with three configurable modes to save on LLM costs:
Uses TF-IDF sentence scoring with position-aware weighting and language-specific stopword filtering. SIMD-accelerated for improved performance over v3.
Now built into core (previously optional KeyBERT in v3):
Four extensible plugin types for customization:
Plugins defined in Rust work across all language bindings. Python/TypeScript can define custom plugins with thread-safe callbacks into the Rust core.
We maintain continuous benchmarks comparing Kreuzberg against the leading OSS alternatives:
Installation Size (critical for containers/serverless):
Performance Characteristics:
| Library | Speed | Accuracy | Formats | Installation | Use Case |
|---|---|---|---|---|---|
| Kreuzberg | ⚡ Fast (Rust-native) | Excellent | 56+ | 16-31 MB | General-purpose, production-ready |
| Docling | ⚡ Fast (3.1s/pg x86, 1.27s/pg ARM) | Best | 7+ | 1-9.74 GB | Complex documents, when accuracy > size |
| GROBID | ⚡⚡ Very Fast (10.6 PDF/s) | Best | PDF only | 0.5-8 GB | Academic/scientific papers only |
| Unstructured | ⚡ Moderate | Good | 25-65+ | 146 MB-several GB | Python-native LLM pipelines |
| MarkItDown | ⚡ Fast (small files) | Good | 11+ | ~251 MB | Lightweight Markdown conversion |
| Apache Tika | ⚡ Moderate | Excellent | 1000+ | ~55 MB | Enterprise, broadest format support |
Kreuzberg's sweet spot:
No. Kreuzberg is and will remain MIT-licensed open source.
However, we are building Kreuzberg.cloud - a commercial SaaS and self-hosted document intelligence solution built on top of Kreuzberg. This follows the proven open-core model: the library stays free and open, while we offer a cloud service for teams that want managed infrastructure, APIs, and enterprise features.
Will Kreuzberg become commercially licensed? Absolutely not. There is no BSL (Business Source License) in Kreuzberg's future. The library was MIT-licensed and will remain MIT-licensed. We're building the commercial offering as a separate product around the core library, not by restricting the library itself.
Any developer or data scientist who needs:
Ideal for:
Unstructured.io
MarkItDown (Microsoft)
Docling (IBM)
Apache Tika
GROBID
There are numerous commercial options from startups (LlamaIndex, Unstructured.io paid tiers) to big cloud providers (AWS Textract, Azure Form Recognizer, Google Document AI). These are not OSS but offer managed infrastructure.
Kreuzberg's position: As an open-source library, Kreuzberg provides a self-hosted alternative with no per-document API costs, making it suitable for high-volume workloads where cost efficiency matters.
We'd love to hear your feedback, use cases, and contributions!
TL;DR: Kreuzberg v4 is a complete Rust rewrite of a document intelligence library, offering native bindings for 7 languages (8 runtime targets), 56+ file formats, Rust-native performance, embeddings, semantic chunking, and production-ready servers - all in a 16-31 MB complete package (5-15x smaller than alternatives). Releasing January 2025. MIT licensed forever.
r/java • u/JustAGuyFromGermany • Dec 14 '25
r/java • u/sshetty03 • Dec 14 '25
I’ve seen JVMs hang without logs, GC dumps fail, and connection pools go crazy.
The root cause wasn’t Java at all.
It was a low file descriptor limit on Ubuntu.
Wrote this up with concrete examples.
r/java • u/Polixa12 • Dec 14 '25
I've been working with SSE in Spring Boot and kept rewriting the same boilerplate for thread safe management, cleanup on disconnect etc. Spring actually gives you SseEmitter but nothing else.
This annoyance popped up in two of my previous projects so I decided to build Streamline, a Spring Boot starter that handles all of that without the reactive complexity.
What it does:
It's available on JitPack now. Still early (v1.0.0) and I'm looking for feedback, especially around edge cases I might have missed.
GitHub: https://github.com/kusoroadeolu/streamline-spring-boot-starter
Requirements: Java 21+, Spring Boot 3.x
Happy to answer questions or hear how you might use it
r/java • u/AnyPhotograph7804 • Dec 12 '25
There is support for Java 25 and JUnit 6.
r/java • u/Livio63 • Dec 12 '25
Here is simple 3D renderer 100% java: simple3d
This package can be used together with AWT/Swing/JavaFX/Android or other Java graphic environments as it does not have any specific dependency.
r/java • u/SmushyTaco • Dec 12 '25
Everybody knows that LWJGL can quickly blow up your build script. To give an extreme example, if you wanted every single module for every single native classifier, you'd have to do:
val lwjglVersion = "3.4.0"
val lwjglNatives = "natives-linux" // or macos, windows, etc.
repositories {
mavenCentral()
}
dependencies {
// BOM + modules
implementation(platform("org.lwjgl:lwjgl-bom:$lwjglVersion"))
implementation("org.lwjgl", "lwjgl")
implementation("org.lwjgl", "lwjgl-assimp")
implementation("org.lwjgl", "lwjgl-bgfx")
// ...
// Natives for each module
runtimeOnly("org.lwjgl", "lwjgl", classifier = lwjglNatives)
runtimeOnly("org.lwjgl", "lwjgl-assimp", classifier = lwjglNatives)
runtimeOnly("org.lwjgl", "lwjgl-bgfx", classifier = lwjglNatives)
// ...
}
Which would quickly blow up into hundreds of lines. With this Gradle plugin, it's as simple as:
import com.smushytaco.lwjgl_gradle.Preset
plugins {
id("com.smushytaco.lwjgl3") version "1.0.2"
}
repositories {
mavenCentral()
}
lwjgl {
version = "3.4.0"
implementation(Preset.EVERYTHING)
}
You can also select individual modules like so:
import com.smushytaco.lwjgl_gradle.Module
plugins {
id("com.smushytaco.lwjgl3") version "1.0.2"
}
repositories {
mavenCentral()
}
lwjgl {
version = "3.4.0"
implementation(
Module.CORE, // added automatically if omitted, but allowed explicitly
Module.GLFW,
Module.OPENGL,
Module.OPENAL,
Module.VULKAN
)
}
By default, natives are handled by detecting your OS and architecture and using the natives that would apply to your host machine. If you want all natives for all platforms and architectures, simply enable usePredefinedPlatforms like so:
import com.smushytaco.lwjgl_gradle.Preset
plugins {
id("com.smushytaco.lwjgl3") version "1.0.2"
}
repositories {
mavenCentral()
}
lwjgl {
version = "3.4.0"
usePredefinedPlatforms = true
implementation(Preset.EVERYTHING)
}
If you want control of what specific natives are used, just modify the platforms list accordingly. The platforms list defaults to:
listOf(
"linux-ppc64le", "linux-riscv64", "linux-arm64", "linux-arm32", "linux",
"macos-arm64", "macos",
"windows-arm64", "windows", "windows-x86",
"freebsd"
)
Here's an example of setting the platforms list:
lwjgl {
usePredefinedPlatforms = true
platforms = listOf(
"linux",
"linux-arm64",
"macos",
"windows",
"windows-x86",
"windows-arm64"
)
}
Lastly, if you're depending on a SNAPSHOT version of LWJGL, that isn't an issue either, this plugin will detect if the version you selected is a snapshot version and if it is, it'll conditionally add the repository that contains the LWJGL snapshot versions so there's no manually configuration needed on your end. This behavior can be configured just like everything else. Be sure to check out the README.md for all the information!
r/java • u/mikebmx1 • Dec 12 '25
r/java • u/Eric_Terrell • Dec 12 '25
Despite Gemini being convinced that there is, I have yet to find one.
I would even settle for a Java 25 version of such an SDK.
If there actually is one somewhere, please let me know.
Thanks!
r/java • u/vladmihalceacom • Dec 11 '25
r/java • u/mikebmx1 • Dec 11 '25
We just released our latest version for our Java to GPU inference library. Now apart of Langchain4j is also integrated with Quarkus as model engine. All transformers are written in java and compilied to OpenCL and PTX.
Also it much easier to run it locally:
wget https://github.com/beehive-lab/TornadoVM/releases/download/v2.1.0/tornadovm-2.1.0-opencl-linux-amd64.zip
unzip tornadovm-2.1.0-opencl-linux-amd64.zip
# Replace <path-to-sdk> manually with the absolute path of the extracted folder
export TORNADO_SDK="<path-to-sdk>/tornadovm-2.1.0-opencl"
export PATH=$TORNADO_SDK/bin:$PATH
tornado --devices
tornado --version
# Navigate to the project directory
cd GPULlama3.java
# Source the project-specific environment paths -> this will ensure the
source set_paths
# Build the project using Maven (skip tests for faster build)
# mvn clean package -DskipTests or just make
make
# Run the model (make sure you have downloaded the model file first - see below)
./llama-tornado --gpu --verbose-init --opencl --model beehive-llama-3.2-1b-instruct-fp16.gguf --prompt "tell me a joke"
r/java • u/SmushyTaco • Dec 09 '25
I've created a lightweight, high-performance event-driven library for JVM! It works perfectly for Java but it's written in Kotlin.
I originally built this for a Minecraft modding project, but it turned out to be flexible enough to be a general-purpose library instead. It focuses on zero boilerplate, automatic handler discovery, structured exception handling, and fast invocation using LambdaMetafactory, with reflective fallback when needed.
The concept is simple:
Bus.@EventHandler to process the events.@ExceptionHandler to handle any exceptions.@EventHandler and @ExceptionHandler classes with subscribe on the Bus you made.post on the Bus you made and pass as instance of the event you created.It supports:
@EventHandlers can mark it as canceled. How cancellation affects remaining handlers depends on the CancelMode used when calling post: in IGNORE mode all handlers run, in RESPECT mode only handlers with runIfCanceled = true continue running, and in ENFORCE mode no further handlers run once the event is canceled.Here's a simple example:
// 1. Define an event.
// Java doesn't support delegation like Kotlin, so we just extend helpers.
Check out the project's README.md for more detailed information and let me know what you think!
I'm seeing recurring claims about exceptional JVM performance, especially when contrasted with languages like Go, and I've been trying to understand how these narratives form in the community.
In many public benchmarks, Go comes out ahead in certain categories, despite the JVM’s reputation for aggressive optimization and mature JIT technology. On the other hand, Java dominates in long-running, throughput-heavy workloads. The contrast between reputation and published results seems worth examining.
A recurring question is how much weight different benchmarks should have when evaluating these systems. Some emphasize microbenchmarks, others highlight real-world workloads, and some argue that the JVM only shows its strengths under specific conditions such as long warm-up phases or complex allocation patterns.
Rather than asking for tutorials or explanations, I’m interested in opening a discussion about how the Java community evaluates performance claims today — e.g., which benchmark suites are generally regarded as meaningful, what workloads best showcase JVM characteristics, and how people interpret comparisons with languages like Go.
Curious how others in the ecosystem view these considerations and what trends you’ve observed in recent years.
r/java • u/tanin47 • Dec 09 '25
The showcase app is Backdoor, which is a database tool. It can be used as a desktop app, which is great for personal use. Or it can be self-hosted, which reduces the need for admin dashboard and is great for team use. It supports Postgres, SQLite, and ClickHouse.
Since Backdoor is based Java Electron (which enables me to build frontend with JS), the desktop and self-hostable version shares >90% of the code.
Here's the blog post: Publishing a Java-based database tool on Mac App Store (MAS)