A few months ago I came here and asked how best to package JavaFX applications. I was met with people pointing me at third party tools (that abstract away the details and theory), people's own personal setups, but with little context of how / why they were setup like that and other "not quite what I was looking for" guidance.

God knows the official documentation doesn't make it easily clear. As such, it seemed there was a legitimate gap on what, to me personally, seems like a pretty fundamental step of using JavaFX.

So I decided to say "sod it" and make my own guide.

Here is a link to the repo of the project

It is quite simply a default "HelloApplication" project, but with a pom.xml setup to package the application into an OS-specific distributable that, should be JDK/JRE independent (i.e. self-contained).

Along with this, there are several markdown documents explaining the workflow of the packaging solution, along with details on each of the steps of the workflow (i.e. each plugin, the properties in the pom.xml ,etc).

The only limitation now is, I am but one developer on one Operating System (CachyOS) and would love other contributors to provide insight into the per-distro / per OS requirements (such as specific build tools like the WiX toolset), as they are quite sparse as of the moment, with that sparse nature being identified within the documentation itself.

Either way, I hope this helps anyone who, like me a few a months ago, struggled to find an explanation of how to set up packaging a JavaFX app, and was shocked to find there was next to nothing out there. 😄

Ok, a while ago I showed an early version of my PDF engine here. A lot has changed since then, I tried everything, so here is where it stands.

Mergi is a Windows desktop PDF suite: a real viewer, full editing, comments, forms, signatures, redaction, a small word processor that writes PDFs, conversion to Word and Excel, and the everyday tools (merge, organize, split, compress, protect, watermark, batch). Every file stays on the user's computer.

It is 100% JavaFX. No WebView, no embedded browser, no Electron, no third-party UI kit. The only UI module is javafx.controls; the page view, the virtualized lists, the responsive grid, the print dialog and the editor are all built on it by hand, title bar included (StageStyle.EXTENDED + HeaderBar). And there is not one line of AWT or Swing: no BufferedImage, no SwingFXUtils, no ImageIO. Pages go straight from the engine to JavaFX.

jux-pdf

Everything runs on jux-pdf, a PDF engine I started more than three years ago, I changed the name like 5 times already 😂, but this stay.

• Pure Java, zero AWT, zero natives. No JNI, nothing to bundle per platform. Fonts and image codecs are part of the engine.

• Runs where Java runs: desktop, Android, server and cloud. Nothing in it depends on a windowing toolkit.

• Built to PDFium's standard. I followed PDFium's guidelines and its tests to reach the same rendering quality or better, and kept checking against it as the engine grew.

• Every font PDF uses: Type 1, TrueType, OpenType/CFF, Type 3 and CID, embedded, subset or missing, through its own rasterizer. For writing: the standard fonts, the system's fonts and every Google Fonts family, embedded into the file.

• Full editing of any PDF. The page is read as objects (text, pictures, paths) and written back changed, moved, restyled or removed. Not boxes painted on top: the file's own content.

• JavaScript and actions. Its own sandboxed JS engine, also pure Java, runs form scripts (keystroke, validate, calculate, format) and button actions.

• Real redaction. Black-out and white-out destroy what is under the box: the letters leave the text, a picture is cut where the box is. Nothing can be copied or recovered afterwards.

• OCR, Word and Excel. Its own text recognition module, and converters that write real .docx and .xlsx (styles, pictures, tables, numbers as numbers). No Office, no POI.

• Also: forms, every standard annotation, AES-256 encryption, digital signatures with trusted timestamps, compression, and search and text extraction with positions.

There is a lot to say but I suck writing posts , Im tired and AI will do a bible about this , so ask me if you got any question.

• Mergi will be released soon on my own website, with a free version and a paid version.

• The viewer and editor as a JavaFX control. Everything above is one component, and it will be published for anyone to drop into their own JavaFX app: one node, choose the features, theme and language.

• jux-pdf will be released on my own repository 😏.

There is still a lot of work before each of these, but it is getting close. Happy to answer questions about the engine or the JavaFX side.

It's been quite a while since I've posted about any new articles her, and honestly, I've been pretty absorbed in HomeLab stuff for about a year. But, I haven't abandoned my website. In fact I've just rolled out a complete reworking of the website. All the JavaFX content from before is still there, and easier to use now.

The old Jekyll/Minimal Mistakes layout was starting to look dated, and I also wanted to get away from GitHub Pages as the hosting service. But GitHub Pages also enabled a workflow that supported only Jekyll.

The new version is running Hugo with the Blowfish theme, and I think it looks way better than the old version. However, the underlying organizational paradigms are way different from Jekyll, so it took a lot more work than I expected to do the conversion.

I've also taken the opportunity to reorganize the JavaFX content. The old "Elements" section has been expanded into two now: "Elements" and "Techniques". "Elements" is for articles about components of JavaFX and how they work. "Techniques" talks about how to use them, and bigger picture ideas like MVCI.

As an example, descriptions about how specific standard Node classes work is something you'd find in "Elements". Instructions about how to go about creating your own custom Nodes is something you'd find in "Techniques".

Part of the reorganization was to come up with some new categories for the articles, and I've added new landing pages for those categories. When sorting through it all, I was a bit surprised at just how much JavaFX content I have, and I think the new structure makes it easier to find particular subjects.

I think in this age of AI assisted coding, there still is a place for the kind of articles I've been writing. My goal has always been to explain the first principles of all of the concepts, so that you can understand why you should do things in a particular way instead of just blindly following a recipe. I don't think that AI necessarily understands these first principles - mostly because they aren't generally available on the web, and I'm not vain enough to imagine that the models have been trained on my content.

If you new enough here that you haven't seen any of my previous posts announcing articles I've published, then you probably haven't seen my website. I think you should take a look, there is a ton of content there an just about every subject important to developing good JavaFX applications.

Be warned, though, I don't use FXML personally and I don't think anybody else should either. Also, I'm a big fan of Kotlin, and I think that Kotlin + JavaFX is a killer combination. Most of the code samples in my later articles are Kotlin. If you're a half-way competent Java programmer, you shouldn't have any trouble following the ideas behind the Kotlin code.

One of the things about the new format is that it supports multi-lingual code samples. I haven't tried it yet, but I may go back and rework some articles to include both Java and Kotlin code snippets.

Anyway, take a look at https://www.pragmaticcoding.ca and tell me what you think about the new design.

Hi r/JavaFX,

I'd like to share a small library I've been working on: Workbench Themes, two AtlantaFX themes called Workbench Dark and Workbench Light. They're based on the color palettes of the IntelliJ themes from Familiar Java Themes, so if you like the classic IntelliJ "Darcula"/Light look, your JavaFX app can now feel right at home next to your IDE.

Screenshots

• Workbench Dark

• Workbench Light

What's inside

• Backgrounds, foreground, selection, borders, links, status and syntax colors are taken from the IntelliJ color theme JSON files and mapped onto the AtlantaFX color system (e.g. #3C3F41 panels / #2B2B2B editors in dark mode)

• The remaining color scale steps are interpolated around these anchor colors

• Chart colors (-color-chart-1 to -color-chart-8) mostly use the theme's syntax colors

• WorkbenchDark and WorkbenchLight implement atlantafx.base.theme.Theme, so they work with ThemeManager too

• Automatic module name for JPMS: io.github.tomarkar.workbench

• Plain CSS files are also available if you don't want the Java classes

Usage

It's on Maven Central:

<dependency>
    <groupId>io.github.tomarkar</groupId>
    <artifactId>workbench-themes</artifactId>
    <version>1.0.1</version>
</dependency>

Gradle:

implementation("io.github.tomarkar:workbench-themes:1.0.1")

Then:

Application.setUserAgentStylesheet(new WorkbenchDark().getUserAgentStylesheet());
// or
Application.setUserAgentStylesheet(new WorkbenchLight().getUserAgentStylesheet());

JavaFX itself has to be provided by your application. Building from source requires JDK 17+ and Maven; the AtlantaFX SASS sources are pulled in automatically and compiled with Dart Sass.

How it was made

Full disclosure: of course this was built with Claude Code. It handled a lot of the tedious parts like mapping the IntelliJ colors onto AtlantaFX's variables, interpolating the color scales and setting up the Maven/SASS build.

The project is MIT licensed. Feedback, issues and PRs are very welcome!

GitHub: https://github.com/tomarkar/workbench-themes

I have made (using claude) a multi user Whatsapp client (using Whatsmeow) in JavaFx.

Multi user

You can login up to 8 numbers, and each get's its own unique color. Two multi user screenshots shown above. The entire UI down to the level of notification is colored to make it easy to identify which user/profile.

RAM Saving

Less than half the RAM of the regular Whatsapp for desktop

Gated Agentic CLI for automations

You can access your whatsapp by cli, and have claude-code do automations. However everything is permission bound, with approvals issued from the frontend ui to the cli at the process tree level. So for example you can approve the claude.exe process (a particular processid) and all it's children also get access for the given time limit and for the given scope. Approvals expire with time, or on breach of scope, or if the process ends. The approvals cannot be spoofed because named pipe (and not network tcp) is used to verify the caller process id.

Different user profiles' approval dialogues are different colored. The example shown below is not that nice, but basically you will be able to approve a claude code (or chatgpt codex) process or any process for that matter and it will be able to do things on your behalf.

It is a hobby project, it is not an official whatsapp app.

Source code and pre-release download : https://github.com/chatsgate/whatsappfx/

Comments, criticism, appreciation, suggestion, discussion --- all are welcome.

Ok, I'm a bit of an old JavaFX hobbyist. I started about 10 years ago in college and keep using it for my personal projects.

Nowadays, I feel it's so much harder to configure the environment. Even with AI help, there's always an "if this, then that." I mean, as I remember, you used to just install Eclipse with e(fx)clipse, install Scene Builder, and in the end, just generate a .jar file. Now, I can't find a guide from start to deploy that doesn't look like a workaround. And with every Java/JavaFX update, some detail changes.

How do you configure your environment to make it easier? I mean IDE, embedded DB, how to deploy, and how to distribute (I see there are some frameworks that compile JavaFX to web apps).

I'm a newbie when it comes to developing with JavaFX, although I am experienced with java.

But as far as I can see there's no official architecture recommendations from the developers of JavaFX so I'd like to know what's the most modern architecture pattern (e.g. MVVM) for starting an app today.

And if there are resources with good real life examples to see that in practice would be great. Maybe some good quality open source apps...

Anyway, it would be great if you share your experiences as well.

I made javafx version of whatsapp, slack, vscode, and a few other browser-engine/electron apps;

also made a javafx terminal with vertical tabs with feature to hibernate tabs. Altogether archived 3.5

GB ram saving. The app is also 10 times more snappier and faster. Used serial GC in most cases.

There are 100s of markdown editor, but very few of them support WYSIWYG

But very very very few of them are written in a non-browser based stack. Most of them will be like electron apps which will eat a lot of ram for simplest tasks - and i really dislike ram eating apps.

So I have made this in javafx, and distributed as a executable for windows, it is just a 600KB exe, which downloads the jar and installs the jdk if needed.

It also generates AOT (ahead of time) image of the app upon first run, so from second run, the app will be more fast.

Ram consumption is low, 100MB you can expect. When idle it can drop even to 15MB.

It also provides vertical tabs as a default. I like vertical tabs, I am not even given option for horizontal tabs.

I just made it, I haven't even tested it much. All credit goes to claude to make it (I basically refactored one of my old editors which used ckeditor and an embedded webview ... it wasn't nice ... honestly).

Project link : https://github.com/prosefx/notepadfx/

Here is the release link - https://github.com/prosefx/notepadfx/releases/

If you are on windows, please prefer the exe version, it is just 600KB, it is self installing, auto-updating, auto-generates and uses AOT image, all the best Garbage collection and jvm flags included in the exe.

If you wish to make such exes for java please see - https://github.com/jarrunner/jr (BTW Jr.exe is written in java! From Java -> C -> Exe using teavm !!! )

It's unfortunate that Flatpak is phasing out apps that use both X11 and Wayland.

Since JavaFX doesn't fully support Wayland yet, most JavaFX applications risk being removed from Flathub or having their updates halted.

The way I see it, the lack of Wayland support will spell total failure for JavaFX in the short term.

Oracle, are you interested in adding official support for Wayland or not?

Hi all,

I've been working on Sheetmusic4J, an open-source Java library that renders sheet music natively in Java(FX). Two new releases are out, and I made a video showing both: https://youtu.be/8n7WONyX0yk

0.0.4

- NodeSheetView builds the score as a JavaFX scene graph, with one Group per note, rest and chord. Each element can take mouse events, effects and tooltips like any other node. The demo app lets you select a note and drag it up or down.

- FlyOverSheetView is a 3D play-along view. A perspective camera flies over the score, and a glowing ball per voice hops from note to note.

- Headless rendering to an image via the new render and render-awt modules, with no JavaFX needed:

BufferedImage image = HeadlessScoreImage.render(score, 1200);

- The 3000+ line Engraver class is split into focused packages, and all library modules are now JPMS modules.

0.0.5

- LilyPond (.ly) import and export through the ScoreFile facade, without running LilyPond:

Score score = ScoreFile.load(Path.of("bach-bwv610.ly"));

ScoreFile.save(score, Path.of("bach-copy.ly"));

- Engraving improvements: tuplet placement and nesting, octave clefs, and the percussion clef.

- Layouts are now identical across CPU architectures.

LilyPond support (and other formats earlier) came from suggestions on Reddit, so thanks to everyone who asked for it. Overrides and Scheme code are skipped, because the library does its own layout. The LilyPond page on the site lists what is supported.

It also reads MusicXML, MIDI, ABC and Guitar Pro.

The demo app has a "Report Visual Issue" button. It captures the Sheetmusic4J rendering, the reference PDF and your description, ready to attach to a GitHub issue. If a score looks wrong, that is the most useful feedback I can get.

- Release notes: https://sheetmusic4j.com/releases/

- GitHub: https://github.com/sheetmusic4j/sheetmusic4j

Feedback, issues and score files that break things are all welcome.

Thanks
Frank

Hey everyone!

I've been working on a Windows desktop application called FilzaPDF, and I've just published it on the Microsoft Store!

It's a PDF reader and document utility built with Java and JavaFX. I'm sharing it here because I want people to try it out, find bugs, and tell me what needs improvement.

🔗 Microsoft Store: https://apps.microsoft.com/detail/9P53N7DWMS1S?hl=en-us&gl=US&ocid=pdpshare

I'm currently looking for help with testing and bug fixing. In particular, I'd appreciate feedback on:

• Does it install and launch correctly on your Windows PC?

• Do the PDF viewing and document tools work as expected?

• Have you encountered any crashes, UI glitches, or performance issues?

• What features or improvements would make it more useful?

This is an early release, so I'm expecting things that need fixing. Please be honest—even small bugs or suggestions are helpful.

I'm building FilzaPDF as part of a bigger effort to create useful software that people can use for free, without unnecessary subscriptions.

Thanks to anyone willing to give it a try! Every bit of feedback helps me improve it. 💜

Hi everyone.

After starting this many years ago as a side project to test/learn JavaFX and out of my frustration of digging through massive dev logs in a text editor. This side-project sat half-finished for a long time, due to life getting in the way, but was finally able to push my log viewing app Klunk to a beta release.

It’s a Java 25 / JavaFX 26 desktop app available on Linux, Windows, and macOS.

Some features:

• Load logs from disk, SFTP, Kubernetes pods, URLs, and databases.

• Handles large files (millions of rows)

• Fast navigation + filtering

• Customizable UI

• Analysis reports.

• Free

It’s currently beta, but I use it daily without issues and figured others might find it useful too.

Happy to hear feedback, bug reports, or feature ideas.

Klunk

Hello everyone, I'm new to Desktop development! And I want to know techniques/ways on how to handle global keyboard events! for example, cmd+shift+a to open a window etc.

Thanks :)

Hi everyone. I’m looking for someone who could help port Ears Audio Toolkit from Chromium to Firefox.

The main reason I’m still using Chrome is this extension. I’d really like to move to Firefox, but without Ears Audio Toolkit it’s basically the one thing keeping me on Chromium.

I’m looking for a true 1:1 port, not a simplified version — ideally with all existing features working exactly as they do in the Chromium version, including the same audio processing and functionality.

I’d also like to have a Java version/port of the same functionality because I want to integrate it into one of my own projects.

I’m asking for both because I tried looking into it myself, but I’m not experienced enough with this kind of thing. From what I understand, the audio pipeline / sound transmission logic is different, and I don’t really know enough about browser audio APIs and Java audio processing to reproduce it correctly.

If someone is interested in doing this, it would be great if the Firefox port and Java implementation could be published on GitHub so they can be maintained and improved by the community.

Thanks!

Hey everyone,

I’m an experienced developer jumping into JavaFX for the first time. I'm building an app where I need to persist user session tokens securely without rolling my own plaintext file storage.

Ideally, I know that using the OS native credential stores (Windows DPAPI / Credential Manager, macOS Keychain, Linux Secret Service / Keyring). However, pure Java doesn't seem to have built-in APIs for these out of the box.

Is there an established, standard or library the community uses for this? Or does everyone just reach for JNA/JNI bindings like keytar / native wrappers?

Any recommendations or architectural patterns would be appreciated :D

I've been waiting/hoping for years that we'd get support for JavaFX in the browser, but I think I'm finally about to give up--maybe a year or two too late. Does anyone else know of good options?

Some of my criteria:

• Minimal rewriting.

• Still allows for desktop versions.

• The app allows the user to have a large data model--although I can likely do something to minimize this per user/client.

• I don't have regular usage stats, but I do want to support 100s of people using it at a time.

I had been thinking one of the following options would give me what I want:

• WebFX: Was promising, but only supported a few basic controls like labels & buttons--but if you want something even as common as a ComboBox, you'd have to make your own for example. Also, it is essentially just one person so it isn't something someone can rely on.

• CheerpJ: Good for awt/swing, but recently said while they are planning to support it and have some internal prototype stuff, they don't have any timeline for it. Plus the way their of loading the whole app into a canvas like object has a delay and isn't very pretty.

• Gluon: Recently answered me that the old prototype they had from several years back hasn't been updated and they don't plan to without support. (Which I'd be willing $$$ to do, but likely not at the scale they need by myself.)

• JPro: I'm trying to offload most of the work to the client. I worry that having all the logic on the server and just having the graphical output on the browser is a problem if I have an app that allows for a large amount of user data and/or many users.

• Graal to WASM to the browser: Is this possible? I can't seem to find working prototypes.

I think that's all, but if you know other options or a key aspect of the above I'm missing please post.

Edit: Why do I want this? I want folks to be able to try my app without an install. Also maybe even on their phones without me having to go through the app store approval processes.

... with decorations, Scene Builder plugin, theme manager and a new Sidebar component.

Release & changelog.

I'd like to introduce our project - PatternFX. It is a framework that provides developers with templates for MVC, MVP, and MVVM patterns. Although the templates are different, they share a common architectural foundation.

The framework is designed purely for practical use and can be used to build both simple and highly complex applications. For example, our ShellFX platform is built on top of this framework.

One of the key features of the framework is modeling a window as a component tree, where components can be dynamically added and removed. Each component is implemented using one of the provided templates - MVC, MVP or MVVM. Using multiple templates within a single tree is not supported.

Another distinctive feature of the framework is how communication between components is organized. Some solutions use a bus for this, but we decided to use ports instead. A Port is an interface to the key element of a component: its Controller/Presenter/ViewModel. On the one hand, a Port provides a reliable, type-safe communication channel; on the other, it strictly limits access. A component can have N ports, with each client being given only the API it needs.

Key features include:

• Component-oriented architecture.

• Support for the component lifecycle.

• Models the window as a component tree.

• Supports dynamic component composition.

• Organizes core tasks within the view.

• Supports component inheritance.

• Supports preserving component history.

• Provides component-level logging support.

• Designed without FXML dependency.

• Includes a demo for each template.

• Comprehensive documentation.

The demo module implements the same example using all three templates, allowing you to explore and compare the characteristics of each approach.

I hope you find the project interesting and useful.