BoxLang is a modern dynamic JVM language built for rapid application development. It's 100% Java-interoperable, compiles to JVM bytecode, and deployable anywhere from OS to AWS Lambda to Spring Boot. In this episode, we sit down with Luis Majano (CEO of Ortus Solutions and creator of BoxLang) and Cristobal Escobar (BoxLang community manager) to dig into the wave of innovation that has hit the platform over the past few months.

We cover the BoxLang AI v3 release, a major overhaul that ships multi-agent orchestration with parent-child hierarchies, an AI Skills system based on Anthropic's open standard, MCP server integration (both consuming and serving), a composable middleware layer with six built-in classes including a FlightRecorder for deterministic CI testing, and a unified API spanning 17 AI providers. Luis and Cristobal walk us through the highlights of a 7-part BoxLang AI deep dive series, covering tools, memory systems & RAG, streaming, middleware, and MCP. We also touch on the BoxLang Spring Boot Starter, BoxLings (an interactive TDD/BDD learning platform), and TestBox 7's real-time streaming test runner.

Whether you're a Java developer curious about dynamic JVM languages, an AI engineer looking for a productive alternative to Python-based agent frameworks, or just want to see what the JVM ecosystem can do in 2026, this episode is for you.

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Guests

• Luis Majano
  • Foojay author page
  • LinkedIn
• Cristobal Escobar
  • Foojay author page
  • LinkedIn

Links

• On the BoxLang website:
  • BoxLang docs
  • BoxLang AI docs
  • BoxLang Academy
  • BoxLang for desktop applications
  • BoxLang Spring Boot Starter
  • BoxLings
  • Announcing MatchBox Open Beta: BoxLang, Now Running in New Places
  • Try BoxLang
• On Foojay:
  • Overview of all recent BoxLang AI articles: Complete Guide to Building AI Agents
  • BoxLang AI v3 Has Landed
  • BoxLang AI Deep Dive series, Parts 1–7
  • How to Develop AI Agents Using BoxLang AI: A Practical Guide
  • Introducing the BoxLang Spring Boot Starter
  • Introducing BoxLings!
  • Introducing skills.boxlang.io — The Open Agent Skills Ecosystem for BoxLang & the Ortus World

Content

00:00 Introduction of topic and guests
01:17 What is BoxLang and how to use it
05:25 Multi-runtime (WASM) with MatchBox, based on Rust
07:00 Combining BoxLang with Spring Boot
10:40 The abstraction approach in BoxLang AI, compared with LangChain4j and others
14:18 Markdown skill files similar to Claude are also used in BoxLang AI
15:21 About the 7-part Foojay BoxLang Deep Dive posts series, agents, event-driven,...
19:28 BoxLang can be used for MCP server and client
23:01 Premium features in BoxLang and building a company on an open-source project
27:52 BoxLings, an interactive learning tool for BoxLang that teaches TDD and BDD
30:25 TestBox 7, real-time streaming test execution and a browser-based IDE
32:58 How to get started with BoxLang?
34:14 How the evolutions in the JVM and Java language influence BoxLang development
39:33 Which article to read first on Foojay about BoxLang?
43:27 More learning resources and ideas for the future and desktop development
48:05 Conclusions

The post Foojay Podcast #97: From Scripting Language to AI Powerhouse: How BoxLang Is Redefining JVM Development appeared first on foojay.

Here are the JavaFX LinksOfTheMonth of May 2026. You can find the weekly lists on jfx-central.com. Did we miss anything? Is there anything you want to have included in one of the next overviews? Let us know via links@jfx-central.com.

Applications

• Gerrit Grunwald: "After a nice 14km morning walk, I’ve modified the prediction mode in my little JavaFX diabetes app and created a new release... and all of that before 8am... great start into the Sunday. 😁"
• Message from JabRef: "We are excited that we are participating in GSOC2026 with 3 projects:"
  • Improved handling of older documents with OCR and AI-powered tools.
  • Improved LibreOffice-JabRef integration with one particular aspect of compatibility with other reference managers.
  • Improving startup times for JabKit by leveraging the power of GraalVM
• David Gutiérrez released version 1.8.0 of JMathAnim, a Java editor to make mathematical animations: "featuring JavaFX effects for each individual object, improvements to autocomplete and the editor, code polishing, and numerous bug fixes." Sources are available here.
• Pedro Duke shared a video of IKE: "Demo: users create custom Knowledge Layout windows,then use them to view/edit/create Components tailored to their workflow. Built for healthcare, involving standards and terminologies like HL7, SNOMED CT, LOINC, RxNorm."
• Ilmetallaro built a 100% offline PDF utility app using Java 25, JavaFX and AtlantaFX (GPLv3): "LibrePDF is focused on 100% privacy. It makes zero HTTP calls, everything stays locally on your machine, and it doesn't even support logging. I was sick and tired of uploading my personal data to cloud giants (like iLovePDF, Smallpdf, etc.) or relying on sketchy closed-source freeware." You can find the code, binaries, and more info here.
• Leo Xiong shared a screenshot of work-in-progress: "Hello! I'm Lucy, your AI assistant. How can I help you with your database queries today? The AI-native database management tool journey has finally begun."
• Bruno Borges on Bluesky: "And to think that I did port a 2048 game #JavaScript implementation to a Java + JavaFX desktop version, all by hand a long time ago! Copilot just helped enhance further... Available on brunoborges.github.io/fx2048"
• Robert Ladstätter shared a behind the scenes: "LogoRRR’s latest tutorial video was made with JavaFX too. The app, overlays, effects, voice, and recording pipeline all come together in one generated video."
• Marcus Hirt is looking for people wanting to try out, and maybe even participate in, a little hobby project: DiskSpace: "A cross-platform disk space visualizer that shows where your space went, with two complementary views: a sunburst (hierarchical radial layout, good for spotting depth-imbalanced subtrees and proportional weight at a glance) and a squarified-treemap heatmap (good for finding the largest individual cells across the whole tree). Press V to toggle."

Components, Libraries, Tools

• A (removed) message by Street_Humor_7861 on Reddit: "Early contributors wanted for TailwindFX. An utility-first UI framework for JavaFX (MIT, 1.0-SNAPSHOT, actively developed). I'm building TailwindFX, an open-source framework that brings Tailwind CSS's utility-first paradigm to JavaFX. Instead of writing verbose CSS/FXML or inline -fx-* styles, you compose UIs with familiar utility classes and type-safe Java APIs." Check the repository here.
• Striking_Creme864 on Reddit: "We recently introduced our CEFFX project (a library for integrating the Chromium Embedded Framework into JavaFX) and it was well received. Based on that feedback, we decided to simplify its usage by providing prebuilt native libraries. This allows you to use the library without having to compile anything yourself. All native binaries are packaged into the ceffx-natives module using classifier names similar to those in OpenJFX."
• Message by Dirk Lemmermann: "GemsFX 4.0.1 is out and has been 'downgraded' back to using Java 11 and JavaFX 17 due to popular demand. I also added a new sampler demo auto-update installer (jdeploy) that you can download here. The demo uses Java 24 and JavaFX 25."
• Screenshot shared by Dirk Lemmermann: "GemsFX 4.0.4 is out on Maven Central with fixes to the styling of the InfoCenterView. Try it out via the installer. Browse the available controls at gemsfx.dlsc.com."
• Message shared by Austin Lehman: "Aussom-Lang now has support for JavaFX, GTK4, a Java native interface with dynamic Jar loading, and native library interface via Panama. Quite a bit that can be done with it now. Aussom is a safe, sandboxed scripting language for the JVM. Embed it in your Java app, run it on the server with Aussom Server, or use it in the browser with Aussom-Script." A JavaFX example is available in the documentation.
• Frank Delporte announced "V1.2.3 of Lottie4J, the library for parsing Lottie animations as Java objects and playing them as JavaFX animations. In this release: improved unit tests, data model and player improvements, and more! All info in the release notes."
• Kareem shared a video on Reddit of DockTask: "JavaFX dynamic JAR based plugin system. The idea is pretty straightforward: users can upload their own JARs, and the app will load them at runtime thanks to Java's serviceloader. It also connects to a remote repo to browse and display plugin information. It's still a work in progress, but I'm really curious about what people think of this system. Any feedback would be appreciated! Check it on GitHub."
• Dirk Lemmermann shared a screenshot with a lot of AtlantaFX themes: "Release 1.3.0 of the new collection of AtlantaFX themes is out now and published on Maven Central. A total of 25 themes (14 dark, 11 light). Use the plain CSS files or the Java API."
• Republished on Foojay "JavaFX 26's new headless mode solves a real problem: testing animations in CI/CD pipelines without a display server. Frank Delporte shows how to use it with Lottie4J in GitHub Actions."
• Lee Wyatt shared a video about JavaFX Tools: "JavaFX Tools now includes four ways to generate or complete JavaFX property code":
  • Alt+Enter accessor intention
  • fxp* completions
  • Generate menu: JavaFX Property Accessors
  • Generate menu: JavaFX Property
• Striking_Creme864 on Reddit: "Recently, we introduced Weaverbird - a framework for working with dynamic plugins. In this post, we want to show a real example of how it can be used. The GUI is build on top of TabShell. The main idea is that a plugin configuration is represented as an XML file. When the application is distributed, it already contains predefined plugin configurations (at the same time, users can add their own plugins). A configuration contains module definitions, repositories used to download them, plugin metadata, and other related information."
• Last week, we included a link to the message by Dirk Lemmermann about AtlantaFX Themes. Now, there is also a website at with screenshots of all themes. "Each theme overrides the color scale, semantic tokens, and dark / light mode flag without touching the upstream stylesheet."
• Dirk Lemmermann announced version 4.1.0 of GemsFX: "now includes an AtlantaFX companion stylesheet for ControlsFX. You can use the method ControlsFXAtlantaFX.apply() to add this new stylesheet to your scene or any parent node. By doing so you will be able to get rid of all those pesky warning / error messages regarding CSS rules using unknown colors. For more on GemsFX see gemsfx.dlsc.com."

Podcasts, Videos, Books

• Video by BabyDevCode: "How to Run JavaFX Projects in Visual Studio Code." The original is in Spanish, but also available in auto-dubbed English.
• Recording of the JavaOne '26 talk by Phil Race: The JDK Client Desktop : 2026 and Still Swinging: "In this session, we explore how Swing fits into today’s Java ecosystem, how it works seamlessly alongside JavaFX, and why it can still outperform web-based approaches for certain desktop applications."
• Republished on Foojay: "Frank Delporte walks through debugging BentoFX in MelodyMatrix using Scenic View with Matt Coley, plus a realistic look at AI-generated code and its challenges."
• Video by Florian Enner showing his JavaFX charts and 3D visualizations in JavaFX from within MATLAB.
• New impressive video by Florian Enner of the JavaFX HEBI Charts showing 50 KHz update, 100 subplots, chart with 1000 lines, and more. You can find the example repo on GitHub.

Tutorials

• New tutorial by Ana-Maria Mihalceanu: "Accessibility in JavaFX". "JavaFX provides accessibility APIs and properties that help you build inclusive user interfaces. A good starting point is to rely on standard controls and ensure that your user interface employs proper semantics. From there, you can customize accessible metadata and fine-tune how components behave for assistive technologies."

Conferences, Presentations

• On June 16th, the JFX Adopters Meeting will take place in Munich, Germany. "We will be hosting a JFX Adopters Meeting to exchange information on current projects and future plans. Representatives of the JavaFX 'ecosystem' will also be there to help develop a viable picture of JavaFX. The success of future developments depends on the contribution of adopter companies making our community stronger."

Miscellaneous

• In the JVM Weekly vol. 173, by Artur Skowroński: "MelodyMatrix by Frank Delporte isn't important for what it does (it's a music-related tool) - it's important as a case study for how to ship a JavaFX desktop app in 2026. The release walkthrough on Foojay covers the full pipeline: jdeploy for cross-platform native installers, GitHub Actions for the build, auto-update integration, the works."
• Dirk Lemmermann is asking to get JetBrains to fix a JavaFX-related issue in IntelliJ IDEA."It is so disruptive to my 'flow'."

JFX Central

• The JavaFX Links Of The Week of April got bundled and published on Foojay.io.

The post JavaFX Links of May 2026 appeared first on foojay.

What if you could run 35 AWS services locally in under 25 milliseconds, using just 13 megabytes of memory, with a single Docker command and no cloud bill? That's exactly what Floci does.

In this episode, Frank Delporte talks with Hector Ventura, the creator of Floci, a free and open-source cloud emulator built with Quarkus and GraalVM native compilation. Hector walks us through why he built it when LocalStack dropped its open-source community edition, how AI tooling helped him accelerate development of new service integrations, the challenges of keeping GraalVM happy with third-party libraries, and the road ahead for Azure and GCP support.

If you're a developer who wants fast local testing, a DevOps engineer writing Terraform, or a student learning cloud without the cost, Floci is worth a look!

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Guest: Hector Ventura

• Foojay Author page
• LinkedIn

Links

• On Foojay: Introducing Floci: A High-Performance, GraalVM-Powered AWS Emulator
• Floci project site
• Floci on GitHub
• Migrate from LocalStack

Content

00:00 Introduction of topic and guest
01:48 What is Floci?
02:15 How Floci compares to LocalStack
03:01 Why Hector started Floci
04:02 Floci emulates the cloud APIs
05:02 How additional services got integrated with AI assistance
06:31 Meaning of the name Floci
07:07 Why Quarkus and GraalVM as the starting point for Floci
09:35 How Floci starts up very fast and only uses a low amount of memory
12:18 GraalVM can be hard with some libraries or frameworks
14:02 What is needed to use Floci
14:56 The challenges to support AWS, Azure, GCP and finding contributors
20:24 Funding Floci
21:04 How data is persisted in Floci
22:37 Verifying Floci versus the "real" APIs with compatibility tests
23:56 In the future: UI for Floci
25:04 Biggest challenges while creating Floci
25:32 Functionality compared between Floci and LocalStack and migrating
28:15 Feedback from the Floci users
28:58 Long-term plans for Floci
29:59 Biggest surprises during the development of Floci
31:00 Best use-cases for Floci
32:12 In the next releases...
33:31 How to get started with Floci
35:00 Conclusion

The post Foojay Podcast #96: Local AWS Development Without LocalStack: Meet Floci, the GraalVM-Powered Alternative appeared first on foojay.

Previously in this series:

• Trusted Java Containers: Azul Zulu OpenJDK Joins Docker’s Official Images
• The Road to Docker Official Images for Java: The Azul Zulu Story
• Using the Azul Zulu Docker Official Images: From Simple Pull to Lean Container

The launch of Azul Zulu as Docker Official Images was a milestone, but it’s just one of several ways to get Azul Zulu Builds of OpenJDK in a container. Depending on whether you’re evaluating Azul Zulu, running it in production under a support contract, or operating in a high-security environment, the right image source will vary. In this post, I’ll show you all the possibilities.

First: Understanding Community vs. Subscriber Availability

Before looking at what’s available where, it helps to understand the two flavors of Azul Zulu Builds of OpenJDK (Zulu):

Community Availability (CA) builds are free to download and use: no account, no token, no license agreement beyond the open-source terms. These are what you get on Docker Hub and what the new Docker Official Images are based on. They’re a great fit for evaluation, development, open-source projects, and any deployment where you don’t need a commercial support contract.

Subscriber Availability (SA) builds are commercially supported, tested, and certified releases exclusively available to Azul customers. On top of everything CA provides, SA adds:

• Security updates beyond what the community releases
• Extended platform and configuration support
• Priority access to critical patches
• CPU and PSU release tracks (more on those below)
• Access to Azul Support engineers averaging 20+ years of Java experience

If you’re running Java in production and need guaranteed support when something breaks, SA is the right choice.

Getting Zulu CA in a Container

You can get Community Availability images from two sources, as explained below and with more details in the Azul Documentation in Running Azul Zulu CA in a Docker Container. The full list of available CA tags is also documented on Zulu CA Docker Tags and Zulu CA Docker Official Tags.

Docker Official Images (new)

The newest addition: azul-zulu is now a Docker Official Image on Docker Hub. These images don’t have a namespace prefix, are maintained by Azul, get reviewed by Docker, and are continuously scanned for CVEs.

docker pull azul-zulu:21
docker pull azul-zulu:21-jre
docker pull azul-zulu:25

This is the recommended starting point for any new project. Full details and example usage are explained in the previous posts of this blog post series (see links above).

Legacy Docker Hub Images (azul/zulu-openjdk-*)

The original Azul images on Docker Hub are still available and cover a wider range of base OS combinations:

Example usage:

docker pull azul/zulu-openjdk:21
docker run --rm azul/zulu-openjdk:21 java -version

These images will be deprecated later in 2026 as the Official Images expand to cover the same variants. If you’re starting something new today, prefer azul-zulu. If you’re using the old images, plan your migration.

Getting Zulu SA in a Container

Subscriber Availability images are delivered through two channels: Azul’s own private registry, and Chainguard’s registry.

Azul Customer Registry

SA images are hosted on Azul’s private container registry and require authentication with an access token. Azul customers can manage their access tokens through access.azul.com.

docker login sa.registry.azul.com
# Username: <your-ftp-username>
# Password: <your-access-token>

docker run -it sa.registry.azul.com/zulu-sa-ubuntu:17-jre

The SA registry provides images based on multiple base systems:

The full documentation is available on docs.azul.com: Running Azul Zulu SA in a Docker Container.

CPU vs PSU: Choosing the Right Update Track

SA builds are available in two update types:

• CPU (Critical Patch Updates): Contain fixes to security vulnerabilities and critical bug fixes only. CPU releases are based on prior-cycle PSU releases with security fixes applied, providing a low-risk deployment option for urgent security updates.
• PSU (Patch Set Updates): Include all CPU fixes plus additional non-security bug fixes. PSU releases align with OpenJDK quarterly releases, including both security fixes and general improvements.

You can identify the release type from the Zulu minor version in the tag:

• odd minor = CPU, e.g. 21.43
• even minor = PSU, e.g. 21.44

SA Tagging Scheme

SA images use both fixed version tags (pinned to a specific build) and mutable alias tags (always pointing to the latest of a given type):

Fixed version tags: immutable, safe to pin for reproducible deployments:

Mutable alias tags: convenient when you always want to use the latest version, but will pull different content over time:

Available Java versions for SA images currently include 8, 11, 17, 21, 25, and 26.

In a Dockerfile, you typically use a fixed version tag for production builds to ensure reproducibility, and a mutable alias in development or CI pipelines where you want automatic updates:

# Production: pin to an exact build
FROM sa.registry.azul.com/zulu-sa-ubuntu:21.44-21.0.8-jre AS runtime

# CI/development: always get the latest security patch
FROM sa.registry.azul.com/zulu-sa-ubuntu:21-cpu-jre AS runtime

For the complete tag listing, see the Zulu SA Docker Tags in the Azul Documentation.

Chainguard Images

For environments with strict supply chain security requirements, Azul Zulu SA is also available through Chainguard’s registry. This is part of the Chainguard Images collection, built on Wolfi, a purpose-built Linux undistro designed for minimal, secure containers.

Chainguard Zulu images offer:

• Minimal design, with no unnecessary software included
• Daily builds to ensure container images are up-to-date with available security patches
• High quality build-time SBOMs attesting to the provenance of all artifacts within the image
• Verifiable container image signatures
• Reproducible builds with Cosign and apko (read more about reproducibility)

docker pull cgr.dev/ORGANIZATION/zulu-jdk:latest
docker run -it --rm cgr.dev/ORGANIZATION/zulu-jdk:latest java -version

Replace ORGANIZATION with your organization’s name in the Chainguard registry. Access to the Chainguard registry requires authentication. That way, Chainguard can reach you if something important changes in an image you are using.

You can find more resources at Chainguard Academy, Chainguard Courses, and Running Azul Zulu SA in a Chainguard Container in the Azul Documentation.

Choosing the Right Image

Here’s a quick decision guide:

CPU versus PSU is a secondary choice for SA users: if your priority is minimizing the risk of change when applying security patches, pin to CPU releases. If you want all quarterly bug fixes alongside security fixes, use PSU.

What’s Missing? Tell Us.

The SA and Official image offerings are actively growing. If you need a specific Java version, base OS combination, or architecture that isn’t currently available, create an issue on GitHub in AzulSystems/azul-zulu-images. The Azul team is actively prioritizing based on demand.

Full documentation for each image source:

• CA Docker images: docs.azul.com/core/install/linux-ca-docker
• SA Docker images: docs.azul.com/core/install/linux-sa-docker
• SA Chainguard images: docs.azul.com/core/install/linux-sa-docker-chainguard
• All image tags: docs.azul.com/core/docker-image-tags

The post All Azul Zulu Container Images Explained: CA, SA, and Chainguard appeared first on foojay.

There are bugs you can solve by yourself, and bugs where you just need to sit down with someone who knows the internals. This video is in the second category. MelodyMatrix uses BentoFX for its dockable panel layout. Branches, leaves, tabs on the side, content panels that open and close. It works well until something fights the layout. But I had some visual problems I could not explain, some code that felt more complicated than it should be, and no good explanation for why.

When Your Layout Library Misbehaves, Call the Person Who Wrote It

So I asked Matt Coley if he had time to take a look. Matt is the creator of BentoFX, but he is also known for Recaf, a bytecode editor for Java that itself uses BentoFX heavily as its UI framework. That means when Matt looks at a BentoFX integration. He wrote the library and uses it heavily in his own project. If you want the full background on his work, there is an earlier interview: JavaFX In Action #22 with Matt Coley.

What BentoFX Actually Does

BentoFX is a docking and layout library for JavaFX. The core idea is that you have a tree of containers: branches split the space horizontally (or vertically if you rotate them), and leaves hold the actual content. Tabs let you stack multiple panels in one leaf.

In MelodyMatrix, this maps to a sidebar on the left, a main content area in the middle, and additional panels on the right. It is a clean model when you understand it, but there are some behaviors that are not immediately obvious. Pruning is one of them: when you close a panel, BentoFX removes the empty container and reorganizes the remaining branches. That is usually what you want, but if you are also managing widths or visibility yourself in code, things start to conflict. That was part of my problem.

Scenic View: Browser DevTools for JavaFX

This session reminded me that Scenic View exists and I should have been using it much earlier.

If you have done any web development, you know how useful browser inspect tools are. You hover over an element, you can see exactly what CSS is applied, what the padding is, why something is shifted by 12 pixels. Scenic View does the same thing for a running JavaFX application. It attaches to your running application and shows the scene graph live with all the layout properties.

We pulled it during the video to look at the tab header rotation issue I was having. Instead of guessing which CSS rule was causing the offset, we could see exactly what was happening in the layout tree. Embarrassingly, I had not used it before this session. It should be in your JavaFX debugging toolkit!

Some Honest Thoughts on AI-Generated Code

We also spent some time looking at code that had been written or modified by Claude and Copilot. Matt spotted it quickly: the code had the patterns you recognize after reviewing AI-generated output. The rotation fix for the tab headers was one example. The code did technically work, but it was fragile: it used CSS class lookups that would break if BentoFX changed anything internally. Matt's take was pragmatic: if it works now, and you have a way to update it when it breaks, fine. But it is worth knowing that is what you are dealing with.

The broader cleanup was straightforward once Matt explained how BentoFX manages its own leaf widths. I had added animation and width-tracking code essentially fighting the library. Removing it simplified things considerably and fixed one of the issues in the process. Not all AI-generated code is bad. But a code review from someone who knows the library beats prompting your way through it. This session was a good reminder of that.

We Might Have Found a Bug

BentoFX did something unexpected with divider modes when re-opening a panel that had been closed. Matt looked at his own source and said he suspected something was not right there. It is a 0.x library, but it is actively maintained and used in production in Recaf. Matt's response was immediate: file a ticket with reproduction steps.

Timeline

• 00:00 Introduction: Matt Coley, Recaf, BentoFX
• 02:19 How BentoFX is used in MelodyMatrix
• 04:18 Visual problems with the BentoFX integration
• 06:33 A look into the MelodyMatrix code
• 09:15 Changing tab position from top to side, and why the project uses Kotlin
• 16:25 Using Scenic View to debug a JavaFX layout live
• 22:38 How pruning affects visual BentoFX components
• 34:53 Cleaning up unneeded code: let BentoFX handle leaf widths, removing animations
• 41:33 We probably found a bug in BentoFX, and a look into the BentoFX source

Links

• JavaFX In Action #22 with Matt Coley, diving into bytecode and JARs with Recaf and JavaFX libraries
• Matt Coley:
  • GitHub
  • Website
  • JFX Central
• JavaFX libraries by Matt:
  • BentoFX
  • TreeMapFX
  • GLCanvasFX
• On JFX Central:
  • BentoFX
  • Recaf
  • PDFViewFX
  • Scenic View
• MelodyMatrix:
  • Website
  • Open-source viewers on GitHub

The post Debugging BentoFX in MelodyMatrix with Matt Coley, Scenic View, and an Honest Look at AI-Generated Code appeared first on foojay.

When I released Lottie4J 1.1.0, I mentioned something a bit embarrassing in the release notes and this blog post: there was a new unit test to compare the JavaFX player output against a JavaScript reference player, but it "can not run on CI, because it requires a display output." A TODO. A known limitation. One of those notes you write hoping future-you will figure it out.

JavaFX 26 was released on March 17, 2026 and includes a new headless platform, allowing me to get the test running on GitHub Actions without a display.

The Test, and Why It Mattered

The core challenge with Lottie4J is correctness. The Lottie format is complex with a lot of nested data, and my JavaFX renderer has to produce output that matches what a JavaScript player would show. Pixel-perfect is too ambitious, but "is this a close enough match" is a reasonable bar.

During development, I use a separate application within the Lottie4J project: LottieFileDebugViewer. This is a JavaFX application that loads a Lottie file and renders it both with the JavaFX player, and inside a Webview with the official Lottie player. This makes it easy to compare the result and debug differences by diving into the data structure and different layers.

Based on this debug viewer, I created a unit-test approach with two steps:

1. A WebViewScreenshotGenerator that I run once on my developer machine. It loads each animation in a JavaFX WebView using the LottieFiles JavaScript player, and captures screenshots of specific frames. These are the reference images and are committed to the repo.

2. The unit test CompareFxViewWithWebViewTest then renders the same animations with the Lottie4J JavaFX player, takes screenshots at the same frames, and compares pixel data against the references.

The reference images are generated once and committed. The test just checks that the JavaFX output stays consistent with them. If something breaks in the renderer, the test will catch it.

This was all working fine locally. The problem was GitHub Actions. The CI runner has no display and no graphics stack. So I disabled this test for CI with:

@DisabledIfEnvironmentVariable(named = "CI", matches = "true")

What Changed in JavaFX 26

JavaFX 26 added a Headless Platform Prototype built directly into the javafx.graphics module. No extra dependencies, no native libraries, no Monocle setup. You pass a single JVM flag:

-Dglass.platform=headless

That is it. JavaFX starts up, you get a functional toolkit, you can create scenes, render nodes, take snapshots, and run animations, all without a display attached. The Gluon team did the heavy lifting on this for JavaFX 26, and it makes CI testing of JavaFX components much more practical. The flag works the same way as running your application normally. The difference is that there is nothing being drawn to a screen. For testing purposes, that is exactly what you want. It also opens the door to server-side rendering, for example, to generate a snapshot of a UI component without a display.

The Catch: JavaFX 26 Requires Java 24

Lottie4J targets Java 21 and JavaFX 21. That is the LTS version most projects are still running on. As this version is widely adopted, I don't want to force users of the library to jump to a newer version just because I want fancier test infrastructure. So the main project stays on 21 (for now).

But JavaFX 26 requires Java 24 or higher to run. They bumped the compiled bytecode level to --release 24 in this release, so if you try to use it with an older JDK you get an error immediately. This means the test infrastructure has to use a different Java and JavaFX version than the main build. The solution I landed on was a Maven profile in the root pom.xml that overrides both version properties and configures the surefire plugin:

<profile>
    <!-- Activates JavaFX 26 headless windowing for unit tests in CI. -->
    <!-- Usage: mvn test -Pheadless-tests -->
    <id>headless-tests</id>
    <properties>
        <java.version>25</java.version>
        <javafx.version>26</javafx.version>
        <surefire.argLine.headless>
            -Dglass.platform=headless --enable-native-access=javafx.graphics
        </surefire.argLine.headless>
    </properties>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M5</version>
                <configuration>
                    <argLine>
                        --add-opens com.lottie4j.fxfileviewer/com.lottie4j.fxfileviewer=ALL-UNNAMED
                        -Dglass.platform=headless --enable-native-access=javafx.graphics
                    </argLine>
                </configuration>
            </plugin>
        </plugins>
    </build>
</profile>

When this profile is active, Maven bumps java.version to 25 and javafx.version to 26, so the dependency resolution picks up JavaFX 26 for the test classpath while the main source still compiles to Java 21 targets. The surefire plugin then passes two JVM arguments to the test JVM:

• -Dglass.platform=headless tells JavaFX to use the new headless glass backend instead of trying to connect to a display.
• --enable-native-access=javafx.graphics is required because the headless platform uses native code paths that the Java module system would otherwise block.

The --add-opens line gives the test runner access to the fxfileviewer module internals it needs to load and compare the rendered output.

The fxfileviewer/pom.xml and fxplayer/pom.xml pick up the overridden javafx.version property through normal Maven inheritance, so those modules automatically get JavaFX 26 on the test classpath when the profile is active.

The GitHub Actions Side

The Maven workflow sets up the environment with a Java 25 JDK so the JavaFX 26 runtime can load, and invokes Maven with the profile:

mvn test -Pheadless-tests

The rest of the build still compiles against Java 21 targets, so the library artifact itself is not affected. The profile only kicks in for the test run. The workflow does not need any display setup, no Xvfb, no DISPLAY environment variable tweaks. The headless flag handles all of that!

What This Actually Tests

The unit test compares screenshots of Lottie animations rendered by the JavaFX player against the pre-generated reference images from the JavaScript player. It loads a set of known animation files, renders specific frames from each one, takes a snapshot using WritableImage and SnapshotParameters, and then does a pixel-level comparison with a configurable tolerance.

The result is a regression test that runs on every push. If someone changes the rendering logic in a way that visibly breaks an animation, CI will catch it. This is more useful than it sounds, because Lottie rendering involves a lot of layered transformations, easing functions, and shape operations where subtle bugs are easy to introduce.

Would I Recommend This Pattern?

Yes, with some caveats.

The version juggling is real work. If you want to use JavaFX 26 headless for testing while keeping your library on an older Java version, you need to be careful about separating the test JVM configuration from the main build. Maven makes this doable but not exactly elegant.

The reference image approach also requires discipline. The references need to be generated consistently, ideally on a reproducible setup, and you need to think about what tolerance makes sense for your comparisons. Too strict and you get flaky tests. Too loose and you miss real regressions.

But the payoff is real. The test that I had marked "can not run on CI" now runs on CI. No virtual framebuffer, no Docker tricks, no manual intervention. JavaFX starts up, renders the animations, and the comparison happens cleanly.

For any library that does visual rendering in JavaFX, this is the kind of testing infrastructure that was genuinely missing before. Good work, OpenJFX contributors!

Links:

• Lottie4J website
• Lottie4J on GitHub
• JavaFX 26 Highlights
• Gluon: Introducing the Headless Platform for JavaFX
• Gluon: JavaFX 26 is Now Available

The post Testing Lottie4J JavaFX Animations in GitHub Actions Without a Display: JavaFX 26 Headless to the Rescue appeared first on foojay.

Is your Java application actually secure, or does it just look that way? In this episode of the Foojay Podcast, Frank is joined by Steve Poole and David Welch, both from HeroDevs, to dig deep into the state of Java security in 2025 and beyond.

Steve introduces the concept of zombie dependencies: end-of-life libraries that appear safely dormant but are quietly accumulating vulnerabilities waiting to bite you. David, a co-chair of the CVE Automation Working Group, explains what a CVE actually is, how the identification and disclosure process works in practice, and why AI tools like Mythos are dramatically accelerating the pace at which new vulnerabilities are found — on both sides of the wall.

Together they cover how CVEs in the Java runtime are handled through coordinated disclosure, why Maven Central is safer than most ecosystems but not a silver bullet, and what insurance companies are starting to demand from organizations that haven't cleaned up their dependency trees. They also discuss practical steps any Java developer can take today, from generating an SBOM and running Snyk or Trivy, to adopting OpenRewrite and Renovate in your pipelines, and why vibe coding with AI tools may be quietly making your security posture worse if you are not reviewing the dependency choices being made for you.

An animated, occasionally alarming, and ultimately optimistic conversation about a problem the Java community is well-positioned to lead on.

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Guests

Steve Poole

• LinkedIn
• Foojay Author profile
• Crossing the River Styx: Spring Boot 3.5 and the Zombie Dependency Problem
• Why Java Developers Over-Trust AI Suggestions

David Welch

• LinkedIn

Content

00:00 Introduction of topics and guests
04:00 What are Zombie dependencies?
05:36 What are CVEs?
11:39 How Mythos and other AI tools are influencing the CVE reporting process
16:53 How CVEs in the Java runtime are handled
21:30 How the industry is looking at the increased security threats
30:17 Developers need to make better decisions "the first time" and use the right tools
31:42 Keep your OS, JVM, and dependencies up-to-date! Insurance companies will force you...
44:48 How "safe" is Maven Central compared to other repository systems
50:48 What you can do as a Java developer to make your apps safer
59:01 Should we be scared for the following years and be careful with vibe coding?
01:04:27 Conclusion

The post Foojay Podcast #95: Is Your Java App Actually Secure, Or Does It Just Look That Way? appeared first on foojay.

Previously in this series:

• Trusted Java Containers: Azul Zulu OpenJDK Joins Docker’s Official Images
• The Road to Docker Official Images for Java: The Azul Zulu Story

Azul Zulu is now a Docker Official Image, so getting a trusted, secure Java base image is now just a FROM azul-zulu line in your Dockerfile. But pulling the right image is just the beginning. This post shows you how to use these images in practice, and how a few extra steps can seriously cut the size of what you ship.

How to Use Azul Zulu as Docker Official Images

The images are available on Docker Hub under the azul-zulu name. You can pull them directly, for instance, with the following commands:

docker pull azul-zulu:21
docker pull azul-zulu:21-jre
docker pull azul-zulu:25

Or you can pull and run one to check the version. This is a good first sanity check when evaluating a new image variant. You should see the following output:

$ docker run --rm azul-zulu:25 java -version
openjdk version "25.0.2" 2026-01-20 LTS
OpenJDK Runtime Environment Zulu25.32+21-CA (build 25.0.2+10-LTS)
OpenJDK 64-Bit Server VM Zulu25.32+21-CA (build 25.0.2+10-LTS, mixed mode, sharing)

Practical Examples: Building Lean Containers

Getting an official, trusted base image is step one. The next step is making sure you’re not shipping more than you need. The Sustainability for Java Developers ebook (published by the Foojay.io community) has an excellent chapter by Jan Ouwens and Ko Turk walking through exactly this problem. Based on their examples, I created a repository on GitHub with a minimal application and multiple example Dockerfiles. The POM file includes the plugins to build a runnable JAR.

package be.webtechie;  
  
public class Main {  
    public static void main(String[] args) {  
        System.out.println("Hello and welcome!");  
    }  
}

Let’s package this app and check the JAR size:

$ mvn package
$ ls -lh target 
-rw-r--r--@ 1 frank  staff   2.2K Mar 23 15:41 azul-docker-demo-1.0-SNAPSHOT.jar

So our application, compiled with Java 25, produces a JAR file that is only 2.2KB. Let’s keep this in mind when comparing it to the Docker container size in the following steps…

Everything in One Container (Don’t Do This)

# dockerfile-full
FROM azul/zulu-openjdk:25

RUN mkdir /app
COPY . /app
WORKDIR /app
RUN apt-get update && apt-get install -y maven
RUN mvn package

ENTRYPOINT ["java", "-jar", "target/azul-docker-demo-1.0-SNAPSHOT.jar"]

Using this file, we can create a Docker image with the following command and check the size.

$ docker build -f dockerfile-full -t azul-docker-demo-full .

$ docker images
REPOSITORY              TAG       IMAGE ID       CREATED          SIZE
azul-docker-demo-full   latest    cf769e50f1db   52 seconds ago   568MB

$ docker run azul-docker-demo-full
Hello and welcome!

This ships your entire build environment, code, Maven, a full JDK, and all the OS tooling alongside your 2.2 KB jar. The resulting image is 568 MB.

Multi-Stage Build with JRE

A multi-stage build separates “what you need to build” from “what you need to run”:

# dockerfile-jre
FROM azul-zulu:25 AS build

RUN mkdir /app
COPY . /app
WORKDIR /app
RUN apt-get update && apt-get install -y maven && mvn package

FROM azul-zulu:25-jre

RUN mkdir /app
COPY --from=build /app /app
WORKDIR /app

ENTRYPOINT ["java", "-jar", "target/azul-docker-demo-1.0-SNAPSHOT.jar"]

Maven and the JDK stay in the build stage. The runtime image includes only your JAR and the Java Runtime Environment (JRE), a stripped-down version of the JDK containing only the tools needed to run applications. Check the blog post The Anatomy of a JVM to learn more about the differences between JDK, JRE, and the Java Virtual Machine (JVM).

$ docker build -f dockerfile-jre -t azul-docker-demo-jre .

$ docker images
REPOSITORY              TAG       IMAGE ID       CREATED          SIZE
azul-docker-demo-jre    latest    16a99e205da7   40 seconds ago   370MB

$ docker run --rm azul-docker-demo-jre
Hello and welcome!

This brings the container size down to 370 MB, and you are no longer shipping your code, Maven, and a full JDK to your production environment or users.

Using jdeps and jlink to Create a Custom Runtime

The JRE still includes every Java module, including the ones your application doesn’t need. jdeps can tell you exactly which modules your application needs, and jlink can assemble a minimal runtime containing only those:

# dockerfile-jlink
FROM azul-zulu:25 AS build

RUN mkdir /app
COPY . /app
WORKDIR /app
RUN apt-get update && apt-get install -y maven binutils

RUN mvn package \
 && jdeps --ignore-missing-deps -q --recursive \
          --multi-release 25 \
          --print-module-deps target/azul-docker-demo-1.0-SNAPSHOT.jar > deps.info \
 && jlink \
          --add-modules "$(cat deps.info)" \
          --strip-debug \
          --compress zip-6 \
          --no-header-files \
          --no-man-pages \
          --output /myjre

FROM debian:stable-slim

ENV JAVA_HOME=/usr/java/jdk25
ENV PATH="${JAVA_HOME}/bin:${PATH}"

COPY --from=build /myjre $JAVA_HOME
RUN mkdir /app
COPY --from=build /app /app
WORKDIR /app

ENTRYPOINT ["java", "-jar", "target/azul-docker-demo-1.0-SNAPSHOT.jar"]

The extra steps with jdeps and jlink make the Dockerfile a bit more complex, but the pattern is a one-time setup you can reuse across projects. Now let’s build the container, and check the size:

$ docker build -f dockerfile-jlink -t azul-docker-demo-jlink .

$ docker images
REPOSITORY              TAG       IMAGE ID       CREATED          SIZE
azul-docker-demo-jlink  latest    4fc3bb4dec14   35 seconds ago   141MB

$ docker run --rm azul-docker-demo-jlink
Hello and welcome!

Result: around 141 MB. You’re now shipping a tailor-made Java runtime with only the modules your application actually needs, nothing else.

Note for Spring Boot and Hibernate users: These frameworks rely heavily on reflection and classpath scanning. This means jdeps may not capture all required modules. You’ll likely need to add some modules manually and test carefully before using this approach in production.

Size Comparison Summary

Every step down this table means a faster pull, less storage, a smaller attack surface, and a smaller carbon footprint! As Jan Ouwens and Ko Turk put it in the Sustainability book: “Whatever you do, don’t ship a 500MB Docker image for a 2.2KB jar file.“

What to Do Next

Start using the official images. For new projects, replace azul/zulu-openjdk references with azul-zulu in your Dockerfiles. For existing projects, plan the migration before the old images are deprecated later in 2026.

Request variants. The official images will grow to cover more Java versions and base OS combinations. If you need something specific, like a particular version, a distroless variant, or a different architecture, open a ticket at AzulSystems/azul-zulu-images.

Think about your image size. If you’re still running FROM azul-zulu:21 in a single-stage build without jlink or multi-stage separation, now is a good time to revisit. Run the comparison yourself with your own application code and the example Dockerfiles in the GitHub repository.

Keep an eye on the next post in this series, where I will walk you through every way to containerize Azul Zulu. From the free Community Availability (CA) images to the commercially supported Subscriber Availability (SA) builds and the Chainguard variant for the most security-conscious environments.

The Sustainability for Java Developers book, which inspired the Docker image examples in this post, is a free ebook published through foojay.io. Chapter 6 by Jan Ouwens and Ko Turk covers container optimization in depth alongside other practical sustainability improvements.

The post Using the Azul Zulu Docker Official Images: From Simple Pull to Lean Container appeared first on foojay.

Foojay.io, the website for the Friends of OpenJDK, is turning six years old. To celebrate, Frank Delporte headed to JCON in Cologne, Germany, and sat down with twelve members of the Java community to talk about what Foojay means to them, what they learn from each other, and how the community is evolving.

This episode covers a lot of ground. Sharat Chandar reflects on 25 years in the Java community and why the people are what keep the language alive. Markus Westergren and Iryna Dohndorf both focus on a theme that comes up again and again: developer sustainability. Not just green software, but how you stay healthy, grounded, and relevant when AI is changing everything around you. Markus and his wife researched how developers are reacting to AI, from ignoring it completely to transforming everything they do. Iryna talks about building resilience and robustness as skills, not afterthoughts.

René Schwietzke dives deep into JIT compilation and his work on the 1 billion row challenge, writing fast pure Java code without reaching for unsafe methods. Gerrit Grunwald explains the Disco API, the tool behind SDKMAN, Gradle, and more, which tracks every OpenJDK distribution available, including ones you have probably never heard of from Asia. Catherine Edelveis walks through why choosing the right OpenJDK distribution matters and how reducing Docker image sizes improves both security and performance. Jago de Vreede built a JavaFX UI for SDKMAN and talks about what he keeps learning from the community.

Annelore Egger mentors people who think they do not know enough to speak at conferences. Spoiler: they do. Buhake Sindi brings Jakarta EE into the AI agent world with LangChain4J CDI and a talk on agent-to-agent protocols. François Martin just published a fresh Foojay article on flaky tests and shares what writing and mentoring have taught him about open source. Dominika Tasarz-Sochacka, Frank's new Foojay colleague, shares her vision for growing the community and making it even more welcoming. And Geertjan Wielenga, who started Foojay six years ago, joins remotely from under a lighthouse in Ireland to look back and look forward.

Foojay is more than a blog. It is a Mastodon server, a Slack community, the Disco API, a book on sustainability, a podcast, and now an education catalog. Six years in, it is still growing, still community-driven, and still very much a place where anyone who works with Java is welcome.

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Content

00:00 Introduction

02:16 Sharat Chandar

• https://www.linkedin.com/in/sharatchander/
• Java community and history
• What you can learn from conferences and articles

05:37 Markus Westergren

• https://www.linkedin.com/in/markuswestergren/
• https://foojay.io/sustainability-for-java-developers/
• https://foojay.io/today/join-slack-com-t-foojay-signup/
• Book "Sustainability for Java Developers"
• How to "sustain yourself" in this strange-AI-changing-world
• Everyone in the Java community is approachable and wants to help you

09:46 Iryna Dohndorf

• https://www.linkedin.com/in/iryna-dohndorf/
• https://foojay.io/today/author/iryna-dohndorf/
• Mentoring about sustainability as a developer + groundness + robustness skills
• High performance without crushing your soul

13:59 René Schwietzke

• https://www.linkedin.com/in/reneschwietzke/
• https://foojay.io/today/the-curious-case-of-different-runtimes-with-different-training-data-jit/
• Diving deep into the runtime, JITWatch
• About the broad mix of topics handled on Foojay
• Foojay helps connect the Java community with Mastodon
• Writing the best performing pure, safe Java code for the 1B row challenge

18:28 Gerrit Grunwald

• https://www.linkedin.com/in/gerritgrunwald/
• https://foojay.io/today/author/gerrit-grunwald/
• https://foojay.io/today/disco-api-helping-you-to-find-any-openjdk-distribution/
• https://sdkman.io/
• The Disco API, the source with all the available OpenJDK distributions, is used by SDKMAN, Gradle, and many other tools
• About the many distributions that are available, even ones that are mainly (and only) used in Asia
• About bringing opensource projects to Commonhaus to ensure their future

27:45 Catherine Edelveis

• https://foojay.io/today/author/catherine-edelveis/
• https://www.youtube.com/watch?v=Ytdo8OGEYFI
• https://foojay.io/today/which-java-runtime-should-you-use-in-production-comparing-openjdk-distributions/
• Reducing Docker sizes improves security and performance
• Many distributors provide builds of OpenJDK

31:16 Jago de Vreede

• https://foojay.io/today/author/jago-de-vreede/
• About the Java community and the place of Foojay in it. What is good, what are we missing?
• SDKMAN, creating an UI for it, and using the many OpenJDK distributions

35:05 Annelore Egger

• https://www.linkedin.com/in/anneloredev/
• https://foojay.io/?s=egger
• Java community, conference volunteering, mentoring
• How to become a conference speaker
• Learn by teaching

38:03 Buhake Sindi

• https://www.linkedin.com/in/buhake-sindi/
• https://foojay.io/today/author/buhake-sindi/
• https://github.com/langchain4j/langchain4j-cdi
• Jakarta EE, LangChain4J CDI, Agent to Agent
• Impact of AI on developer life and sustainability
• Get in touch with your "Java Rockstars"!

44:03 François Martin

• https://www.linkedin.com/in/fran%C3%A7oismartin/
• https://foojay.io/today/author/francois-martin/
• https://foojay.io/today/eliminating-flaky-tests-to-end-world-hunger/
• https://foojay.io/today/five-ways-to-use-gradle-enterprise-to-identify-and-manage-flaky-tests/
• Learn from mentoring, for example, how to earn from opensource
• Foojay author, just published an article about Flaky tests
• Learn from writing and reading

48:18 Dominika Tasarz-Sochacka

• https://www.linkedin.com/in/dominikatasarz/
• https://foojay.io/today/author/dominika-tasarz/
• https://foojay.io/today/join-slack-com-t-foojay-signup/
• https://foojay.io/today/how-to-submit-your-next-article-on-foojay-io/
• The future of Foojay, how can we get the community even more involved
• What you can learn from the community

51:18 Geertjan Wielenga

• https://www.linkedin.com/in/geertjanwielenga/
• https://education.foojay.social/
• Java communities are everywhere
• How Foojay started and grew
• How can contributing to the community influence your career
• Can Foojay connect to universities and other educational initiatives

58:15 Conclusion

The post Foojay Podcast #94: More Than a Blog: How Foojay Connects, Sustains, and Evolves the Java Community appeared first on foojay.

Here are the JavaFX LinksOfTheMonth of April 2026. You can find the weekly lists on jfx-central.com. Did we miss anything? Is there anything you want to have included in one of the next overviews? Let us know via links@jfx-central.com.

Core

• Frank Delporte published a rework on Foojay of last week's Azul Blog post about the Oracle announcement related to JavaFX: Oracle’s Java Verified Portfolio and JavaFX: What It Actually Means.
• Blog post by Gluon: April 2026 Critical Patch Update for OpenJFX Now Available. With a message shared by Johan Vos: "Enjoy the latest and safest releases of JavaFX! And if you want to help us building/distributing these releases, consider our LTS support at gluonhq.com/lts."
• Related to the three-monthly security update, a merge request has been created in the OpenJFX repo with the release notes for 26.0.1 with seven fixes and one known issue: "Media Playback Does Not Work on Ubuntu 26.04. This is because JavaFX Media does not support libavcodec version 62. Support will be added with JDK-8378510.".
• Still on Java 8 with your JavaFX application and using Amazon Corretto? Apparently the April 2026 release is the last one Amazon is providing with JavaFX 8 support.

SceneBuilder

• On Reddit, No-Security-7518 is asking for feedback: SceneBuilder is a GREAT piece of software. What features could make it even greater?: "I'm thinking maybe I could become a contributor. Anyway, I was thinking: What could make Scenebuilder even better?"

Applications

• PDFsam announced: "The new PDFsam Basic 6.0.0 is out with a lot of work done on the PDF engine and accessibility, upgraded JDK and JavaFX and more." Check this post for more details.
• Frank Delporte did the first release of MelodyMatrix, live on camera, together with Steve Hannah, the creator of jDeploy. You can watch the full video on YouTube and find more information in this blog post. MelodyMatrix is a desktop app to experience music in a new way with real-time MIDI recording, multiple visualization views, and powerful playback features. Perfect for musicians, educators, and music enthusiasts.
• Viktor Karpyuk shared on LinkedIn: "It started with a small frustration: Studio 3T Community Edition only allowed 3 database connections. That limitation kept getting in the way of real day-to-day work, so instead of working around it, I decided to build something simpler, lighter, and more practical for everyday MongoDB usage. That is how Mongo Explorer was born — a native MongoDB client focused on the things developers actually need: quick connections, easy browsing, solid querying, and a clean desktop experience without unnecessary overhead." It's available on GitHub.

Components, Libraries, Tools

• Dirk Lemmermann shared amazing screenshots: "Last weekend I worked on FlexGanttFX (flexganttfx.com) improvements and support for AtlantaFX theming / styling. A new showcase app with new demos / samples is also in the works."
• Lee Wyatt announced JavaFX Tools v2.0: "Free IntelliJ plugin for JavaFX devs. CSS completion, variable resolution and gutter previews, 63,000+ Ikonli icons browser, weekly JFXCentral LOTW digest. Thanks to Dirk Lemmermann for testing and guidance!" Check the video on YouTube. The plugin is available on the JetBrains Marketplace.
• Hidekazu Kubota announced the first stable release of the JavaFX Builder API: "This API allows UI code to represent nested structures that mirror the container hierarchy of the user interface. This project aims to reintroduce builder classes to JavaFX. Although these classes were included in JavaFX 2, they were removed from the official library due to concerns about maintenance overhead. Nonetheless, for those who prefer a fluent style, having an API like this is a valuable addition."
• Shared by Striking_Creme864 on Reddit: "Running JavaFX apps with updates and dynamic plugins. Today I want to share our project Weaverbird and show how it can be used with JavaFX. Usually, a JavaFX application is started with all modules loaded int the boot layer. However, JPMS allows you to create an unlimited number of child layers and build a graph from them, which in turn lets us separate application management from the application itself. For exactly this purpose, Weaverbird was created - it runs in the boot layer and is responsible for creating and managing the layers (at the same time its capabilities go much further)."
• Christopher Schnick shared info about KickstartFX v1.1: "A few months ago I released a ready-to-use application template called KickstartFX. You can clone it and get started instantly or try out the pre-built releases on GitHub. The code and buildscripts are the same you find in a real-world production application as most of them are taken straight from one, in this case XPipe. Since then, quite a few additions and bug fixes have been integrated."
• Frank Delporte blogged about headless testing of Lottie4J, a library for parsing Lottie animations as Java objects and playing them as JavaFX animations: "Lottie4J had a unit test I marked 'can not run on CI, because it requires a display.' JavaFX 26 fixed that. There's a built-in headless platform now, one JVM flag, and GitHub Actions just work without any display setup. There's a small catch with Java version juggling (JavaFX 26 requires Java 24+, Lottie4J targets Java 21), but a Maven profile handles it cleanly."
• Dirk Lemmermann published a FlexGanttFX Showcase Application : " created a jdeploy installer for the FlexGanttFX showcase application. You can find it here. The installer will allow you to run the demo locally and the installation will auto-update whenever I push a new release. FlexGanttFX is a framework for building UIs for planning and scheduling applications. The showcase application contains a couple of demos and feature samples. If there is anything you would like to see being added to the demos then please let me know and I will try to come up with an example. I will soon add a JPro-based website that will allow you to run the same application in your browser."

Podcasts, Videos, Books

• Catherine Edelveis published a new video: "New on CyberJAR: Comparing Top OpenJDK Distributions. If you're looking for more than vanilla Java - JavaFX, Java 6 an 7, hardened container images, extended LTS support - check out this comparative summary."
• Live coding session with Johannes Rabauer and Ryan Jarvinen: "AI Coding with IBM Bob: Building a JavaFX Chess Game Live. In this live coding session we'll we explore IBM Bob, IBM’s new AI-first development environment designed to act as a true software engineering partner rather than just an autocomplete tool. Bob integrates directly into the IDE and supports chat-driven development, real-time code review, and security-aware refactoring, while understanding your codebase and intent. It is purpose-built for tasks like Java modernization, large-scale refactoring, and enterprise-grade development workflows. The goal of this session is simple: Use a limited trial budget (40 Bobcoins) to build a functional JavaFX chess game and evaluate how far an AI IDE can realistically take us."
• And also a finished chess game in 3D by Olivier Pillods: "We were asked to replicate the classic chess game with JavaFX, and to add new pieces and rule variants. I was the only student that decided to make it 3D. Developed my own obj file importer. I created piece animations and colored interactions for movement availability. To finish, I made a graveyard system, and a rollback functionality that remembers all until start."
• Frank Delporte was "struggling with the BentoFX layout in MelodyMatrix, and called Matt Coley, the person who wrote it. We used ScenicView to inspect the running JavaFX scene graph, cleaned up some AI-generated code, and possibly found a bug. Honest and practical session." Watch the video on YouTube and check the blog post with more info and links.
• Video by Lee Wyatt: JavaFX Hot Reload in IntelliJ — One Click, Zero Code Changes (FxmlKit + JavaFX Tools) : "JavaFX hot reload without touching your production code. FxmlKit 1.5.1 introduces a system property to enable dev mode externally. JavaFX Tools 2.1.1 takes it one step further — just click the purple Runner button in IntelliJ IDEA, and your app starts with FXML/CSS hot reload enabled automatically. No need to call FxmlKit.enableDevelopmentMode() in your code. No risk of shipping dev mode to production. No extra configuration."

Conferences, Presentations

• Picture shared by Wolfgang Weigend: "A nice conversation about various topics such as Java dependencies, JUnit and also JavaFX at the oracle Java booth at the JCON 2026 conference in Cologne with Christian Stein and Adam Bien."

Miscellaneous

• Article by Daniel Harris: Interactive Floor Plan Editor in Java: Tools and Frameworks: A practical guide for developers building drag‑and‑drop architectural layout editors with Java and JavaFX: "Over the last decade, I've worked on several internal tools for architecture studios and real‑estate visualization teams. One recurring request is the same: build an interactive floor plan editor in Java that allows designers to quickly sketch layouts, drag walls, and experiment with room configurations. ... In this guide I'll walk through the frameworks, design patterns, and engineering decisions that make Java floor plan editors usable and scalable."

JFX Central

• Content changes on JFX Central:
  • Fifty (!) new libraries and three books were added to the JFX Central website.
• The desktop client was updated to JavaFX 25 and now uses the new EXTENDED stage style, which allows for a more native feel of the application on Windows, Mac, Linux.
• Dirk Lemmermann is working on more improvements:
  • "Copilot is now updating the libraries catalogue for JFX Central for me. 'Find the most popular JavaFX libraries on GitHub and summarise the readme and download the images and integrate into libraries.json'. That's what AI was made for "
  • "A little competition never hurt anyone ..... JFX Central will start showing the GitHub stars that a library has received so far."
  • "Here is another one ... the header changes layout when a library has its own icon .... good job Gerrit Grunwald :-)_"
• The JavaFX Links Of The Week of March got bundled and published on Foojay.io.

The post JavaFX Links of April 2026 appeared first on foojay.