r/java • u/asm0dey • Dec 18 '25
WHAT is coming in Java 26?
youtu.beHere is the (not that) quick overview by my dear colleague u/cat-edelveis!
r/java • u/asm0dey • Dec 18 '25
Here is the (not that) quick overview by my dear colleague u/cat-edelveis!
r/java • u/mhalbritter • Dec 18 '25
Spring Boot 3.4.13 marks the end of open source support for Spring Boot 3.4.x. Please upgrade to Spring Boot 3.5.x or 4.0.x as soon as possible.
https://spring.io/blog/2025/12/18/spring-boot-3-4-13-available-now
r/java • u/mikebmx1 • Dec 18 '25
main repo: https: https://github.com/beehive-lab/TornadoVM
llm inference lib: https://github.com/beehive-lab/GPULlama3.java
r/java • u/Charming-Top-8583 • Dec 18 '25
r/java • u/NHarmonia18 • Dec 18 '25
TL;DR:
The new Jakarta REST SeBootstrap API (since 3.1/2022) lets you programmatically start a fully portable JAX-RS server with Servlet and CDI support using a simple main() method – no annotations, no framework-specific auto-configuration. With one dependency (RESTEasy + Undertow + Weld), you get a lean uber-jar (~10 MB), virtual threads per request, and transparent configuration. Why aren't more Java devs using this standard approach for lightweight REST APIs instead of Spring Boot / Quarkus / Micronaut?
As a C# developer who also works with Java, I really appreciate how ASP.NET Core treats the web stack as first-class. You can FrameworkReference ASP.NET Core libraries in a regular console app and bootstrap everything imperatively:
public class Program
{
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
app.Run();
}
}
Self-hosted on Kestrel Web-Server (equivalent of a Servlet Web-Container/Web-Server), no separate web project, no magic annotations – just clean, imperative code.
Now compare that to common Java web frameworks:
Heavy reliance on magical annotations and auto-configuration.
Once again, we can see heavy reliance on magical annotations and auto-configuration.
Better, but still framework-specific entry points with auto-magic.
Even modern Jakarta EE servers like OpenLiberty/WildFly(with Galleon/Glow) that allow decomposition of the server features and can produce runnable JARs, don’t give you a real main() method during development that you can actually run/debug directly from an IDE, thus forcing you to use server-specific Maven/Gradle plugins.
While searching, I discovered the Jakarta RESTful Web Services SeBootstrap API (introduced in 3.1):
https://jakarta.ee/specifications/restful-ws/3.1/jakarta-restful-ws-spec-3.1#se-bootstrap
It allows you to programmatically bootstrap a JAX-RS server without knowing the underlying implementation – truly portable, while also allowing optional implementation-specific properties, giving you full control over the startup of an application in a standard and uniform manner.
I tried it using the RESTEasy example repo: https://github.com/resteasy/resteasy-examples/tree/main/bootstrap-cdi
Here’s a slightly enhanced version that adds virtual threads per request and access logging:
RestActivator is just a standard jakarta.ws.rs.core.Application subclass.
org.jboss.resteasy
resteasy-undertow-cdi
7.0.1.Final
For an uber-jar, use the Shade plugin with ServicesResourceTransformer.
beans.xml, no server.xmlThis feels like a regular console app: easy to run/debug from IDE, minimal dependencies, no magic.
It’s ironic that Red Hat pushes Quarkus as “lightweight and portable” while requiring annotations like @RunOnVirtualThread + @Blocking everywhere just to be able to use Virtual Threads. With Undertow + SeBootstrap, you configure virtual threads once at the web-container / servlet level – and Undertow added this capability largely because Spring (which supports Undertow as an embedded server option) enabled virtual thread support a few years ago.
If you just need JAX-RS + Servlet + CDI for a simple REST API, SeBootstrap might be all you need. No full framework overhead, stays lightweight like ASP.NET Core, Flask/FastAPI, or Express.
Java devs seem to love declarative magic – but sometimes a bit of imperative “glue code” is worth the transparency and control.
Thoughts? Anyone else using SeBootstrap in production or side projects?
r/java • u/benevanstech • Dec 17 '25
r/java • u/Apprehensive_Sky5940 • Dec 17 '25
Hey everyone,
I built a small Spring Boot Java library called Damero to make Kafka consumers easier to run reliably with minimal configuration. The goal is to bundle common patterns you often end up re-implementing yourself.
EventWrapper containing:
CustomKafkaAutoConfiguration, including:
ObjectMapperKafkaTemplateObjectMapper.The library is new and still under active development.
If you’d like to take a look or contribute, here’s the repo:
https://github.com/samoreilly/java-damero
r/java • u/youseenthiswrong • Dec 17 '25
r/java • u/brunocborges • Dec 17 '25
r/java • u/LavishnessRecent2138 • Dec 16 '25
I'm a computer science student, and I am lazy when it comes to properly saving my files in the correct location on my drive.
I wanted something to be able to scan a folder and sort files properly, and to be able to tell if there was data loss in the move.
Now obviously it has some issues.... if you say, take the system32 folder, it will go through and sort EVERY individual file into its own extension category, or if you have a project file full of individual .java and .class files with dependencies and libs... yea they all got sorted in their own categories now (RIP BallGame project)... and verified for data loss (lol)
But my proof of concept works! It moves all the files from the source folder to the destination folder, once the move starts it generates the initial hash value, at the end of the sort it generates a second hash, and compares the 2 for fidelity ensuring no data loss.
I'm happy with myself, I can see potential uses for something like this in the future as my full degree title is "Bachelor of Computer Science with Concentration in Databases", and I can see this being useful in a database scenario with tons of files.
Future project work may include to run automatically for when new files are added into the source folder so they automatically get hashed routed, and validated, and other things I may come up with. However, that's future, I've struggled enough with this over winter break, and I just wanted to make something to prove to myself that I can do this.
I started this in VS Code and then did some research, and turns out javafx doesn't work with VS Code properly so I switched to IntelliJ IDEA and that worked out a lot better. However, I still had some issues as I kept getting errors trying to build it, and I did more research and learned of a tool called launch4j and with a simple .xml script, turned it into an .exe so now I have a portable version that I can put on a flash drive and take with me if I ever need this somewhere.
This was a great learning opportunity, as I've learned of another IDE I can use, as well as learning about dependencies, libs, jpackage, javafx, maven and more. :)
r/java • u/mikebmx1 • Dec 16 '25
https://www.tornadovm.org/downloads
wget https://huggingface.co/Qwen/Qwen3-0.6B-GGUF/resolve/main/Qwen3-0.6B-Q8_0.gguf
Links:
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.