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.

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.

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.

Some side projects take a while to get to a proper release. MelodyMatrix is one of those. The app has been downloadable for quite some time thanks to jDeploy, but there was no official V1.0.0 yet. No tagged release. No moment of "okay, this is it." Just a rolling build on every commit to the main branch.

That changed now: live, on camera, together with Steve Hannah, the creator of jDeploy.

What Is MelodyMatrix?

MelodyMatrix is a JavaFX application for musicians. It connects to MIDI devices, lets you practice and record, and has a set of views that help you understand what you are playing. Those views are open source and available on GitHub. The full app is free, but has some features that are only available with a license. The download packages are published via GitHub Releases.

Building it has been a long journey. JavaFX, MIDI, and musical theory in one app, keeping it working across Windows, macOS, and Linux, while also building and distributing it automatically from GitHub Actions. That last part is where jDeploy comes in.

What Is jDeploy?

If you have not heard of jDeploy yet, Steve explains it very well in a few sentences: "Once you finish building a desktop application, you hit a wall. How do you share it? How does your user install it? And when you update it, how do they get the new version without manually downloading and reinstalling?"

jDeploy solves all of that. It creates native installers for Windows (.exe), macOS (.dmg), and Linux, handles auto-update on launch, bundles its own JVM so users do not need Java installed, and uses GitHub Releases as the distribution backend. No Maven Central, no NPM account required. Your GitHub repo is your distribution channel.

I did a full interview with Steve earlier where he explains the background of the tool: JavaFX In Action #12 with Steve Hannah about jDeploy. Worth watching if you want the full picture.

The Video: Preparing and Triggering the First Release Together

This new video is about an hour long and covers the whole process of getting MelodyMatrix ready for V1.0.0. Steve joined me, and we walked through the project configuration together, fixed a few things in the GitHub Actions workflow, discussed best practices around git tags, and then actually triggered the first release build while the camera was still running.

Some of the things we covered:

• How jDeploy is configured in the MelodyMatrix project, including how JavaFX preview features are enabled.
• npm versus GitHub for the release packages (short version: npm was much easier to get started with than Maven, and Steve modeled the GitHub metadata format on the npm package format).
• Why the Windows installer is an .exe file and not a zip (user experience: download, click, done).
• How jDeploy manages its own JVM per platform (default is Zulu, with some platform-specific exceptions for Windows ARM and Linux).
• Why Maven is not used for application distribution, and why Steve holds his breath every time he does a Maven deploy.
• How to set the version number for a release without breaking the path to your jar file.
• How to prevent multiple jDeploy workflows from running simultaneously.
• Best practices around git tags, including the capital V versus lowercase v debate.
• Customizing the installer and launcher splash screen with a custom HTML page.
• How jDeploy can use a local build to test the installation before pushing to GitHub.

And around the 57-minute mark, the release build finished on GitHub Actions and MelodyMatrix V1.0.0 was live.

Why jDeploy, and Why It Is Free

jDeploy is completely free! Steve wants Java desktop apps to be easy to deploy, and any barrier to entry works against that goal. He is working on a paid tier with private repositories and deployment authentication, but the core tool stays free.

For a solo developer building a side project like MelodyMatrix, that matters. I can push a new version by tagging a commit, and within minutes there is a new installer available for every platform. Users get it automatically on the next launch. No manual distribution, no "please re-download the installer" emails.

A Side Note on Lottie4J

While waiting for the GitHub Actions build to finish, Steve mentioned he had been experimenting with adding Lottie animation support to the jDeploy splash screen, and we talked about Lottie4J for a bit. That is the kind of thing that happens in a live session. Steve even built a Claude Code skill for creating a custom HTML splash screen with a LottieFiles animation. If you want to try it: jdeploy-claude on GitHub and the custom launcher splash screen skill.

Timeline

• 00:00 Introduction
• 00:48 Who is Steve Hannah and why he created jDeploy to distribute Java applications with automatic updates
• 05:42 How Frank uses jDeploy for MelodyMatrix, demo of the application
• 07:26 jDeploy configuration in the MelodyMatrix project, how JavaFX preview features are enabled, GitHub Actions
• 08:32 How new versions get distributed, npm versus Maven versus GitHub
• 10:56 A look into the GitHub Actions flow for MelodyMatrix
• 13:38 Why Maven is not used for application distribution
• 16:38 Why the Windows installer is an .exe file
• 23:13 The JVM runtimes used by a jDeploy application
• 26:05 Modifying the splash screen of the installer and application
• 28:23 The jDeploy desktop app to configure your project
• 31:46 Preparing the MelodyMatrix project for the first release, how to set the release version number, and improving the GitHub workflow
• 40:45 Info about the open-source part of the MelodyMatrix project and the struggle between Gradle and Maven
• 42:59 Checking the GitHub Actions for the release, and more improvements to prevent multiple simultaneous jDeploy workflows
• 45:39 Best practices regarding the use of git tags
• 48:42 Starting the build of the first MelodyMatrix release as V1.0.0!
• 49:40 While the build process is running on GitHub Actions, experimenting with jDeploy locally
• 54:34 Release builds on GitHub Actions are still busy, so another side step to LottieFiles and Lottie4J, and how they could be integrated in the jDeploy splash screen
• 57:41 The first release is ready. Installing and trying it...
• 01:00:40 jDeploy is free! Steve just wants Java to be easy to deploy
• 01:02:31 Conclusion

Links

• JavaFX In Action #12 with Steve Hannah about jDeploy, to distribute your Java app as a native bundle
• Steve Hannah:
  • LinkedIn
  • Twitter
  • Personal blog
• MelodyMatrix:
  • Website
  • Open-source viewers on GitHub
  • Download packages on GitHub
• jDeploy:
  • Website
  • Sources on GitHub
  • Newsletter
  • jDeploy vs jpackage
  • Now you can deploy your app as a DMG
  • Claude Code plugin for jDeploy
  • Custom launcher splash screen skill
• Lottie4J:
  • Website
  • Sources on GitHub

The post MelodyMatrix V1.0.0 Released: Shipping a JavaFX App with jDeploy, GitHub Actions, and Auto-Update appeared first on foojay.

Oracle's JavaOne 2026 brought an announcement that caught some attention in the Java community: the Java Verified Portfolio (JVP), a new program that bundles JDK-related tools, frameworks, libraries, and services under a single commercially supported umbrella with clear roadmaps and support timelines. One of the headline items? Commercial support for JavaFX in JDK 17, 21, 25, 26, and future LTS releases.

Oracle's own framing: "Driven by customer demand, interest from academia, and the growing need for advanced visualizations in AI-powered applications and analytics, Oracle is reintroducing commercial support for JavaFX."

That is good news. But before we celebrate Oracle's renewed commitment, let's be honest about what actually happened between JavaFX being dropped from the JDK in 2017 and this announcement.

Who Kept JavaFX Alive?

When Oracle removed JavaFX from the JDK starting with JDK 9, a small number of organizations and individuals stepped up to make sure it did not quietly disappear. The most important of these is Gluon.

The sources for OpenJFX are hosted on GitHub within the OpenJDK project. Kevin Rushfort from Oracle and Johan Vos from Gluon are the main maintainers of this project. Under their guidance, essential work has been done over the last few years: keeping the rendering pipeline modern, maintaining platform support across Linux, macOS, and Windows, integrating with newer JDK versions, and ensuring that the framework continued to evolve rather than stagnate. This is not marketing work. It is the kind of deep platform engineering that keeps a technology ecosystem alive when the original sponsor walks away.

Without Gluon's sustained investment, the question of whether JavaFX had a future would have been answered a long time ago. But not in a good way...

Beyond Gluon, the broader OpenJFX community contributed bug fixes, improvements, and tooling. And several JDK vendors, including Azul, continued distributing JDK builds that included JavaFX, which helped ensure that the organizations depending on it did not face a cliff edge when Oracle stopped bundling it.

OpenJFX Inspired Project Skara

A nice side-story about OpenJFX: it was the first OpenJDK repository to move to GitHub! The idea was to get the community more involved in the development. And it inspired Oracle to bring the full OpenJDK project to GitHub with Project Skara. Some numbers from github.com/openjdk:

• 135 repositories
• JDK: 905 contributors and almost 23k stars
• JFX: 100 contributors and 3.2k stars.

What the JVP Actually Changes

The JVP announcement matters because it removes a persistent objection that came up whenever anyone evaluated JavaFX for a new project: Who is commercially accountable for this in the long run?

The OpenJFX community had an answer to that with Gluon, but for many companies, this wasn't enough. Enterprise procurement teams like having a "big" name, like Oracle, commit to a technology. Now they have that. Oracle's involvement provides a formal support timeline, making it easier to justify JavaFX in procurement conversations and architecture reviews.

For teams already running JavaFX in production, not much changes immediately. Your applications keep running. The OpenJFX project continues to develop. The Oracle JVP adds a commercial support layer on top of something that was already solid. But these kinds of support contracts were already available for a long time, for instance, with the Azul Core Support Subscriptions.

JavaFX and the AI Visualization Angle

One of the reasons Oracle is highlighting JavaFX right now is the growing need for high-performance data visualization, particularly in AI-powered applications. This is not just marketing spin as there are genuinely impressive things being built.

A good example is the work Florian Enner has done with HebiCharts, a 2D and 3D plotting library built on JavaFX and ChartFX, accessible from Python, C++, and MATLAB. In a recent video, he shows how the combination of Java's ability to handle millions of data points and JavaFX's rendering capabilities produces highly interactive, fast user interfaces that would be difficult to achieve with browser-based alternatives.

This is the kind of use case that makes JavaFX genuinely interesting in 2026, not just as a migration target for legacy Swing applications, but as a real option for new work in scientific computing and data-heavy tooling.

A Note on the Community and Commercial Dynamics

Johan Vos raised a fair point when the JVP was announced: there is a pattern to the way large companies talk about community-driven technology. Oracle used JavaOne, historically a community event, to make a commercial announcement. The line between community stewardship and commercial positioning gets blurry, and it is worth naming that. Johan is, again, inviting all distributors to become more active in the development of JavaFX.

Where Things Stand

JavaFX is in a better position today than it has been at any point since 2017. The technology has continued to improve, the community stayed active (make sure to check JFX Central!), and now Oracle has re-entered with a formal commercial commitment. That is a combination worth being optimistic about.

If you are using JavaFX in production, this is a good moment to revisit your support and upgrade plans, especially if you are still on JDK 8. If you are evaluating JavaFX for something new, the long-term risk question is substantially easier to answer than it was a year ago.

And if you want to understand what keeps JavaFX moving forward technically, spend some time with the OpenJFX project. That is where the real story is.

The post Oracle’s Java Verified Portfolio and JavaFX: What It Actually Means appeared first on foojay.

Here are the JavaFX LinksOfTheMonth of March 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

• Java and JavaFX 26 got released!
  • JavaFX 26 requires JDK 24 or later.
  • You can find all important changes, removed and new features, and fixed issues in the Release Notes for JavaFX 26.
  • You can download JavaFX 26 from the Gluon website.
  • A remarkable move by Oracle: "Oracle is introducing the Java Verified Portfolio (JVP). This is a curated collection of enterprise-grade tools, frameworks, and libraries that Oracle commercially supports. ... It is worth noting that JavaFX, the Java GUI framework, is once again supported via JVP. According to Oracle, this is due to growing demand. Support will be available for all new Java versions and all LTS versions during the five-year Premium Support tier. Support for JDK 8 will be extended until March 2028."
  • Blog post by Oracle: "Announcing the Oracle Java Verified Portfolio including Helidon and reintroduction of JavaFX Commercial Support."
  • Johan Vos announced: "Gluon continues to lead the OpenJFX project. Here is JavaFX 26." With a link to a Gluon blog post about JavaFX 26.
  • Video with the recording of the talk by Kevin Rusforth at JavaOne: JavaFX 26 Today: "Building a compelling desktop app today requires features such as UI controls, charts, interactive media, web content, animation, CSS styling, 2D and 3D rendering, rich text, and property binding, with an easy-to-use programming paradigm that runs cross-platform. JavaFX is all this and more, delivering a rich graphical UI toolkit for building your applications and can also seamlessly interoperate with Swing. In this session you'll learn about the new and exciting features we've developed over the past couple of years, culminating with the release of JavaFX 26. You'll also get an update on RichTextArea. We'll show plenty of demos and sample code, and finish with a sneak peek at what's coming next."
  • APIdia announced: "Adjacent to Java releases are JavaFX releases. Of course, API documentation of JavaFX 26 is similarly available on APIdia."
• Quality Outreach Heads-up - JavaFX 27: Metal Is Now the Default Rendering Pipeline on macOS: "This heads-up is part of the quality outreach sent to the projects involved. ... On macOS, the default JavaFX rendering pipeline has been switched to Metal since JavaFX 27 Early Access (EA) build 3. Metal provides improved performance and better compatibility on modern hardware."
• A blog by Gluon: The Art of the Backport: Why JavaFX Security Doesn’t “Just Happen”: "In a perfect world, keeping a tech stack current is as simple as bumping a version number in a pom.xml or build.gradle file. You run a clean build, and suddenly, the latest fixes are integrated. But for those of us building mission-critical desktop and embedded applications, “just upgrading” to the latest major release isn’t always feasible. When your application is built on a stable Long Term Support (LTS) foundation, you need that environment to remain predictable. You want the stability of your current version, but you absolutely need the security fixes that are discovered in the newer branches. This is where the “Art of the Backport” comes in, and it’s a significant part of the heavy lifting we do at Gluon."
• Related to the announcement of the Oracle Java Verified Portfolio (JVP) and the reintroduction of commercial support for JavaFX, Frank Delporte wrote a blog: The JavaFX Revival: Good News for the Community, Business as Usual for Azul.
• Already want to experiment with JavaFX 27? Check the early-access builds.

Applications

• LogoRRR announced release 26.2.0. Robert Ladstätter published a video showing the new features.
• Mapton announced: "_Here is a new version of Mapton!, 'some kind of map application', built with Jva & JavaFX on the Netbeans platform. Let's call this one the MARKDOWN_HASHca329fd857db05db392388a1d1c2b7f9MARKDOWNHASH. Enjoy!"
• Message by Jakob Jenkov : "I have started the process of building up the Polymorph Player in Java 25 and JavaFX 25. The code will now be located in the Polymorph mono-repo. The first bits are already there, but the player app does not do anything yet, except starting up 😊 But from now on, you can always clone or pull this repo to see just exactly how much is working, officially. This is a project where we can allow ourselves to question the entire current status quo of tech. Some should be kept - but other parts could probably be replaced with better formats / models / architectures. Let's experiment to see what works, and what doesn't."
• Frederick Salazar released OllamaFX v0.5.0. "OllamaFX is a modern, native desktop client for Ollama, built with JavaFX. It provides a beautiful, user-friendly interface to manage your local LLMs and chat with them, featuring a sleek GNOME/Adwaita-inspired design."
• Robert von Burg shared the sources of LumineLog: "A modern, cross-platform log viewer application built with JavaFX. It provides a real-time 'tail -f' experience with powerful highlighting and multi-file support."
  • Release of LumineLog 0.3.0: "_A modern, cross-platform log viewer application built with JavaFX. It provides a real-time MARKDOWN_HASHc21d50ccb3e2b0daf559d6015794f6a7MARKDOWNHASH experience with powerful highlighting and multi-file support. As always, feedback is welcome. Feel free to raise a ticket."
• Message by Robert Ladstätter: "Just released CameraApp on Windows and Linux appstores! Check out this project which resurrects my old passion of doing work with JavaCV and JavaFX. This project can be used as a starting point for experiments with OpenCV and Java."

Components, Libraries, Tools

• Frank Delporte announced the first release of Lottie4J, a new Java(FX) library: "With this library, you can load and parse LottieFiles animations as Java objects, and integrate them as a JavaFX animation component in your application. Watch this video for more info or read this blog."
  • Followed by release V1.1.0 of Lottie4J, a JavaFX player for LottieFiles animations. "This release includes improved rendering and additional debugging tools. And of course, it also uses the new and animated Lottie4J logo for testing " All info and a video demonstration are available on the website in the release notes.
  • And another release: "Version 1.2.0 of Lottie4J is out, and it's again a big release! The headline feature is support for the dotLottie zip-container format, but that's just the start. This release also brings marker-based playback, cropping, adaptive rendering, significant performance improvements, and a lot of core model fixes driven by testing more complex real-world animations. Detailed info and a video showing all new features are explained in this blog post."
• A good read by Liu Tiger: "JavaFX UI Automation: Challenges, Existing Tools, and Real-World Event Handling Problems. Automation testing has become a fundamental component of modern software engineering. In web development, automation ecosystems such as Selenium, Playwright, and Cypress are mature and widely adopted. However, the situation is very different for Java desktop applications, particularly those built using JavaFX."
• Pavel Castornîi is preparing a new release of TabShell, "a platform for building tab-based applications in JavaFX, where an application is structured as a tree of MVP components, each of which has its own lifecycle, history, etc. The platform provides abstract classes for creating the main types of components: tab, area, page, dialog, and popup, as well as containers for them." Try it out and let him know if there are any remarks...
• Gerrit Grunwald created svgconverter: "An SVG to JavaFX converter that can handle nearly everything except animations and masking. You can load a svg file and render it either to the JavaFX SceneGraph using nodes or to the JavaFX Canvas. It took some time to get the Canvas thing working because it is missing some things but now it works kind of ok."
• Dirk Lemmermann announced: "I created a new website for GemsFX that will give you an idea which controls are available in this library."
• Lee Wyatt shared the new library CarouselFX: "A JavaFX carousel / slideshow component with 70+ built-in transition effects." Demo on YouTube and sources on GitHub.

Podcasts, Videos, Books

• GNUBSD404 Long N162 PacMan XXL (JavaFX Game) (Linux/FreeBSD): "This is another example of a "Quality" game on Linux made by some developers. THANKS ! to this developers is that Linux/FreeBSD gaming (and off course thanks to Valve and Steam) is alive!. The game is available on Linux andFreeBSD may work with OpenJDK or may require Linuxuator."
• New video by Helal Anwar: Student management app (Part 6)
• Florian Enner published a video demonstrating HebiCharts: "A 2D and 3D plotting library built in JavaFX with ChartFX, compiled as GraalVM native-image, and accessible from Python / C++ / MATLAB via idiomatic interface over a C ABI."

Miscellaneous

• Robert Ladstätter is experimenting with JavaFX 26 and shared a video: "Vibe coding an editable ToolBar for #JavaFX supporting drag'n drop for the editable Search Term Toolbar Feature. It is amazing how easy it is to implement such things with JavaFX. Looking forward to JavaFX26 which will be released soon."
• Interesting read by SikorSky: "Building a Real-Time Group Chat with Java TCP Sockets and JavaFX. We recently implemented a mini project where the objective was to build a real-time group chat application using Java TCP sockets and JavaFX. This article summarizes the architecture, design decisions, and lessons learned during development."
• Dirk Lemmermann "did some more evaluation of GitHub Copilot CLI today and built a nice launcher app for my GemsFX open source project. The productivity I get out of this surpassed all my expectations."
• Post by Gluon: "We’ve all been there. You’re working on a JavaFX application, and you hit that wall. Maybe it’s a strange rendering glitch on a specific OS, a memory leak you can’t pin down, or a performance bottleneck that only appears in production. You search the forums. You check Stack Overflow. You spend days tweaking code, hoping for a breakthrough. There is a faster way! To make it easier for teams to experience the value of expert support, we are introducing a one-time JavaFX Quick-Fix Package."

JFX Central

• New content on JFX Central:
  • Library: Lottie4J
  • Libraries: TabShell got updated.
• Internal improvements in JFX Central with latest release of JPro.
• Screenshots shared by Dirk Lemmermann: "Thanks to the efforts of several open source developers we can now display syntax-highlighted code in markdown files via JPro Markdown by Florian Kirmaier. Available hopefully by the end of the week."
• Dirk Lemmermann shared another screenshot: "We finally moved to JavaFX 25 for JFX Central and this now allows us to use StageStyle.EXTENDED. Sounds like a minor thing but allows apps to look much more native than before. No more custom resizing borders and behaviour."
• The JavaFX Links Of The Week of February got bundled and published on Foojay.io.

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

Version 1.2.0 of Lottie4J is out, and it's again a big release! The headline feature is support for the .lottie container format, but that's just the start. This release also brings marker-based playback, cropping, adaptive rendering, significant performance improvements, and a lot of core model fixes driven by testing more complex real-world animations.

dotLottie File Support

Until now, Lottie4J only supported the plain JSON format (.json). That's the original Lottie format, but LottieFiles also introduced a newer container format: .lottie. It's essentially a ZIP archive that can hold one or more animations, embedded images, sounds, and a manifest file that describes the contents.

The .lottie format is a practical improvement: it makes Lottie files smaller and self-contained, bundling images and other assets alongside the animation data instead of relying on external references. Lottie4J now supports loading .lottie files directly via the core FileLoader. There are two loading modes available:

// Load the first animation from a .lottie file (simplest path)
LottieAnimation animation = FileLoader.load(path);

// Load the full .lottie container to access the manifest and all animations
DotLottie lottie = FileLoader.loadDotLottie(path);

The Lottie object gives you access to the manifest (author, version metadata) and the full list of animations. At the moment, most real-world .lottie files I found, only bundle a single animation, but the API is ready for multi-animation files when they appear.

New Player Features

Play Between Markers

Lottie animations can embed named markers. Those are timestamp labels inside the animation JSON that indicate points of interest or looping regions. This is a feature Lottie4J previously parsed but didn't expose in the player. Now it does.

The new play(startMarker, endMarker) method makes the player start at frame 1, and then loop between the two named positions in the timeline.

Cropping Support

LottiePlayer now supports cropping via crop(top, right, bottom, left). This lets you clip the rendered output to a sub-region of the animation canvas, which is handy when you want to embed only part of an animation into a layout without modifying the original file.

Resizable Player

LottiePlayer is now properly resizable and adjusts its rendering accordingly. Resizing also has a secondary effect: smaller sizes reduce the rendering load, so you can trade size for performance when needed.

Performance Improvements

Rendering speed has improved significantly in this release. The main gains come from reducing the number of rendering passes per frame and adding a caching layer for layer and precomp render metadata, which avoids redundant recalculation on heavy animations.

The difference is measurable: one test animation that previously played back at around 20–30 FPS now runs at ~50 FPS. A heavier animation that struggled at 11 FPS now reaches ~31 FPS at full size, and scales higher as the player is resized smaller.

Adaptive Rendering Mode

A new adaptive rendering toggle setAdaptiveOffscreenScalingEnabled(enabled) trades rendering sharpness for speed. In adaptive mode, JavaFX uses a faster rendering path that can introduce slight blurring on some elements (particularly sharp text or fine detail at certain sizes). In non-adaptive mode, rendering is pixel-precise but slower.

Which mode works better depends on the animation: simpler animations often look fine in adaptive mode and benefit from the speed, while text-heavy or detail-rich animations are better left in the default mode. The toggle is exposed in both the LottiePlayer and the file viewers so you can test your specific animations.

Core Model Improvements

A lot of work went into the core library this release, driven by testing more complex real-world Lottie files:

• Merge and modifier shape support: a shape layer feature used in more complex animations.
• Blend mode support: layers can now carry blend mode instructions that affect compositing.
• Spatial bezier interpolation: position animations now correctly interpolate using bezier curves rather than linear paths, which produces the characteristic easing motion that makes Lottie animations feel polished.
• Missing model fields: mask, layer, and animation objects had gaps that caused incorrect rendering on specific files, these are now filled in.
• Improved JSON output: when recreating a Lottie JSON from the model (write path), value ordering is now more consistent, and the reconstructed file more closely matches the original.

Jackson 3 Upgrade

The core library has been upgraded to Jackson 3. This is a major version bump: the group ID changes from com.fasterxml.jackson to tools.jackson, so if you depend on the core directly and also pull in Jackson yourself, you'll want to align on version 3. The upgrade also includes CVE-related dependency updates and follow-up compatibility fixes that came out of the migration.

Note that jackson-annotations has not yet moved to the tools.jackson group ID and remains on its previous coordinates for now.

Debug Tooling Updates

The LottieFileDebugViewer has been refactored to extract the duplicated WebView JavaScript bridge code into reusable components. The FX versus JS side-by-side views are improved, and the comparison test has better frame synchronization. A new validation mode tests the player at a resized dimension to verify that rendering holds up under scaling.

The automated CompareFxViewWithWebViewTest, which renders both the JavaFX and JavaScript players frame by frame and checks visual similarity, now also uses .lottie files.

Trying It Out

Update your Maven dependency:

<!-- Just the core model, no player -->
<dependency>
    <groupId>com.lottie4j</groupId>
    <artifactId>core</artifactId>
    <version>1.2.0</version>
</dependency>

<!-- JavaFX player -->
<dependency>
    <groupId>com.lottie4j</groupId>
    <artifactId>fxplayer</artifactId>
    <version>1.2.0</version>
</dependency>

The full list of changes is available on GitHub.

What's Next

The automated comparison test still can't run on GitHub Actions because it requires a display. JavaFX 26 (released alongside Java 26 this week) includes headless rendering support, which may make it possible to run the visual regression tests on GitHub Actions. That's the next thing to investigate...

As always: if you run into a Lottie file that doesn't render correctly, please open an issue and attach screenshots. The more real-world files get tested, the better the library gets.

• Website: lottie4j.com
• GitHub: github.com/lottie4j/lottie4j
• Release notes: lottie4j.com/releases

The post Lottie4J 1.2.0: dotLottie Support, Marker Playback, Cropping, and a Big Speed Boost appeared first on foojay.

Just one week after the first public release of Lottie4J, the open-source Java library for rendering Lottie animations in JavaFX, version 1.1.0 is already out. And it's a big one!

A lot happened in that one week. A logo was designed for the project, a Lottie animation was created for that logo (naturally!), and, most importantly, a significant number of rendering improvements landed after testing a much wider range of animation files. That's the reason for the version bump from 1.0.0 to 1.1.0: there are some API changes that come with it.

What Is Lottie4J?

LottieFiles is a JSON-based animation format, originally developed at Airbnb, widely used to play back animations on websites and mobile apps. Players exist for JavaScript, Android, iOS, and more, but a Java/JavaFX player was missing. That's the gap I want to fix with Lottie4J.

The library is split into two Maven artifacts:

• Core: reads and writes Lottie JSON files, useful if you want to process animations without a player.
• FXPlayer: the JavaFX-based animation player.

You can find them on Maven Central.

What's New in Lottie4J v1.1.0

License and API Improvements

The project has switched from GPLv2 to Apache License V2, which makes it much more adoption-friendly for commercial and open-source projects alike. Logging has been migrated to SLF4J, and there have been significant JavaDoc improvements and code restructuring.

Many Rendering Fixes in the JavaFX Player

This release is primarily driven by testing more complex real-world Lottie files and fixing what didn't render correctly. Here's what changed in the FXPlayer module:

• Correct path closing (fixing gaps in thick borders)
• Better border rendering
• Track Matte support — a key compositing feature in Lottie
• Fix for a layer disappearance at exact keyframe boundaries
• Correct gradient alpha channel parsing for proper transparency
• Image layer rendering — images embedded in Lottie files now display correctly
• Fix for GradientStroke deserialization and color format handling
• Solid color layer rendering
• Text rendering — text objects in animations now display in the JavaFX player
• Improved animation handling overall
• Gaussian Blur effect support added
• Fixed layer opacity
• Combined multiple trim paths correctly
• Fixed animations that start later in the timeline
• Fixed stroke style for dotted lines
• Fixed fade transitions for overlapping shapes
• Improved gradient fills

That's a long list. Animations that were partially broken or visually wrong in 1.0.0 (missing dots, wrong gradients, invisible layers, no text) now render much closer to what the official JavaScript player produces. There are still known open issues: Gaussian blur combined with clipping is tricky in JavaFX, and some complex gradient shapes still differ from the reference player. But the gap has narrowed considerably.

Smarter Debug Tooling

One of the most useful additions in this release is the extended LottieFileDebugViewer. This tool shows the JavaFX player output side by side with the official JavaScript web player, making it immediately obvious where rendering differs.

New in this version:

• Screenshot buttons to capture a single frame or all frames at once
• A tile viewer that visualizes each layer individually
• The ability to export a single layer as a new Lottie file, so you can isolate and test a specific rendering issue without loading the entire animation

There's also a brand-new LottieFileSimpleViewer, a no-frills viewer that just loads a Lottie file and plays it back in a loop using the JavaFX player. Good for quick checks and an example of how you can use the player in your own projects.

Automated Comparison Testing

Perhaps the most exciting developer tooling addition: a unit test called CompareFxViewWithWebViewTest that automates the comparison between the JavaFX player and the JavaScript web player. The test iterates through a list of Lottie files, captures a screenshot every five frames from both players, and compares them for visual similarity. Any frame that differs too much is saved to disk so you can inspect exactly where and how the rendering diverges.

This makes it much easier to track down rendering regressions and verify improvements. Note that the test requires a display (it can't run headless yet — see this open issue), so it won't run on CI for now, but it's extremely useful locally.

Trying It Out

Add the Maven dependency for whichever module you need:

<!-- Just the core model, no player -->
<dependency>
    <groupId>com.lottie4j</groupId>
    <artifactId>lottie4j-core</artifactId>
    <version>1.1.0</version>
</dependency>

<!-- JavaFX player -->
<dependency>
    <groupId>com.lottie4j</groupId>
    <artifactId>lottie4j-fx-player</artifactId>
    <version>1.1.0</version>
</dependency>

The full list of changes between 1.0.0 and 1.1.0 is available on GitHub.

What's Next

The goal isn't to ship a new release every week, but when rendering problems are found in specific animations, the debug tools and automated tests make it much easier to isolate, fix, and verify. If you run into a Lottie file that doesn't render correctly in JavaFX, it can be added to the test suite and investigated.

The biggest open challenge right now is Gaussian blur combined with clipping, which JavaFX makes particularly difficult. That's a known limitation for now.

If you're using Lottie4J in a project, I'd love to hear about it! Share what you've built, report rendering differences you find, and follow along for further progress. Contributions and feedback are very welcome.

• Website: lottie4j.com
• GitHub: github.com/lottie4j/lottie4j
• Release notes: lottie4j.com/releases

The post Lottie4J 1.1.0: Better Rendering, Smarter Debugging, and an animated Lottie4J Logo! appeared first on foojay.

Here are the JavaFX LinksOfTheMonth of February 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

• Amazing work by CommonGround_2048: "Excited to share Cycle Power, a complete cycling ecosystem built entirely with Java! From a native mobile app to a web dashboard, it's 'Java Everywhere' in action. Huge thanks to Johan Vos and the Gluon team for making native mobile Java a reality. It's 'Java Everywhere' in action!" Check the thread on Mastodon for screenshots.
  • "The Mobile App (Android/iOS) uses GluonFX & JavaFX for a high-performance native experience."
  • "The Web Dashboard is the cherry on top! Built with #WebFX, it transpiles JavaFX directly to JavaScript."
  • Reply by Johan Vos: "Fantastic work! Java and JavaFX are extremely suitable for many end-to-end applications, bridging the gap between user-friendly applications and enterprise data platforms."
• JabRef news: "In the latest development version, JabRef now supports multiple citation fetchers/providers, including SemanticScholar, crossref, opencitations, and OpenAlex. And at the bottom we provide some additional metrics from scite.ai. Grab the version here. PS: This version now uses also JavaFX 25.02 and JDK 25.02. -"
• Message with screenshot by Tom Dörr: "Customizable application dock for Windows built with JavaFX." You can find it on GitHub.
• Lidiany Cerqueira announced a new release of CERCA, the Citation Extraction & Reference Checking Assistant, with support for Semantic Scholar's API. Get it from Sourceforge or check the code on GitHub.
• Message with screenshot by LogoRRR: "LogoRRR just got a major facelift. Analysing logs has never looked this good Get it here."
• Vitor Pereira is working on his version of Wireshark and shared some ot the challenges and solutions: "The result was a 5x reduction in RAM usage. I dropped from 5GB on 800,000 packets down to just 1GB." Check Java Packet Analyzer on GitHub for the sources.

Components, Libraries, Tools

• Library updates by Dirk Lemmermann:
  • Dirk Lemmermann shared a screenshot: "Just finished putting a 'Mail App Demo' together for GemsFX. It shows how you can leverage the 'TagsField'"' to implement the email address lookup in a user-friendly way." Check the GemsFX library on GitHub.
  • On Bluesky with screenshot: "I revisited the PopOver control that I wrote years ago. I noticed that the clipping wasn't working perfectly and that the placement logic had issues (to say the least), which caused the popover arrow to point at the wrong location. It's all fixed now and will be in the next GemsFX release."
  • Release 3.9.0 of GemsFX
  • Release 3.10.0 of GemsFX : "It contains a new feature for the InfoCenterPane allowing you to specify where to show notifications (upper left, upper right, etc...)."
• A new library by Gerrit Grunwald: SplitFlap 2026: "A JavaFX implementation of a SplitFlap component."
• Message by Steve Hannah on LinkedIn: "Most desktop apps feel disconnected from the web. You can't link directly into them. You can't share a URL that opens a specific screen. Users have to manually navigate after launching. I just added deep linking to jDeploy 6.0 for JavaFX apps. Now you can register custom URL schemes like: 'myapp://settings' and 'myapp://document/123'. Click the link and your app opens directly to that view. Works on macOS, Windows, and Linux. I wrote a tutorial showing how to set it up step by step."

Podcasts, Videos, Books

• New video by Helal Anwar showing new features in his : Student management app (Part 5). Sources of the project are on GitHub.
• New JavaFX In Action interview published by Frank Delporte: "While reviewing scientific papers, Lidiany Cerqueira had a recurring problem: each reference needed to be checked, as more and more of them were #hallucinations introduced by LLMs and Chatbots. As a solution, she created CERCA during her Christmas holiday. Thanks to #Java, #JavaFX, open-source libraries, and free APIs, the number of references to be checked gets reduced a lot, making her work and that of many other reviewers a lot easier!" You can find the video interview on YouTube and more info in this blog post.
• Frank Delporte took a next stop in his "2026 #JavaOnSingleBoardComputers Journey" with four BeagleBoards (2x #Arm, 2x #RISCV). With his first quick unboxing and test, he got Java(FX) running on the BeagleY-AI. The video is available on YouTube with more info, links, and details in this blog post.
• Frank Delporte published a new interview in his "JavaFX In Action" series: "Helal Anwar builds impressive educational tools with Java and JavaFX. In this interview, we discuss his GradedAttendance application and other projects he's working on." The video is on YouTube with more info in this blog post.
• Video by Florian Enner: "POC: JavaFX native-image snapshots integrated into wxPython. A JavaFX application compiled as a native-image and called from Python. The wxPython GUI updates the JavaFX state and integrates the JavaFX snapshot as an image."
• Video by Sethlans Forge: "Vulkan rendering surface embedded inside a JavaFX application, using Java and LWJGL. This setup demonstrates how low-level Vulkan rendering can coexist with a high-level JavaFX UI, enabling tools, editors, or engine frontends built in Java while keeping full control over the GPU. This is part of the development of Sethlans, a Vulkan graphics engine written in Java, focusing on modern rendering, engine architecture, and low-level GPU control."
• Video by Ken Kousen: "I Built a Star Trek Computer with Java 25 & Spring AI. Is it possible to launch a full Spring Boot AI application in 35 milliseconds? Yes—if you use the right tools. In this video, we aren't just faking a sci-fi UI. We are building the actual ENGINE of a Star Trek computer using the latest in the Java ecosystem: Java 25, Spring AI, and the Model Context Protocol (MCP), using Java FX Voice Interface at 10'50"."
• Video published on LinkedIn by Helal Anwar: "ChessFX made in 10 minutes (Fully vibe coded). Fully written in JavaFX. This is a solid version given the time we had. I believe we can leverage LLMs to build Java and JavaFX applications. If not fully fledged products, then at least substantial parts, since the ecosystem is mature and there’s plenty of data available. Just my opinion 😊." The source (in one single file!) is available on GitHub.

Tutorials

• Nicolas Frankel published do Foojay.io: From a JAR to a full-fledged MacOS app. "The solution is straightforward: create a regular MacOS app from the UberJAR. At its simplest, a MacOS app is only a folder with a specific structure. You could replicate it by hand, but I'm lazy, and there are tools for this. jpackage is such a tool. jpackage is one of the tools I learned about, am ecstatic about, used once, and forgot until the next time. Add one to the counter."

Miscellaneous

• Java UI in 2026: The Complete Guide by Robin Tegg: "When developers think about building user interfaces today, the conversation often revolves around the same familiar choices. But Java offers a fully modern, end-to-end alternative — desktop, web, terminal, and even mobile apps — all powered by a single language. With one cohesive Java stack, teams and AI tools can reason, build, and iterate more efficiently than ever."
  • This guide (and JavaFX) are also mentioned in the JVM Weekly newsletter by Artur Skowroński.
• Jakob Jenkov shared a quick update about the Polymorph project: "The Polymorph Player is beginning to take shape. It can only display some very simple graphics at this point, so I will not include a screenshot in this post. At this point the main structural design is reasonably in place. From here on it is hundreds, if not thousands, of small improvements that need to be added before the Player has a somewhat useful and coherent base set of functionality. These improvements are both in the Player itself, and in the Polymorph Tools toolkit - especially in the virtual machine that executes the scripts which can be run from within the Player app. Lots of work to do ! ... but it's in progress ! 😊 The Player app is made with JavaFX, by the way! ☺️"
• Created by Robin Tegg: Awesome Java UI. "This site provides an overview of the latest and greatest Java UI projects, frameworks and libraries, along with their status, Java version compatibility, learning curve, last release date, and more. Explore the projects to find the right Java UI solution for your needs. This is a community-driven resource, built by Java developers for Java developers. Whether you're discovering a new framework, sharing your expertise, or helping others navigate the Java UI landscape - your contributions make this guide better for everyone. Join us in building the most comprehensive resource for Java UI development!"

JFX Central

• New content on JFX Central:
  • Video: JavaFX In Action with Lidiany Cerqueira about CERCA, an open-source research tool that supports the verification of bibliographic references in scientific manuscripts.
  • Video: JavaFX In Action with Helal Anwar about GradedAttendance
• JFX Central got bumped to JavaFX 25 and JPro 2026.1.1 to fix a few styling issues.
• The links of January 2026 got published on Foojay.

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