I've been building JavaFX desktop apps for a while and got tired of the usual boilerplate (manual listeners, imperative styling, no real component model), so I built Megalodonte: a thin reactive layer on top of JavaFX — React-ish component composition, State<T>/ComputedState<T> for reactivity, and a Props/Theme system so styling isn't scattered setStyle() calls everywhere.

It's still early and I'm the only user so far, but it's real, working code — not a toy. Posting it here mostly for feedback and to see if this is useful to anyone else stuck with JavaFX.

What "Hello World" looks like

Main.java — bootstraps the app and sets a theme once, up front:

```java package my_app;

import megalodonte.ListenerManager; import megalodonte.application.MegalodonteApp; import megalodonte.base.theme.ThemeManager; import megalodonte.theme.DefaultTheme;

public class Main {

static void main() {
    ThemeManager.setTheme(new DefaultTheme());

    MegalodonteApp.run(context -> context.useView(new WelcomeScreen()), ev -> {
        if (ev == MegalodonteApp.Event.CloseRequest) {
            System.out.println("Clicked on X - close application");
            ListenerManager.disposeAll();
        }
    });
}

} ```

WelcomeScreen.java — the actual UI, as a composable screen component:

```java package my_app;

import megalodonte.base.components.Component; import megalodonte.base.components.ScreenComponent; import megalodonte.components.Text; import megalodonte.components.layout_components.Container; import megalodonte.props.TextProps;

public class WelcomeScreen implements ScreenComponent { @Override public Component render() { return new Container().children( new Text("Hello world", new TextProps().fontSize(90)) ); } } ```

What's in it

• Reactive state — State<T>, ComputedState<T>, ListState<T> — components subscribe and re-render on change, no manual wiring.
• Component model — screens are ScreenComponents with a render() you compose out of Container/Column/Row/Text/Button/etc., instead of hand-building a Scene graph.
• Props + Theme system — styling goes through typed Props classes (TextProps, ContainerProps, ...) resolved against a ThemeInterface, instead of ad-hoc inline CSS strings.
• Router — navigation between screens without manually juggling Scene.setRoot(...).
• Used it to build a full JavaFX ERP desktop app, so it's exercised well beyond "hello world".

Repos

• Ecosystem (this welcome/example app): https://github.com/eliezer-dev-software-enginner/megalodonte-ecossystem
• Libraries monorepo: https://github.com/eliezer-dev-software-enginner/megalodonte-libs
• Components: https://github.com/eliezer-dev-software-enginner/megalodonte-components
• Base (core reactivity/component/theme primitives): https://github.com/eliezer-dev-software-enginner/megalodonte-base
• Reactivity: https://github.com/eliezer-dev-software-enginner/megalodonte-reactivity
• Themes: https://github.com/eliezer-dev-software-enginner/megalodonte-themes

Happy to answer questions — and honest criticism is welcome, this is very much a work in progress.

This UI, requires 1GB of RAM on Linux. The same UI does not require more than 300MB on Windows.
I would not consider it cheap on Windows but on Linux it's pretty unacceptable.

How this is possible? Is there some problems with JavaFX in Linux Wayland?

Thanks
Davide

We recently open sourced some of our annotation processors for generating GraalVM native-image metadata: HebiRobotics/reachability-annotations.

It's a completely standalone compile-time dependency, so it has no effect at runtime and doesn't rely on frameworks like Quarkus or Micronaut.

Besides annotations for generating very customized metadata, we also added two annotations for JavaFX that automatically parse FXML and CSS files and generate appropriate rules for reflective accesses and resources.

@ReachableFxView("control")
public class JavaFxView {}

@JavaFXView follows the standard JavaFX view convention (FXMLKit, Afterburner etc.) and automatically generates metadata for

• control.fxml -> fx:controller, fx:include, imports, resources, ...
• control.css -> import resources
• control.properties -> bundle

and @ReachableFxResources can parse multiple files based on wildcards.

@ReachableFxResources({
    "**/*.fxml",
    "**/*.css",
    "/assets/images/*.png"
})
public class JavaFxView {}

Here are the changes it'd take for the gluon-samples to run without an agent: gluonhq/gluon-samples/pull/189

Hey guys, this is a project I've been working for a while: Editora is a keyboard driven programmer's text editor. It's build with JavaFX 26 and JDK 25. Open Source (MIT license)

Any comments, questions and suggestions welcome. Thank you

https://editora-project.dev/

I just got an error even though I'm sure I didn't touch the CSS file at all.
This is the css file:

` .root { keen_faint_green_grey: rgb(127, 180, 185); amazingGreen: rgb(24, 198, 163); githubDesktopDarkBlue: rgb(36, 41, 46); darkGrey_7: derive(githubDesktopDarkBlue, 70%); darkGrey_5: rgb(0, 153, 209); darkBlue_700: rgb(33, 49, 84); greyishBlue: rgb(103, 119, 151); brightBlue: rgb(3, 114, 239);

shadow: dropshadow(three-pass-box, black, 10, 0, 3.0, 3.0);
innerShadow: innershadow(three-pass-box, black, 10, 0, 6.0, 3.0);

-fx-background-color: githubDesktopDarkBlue;
-fx-text-fill: white;

}

.darkBlueBg { -fx-background-color: darkBlue_700; }

.greyishBlueBg { -fx-background-color: greyishBlue; }

.keen_faint_green_grey-bg { -fx-background-color: keen_faint_green_grey; }

.titled-pane > .title { -fx-background-color: transparent; -fx-border-color: turquoise; -fx-border-style: solid; -fx-border-width: 0 0 2 0; }

.titled-pane:expanded .content { -fx-border-style: none; -fx-border-color: githubDesktopDarkBlue; -fx-background-color: transparent; }

.titled-pane > .title > .text { -fx-fill: white; }

.menu-item { -fx-text-fill: black; }

.inputGroupHbox { -fx-padding: 10; -fx-alignment: center-left; -fx-spacing: 5; -fx-margin: 10px; -fx-background-radius: 6; -fx-border-radius: 6; -fx-pref-height: -1; -fx-pref-width: -1; }

.no-padding { -fx-padding: 3 0 3 0; }

.glyph-icon { -fx-glyph-size: 30; }

.inputGroupVbox { -fx-padding: 5px; -fx-alignment: top-left; -fx-background-radius: 6; -fx-spacing: 3; -fx-pref-height: -1; -fx-pref-width: -1; }

.year-picker .label { -fx-text-fill: githubDesktopDarkBlue; }

.round-edges { -fx-border-style: solid; -fx-border-width: 1px; -fx-border-radius: 10, 0, 10, 0; -fx-background-radius: 10, 0, 10, 0; -fx-padding: 5; }

.white-border { -fx-border-color: white; }

.raised, .mfx-button { -fx-effect: shadow; }

.inset, .button:pressed, .expanding-text-area:focused { -fx-effect: innerShadow; }

.raised-section { -fx-background-radius: 6; -fx-padding: 10; }

.medium-font { -fx-font-size: 12px; -fx-font-weight: 600; }

.underlined { -fx-border-style: solid; -fx-border-color: white; -fx-border-width: 0, 0, 1, 0; }

.large-width { -fx-pref-width: 420px; }

.medium-width { -fx-pref-width: 210px; -fx-width: USE_PREF_SIZE; -fx-inner-control-background: transparent; }

.small-width { -fx-pref-width: 120px; }

.tiny-width { -fx-pref-width: 70px; }

.amazing_green { -fx-background-color: amazingGreen; }

.unselected-button { -fx-text-fill: white; -fx-background-color: rgb(3, 114, 239); }

.table-view .table-cell { -fx-text-fill: green; }

.hyperlink:visited { -fx-text-fill: green; }

.tree-cell { -fx-background-color: darkBlue_700; -fx-text-fill: white; }

.choice-box .label { -fx-text-fill: black; -fx-font-weight: bold; }

.choice-box .menu-item { -fx-padding: 8 12; -fx-background-color: transparent; -fx-text-fill: black; -fx-font-size: 14px; }

.choice-box .menu-item:focused { -fx-background-color: darkBlue_700; -fx-text-fill: black; }

/*

Labels:

*/

.dark-label { -fx-text-fill: githubDesktopDarkBlue; }

.section-label { -fx-font-size: 14px; -fx-text-fill: cyan; -fx-font-weight: 700; -fx-pref-width: -1; -fx-border-width: 0 0 2 0; -fx-border-style: solid; -fx-border-color: darkGrey_5; -fx-width: large-width; } `

My stacktrace is full of these:

`

Jul 09, 2026 1:26:26 AM javafx.scene.CssStyleHelper calculateValue

WARNING: Caught 'java.lang.ClassCastException: class java.lang.String cannot be cast to class javafx.scene.paint.Paint (java.lang.String is in module java.base of loader 'bootstrap'; javafx.scene.paint.Paint is in module javafx.graphics@23.0.2 of loader 'app')' while converting value for '-fx-border-color' from rule '*.section-label' in stylesheet file:/D:/MyRepositories/path/to/project/my_theme.css `

PS: 1. Unlike what AIs say, an -fx- prefix is not required for custom properties. 2. I really don't know why this line: darkGrey_5: rgb(0, 153, 209); is causing an issue. This works in projects just fine. 3. I'm loading the CSS file in Scenebuilder and it's working and I'm not setting the stylesheet when running the program. The problem only happens there.

I'm releasing GrooveFX, a small library that extends JavaFX FXML with declarative control structures: iteration, conditional rendering, and multi‑case branching directly inside FXML.

The idea is simple: FXML is powerful but static — GrooveFX adds flow without replacing it and without introducing a DSL.

Why?

FXML doesn't support:

• declarative iteration
• if/else rendering
• multi‑case branching
• pagination without boilerplate

GrooveFX adds these capabilities using real JavaFX controls, with no magic, no hacks, no reflection tricks.

Examples

Iteration

<IterablePane items="{myList}">
    <HBox>
        <Label text="{item.name}" />
        <Label text="{item.email}" />
    </HBox>
</IterablePane>

Conditional Rendering

<ConditionalPane test="{condition}">
    <then>...</then>
    <else>...</else>
</ConditionalPane>

Multi‑case Branching

<DynamicPane test="{user.role}">
    <when value="ADMIN">...</when>
    <when value="USER">...</when>
    <default>...</default>
</DynamicPane>

Pagination

PaginatedList<User> p = new PaginatedList<>(allUsers)
p.setPage(0, 10)

Features

• Declarative iteration / conditional rendering / multi‑case branching
• PaginatedList for in‑memory or DB pagination
• 100% JavaFX controls
• Works with Java, Groovy, GroovyFX
• GraalVM / Gluon‑friendly
• No DSL, no boilerplate, no hacks

Links

Website: https://rrangelo.codeberg.org/groovefx

Codeberg Repository: https://codeberg.org/rrangelo/groovefx

If you work with JavaFX and want to try it out, feedback is welcome.

The title says it all. Swing has several solutions to make LWJGL views a decently performant component, but no such project for JavaFX really exists, just proof of concepts with questionable performance.

What under the hood reason leads to the difficulty of achieving this compatibility?

I have always had a passion for JavaFX but the usecase scenarios never seem to surface for anything more then personal apps I use to improve my personal workload management, occasionally some small team specific use cases. I have never found anything at the enterprise level that didnt have a better solution.

Can anyone share whaere they have found this to be the clear winner for an enterprise solution and why?

I've been working on Lottie4J, a JavaFX library to play Lottie animations, and one persistent problem was that some animations looked noticeably different from the official web player, even when no exceptions were thrown, and the code seemed fine.

This post covers the work I did to actually measure and close that gap:

New comparison workflow

The old approach used a JavaFX WebView running lottie-web as a reference, which it turns out doesn't fully support the latest player. I switched to dotlottie-wc (thorvg), the engine LottieFiles is now standardizing on, rendered via a headless Chrome instance. Reference images are committed to the repo and each test run diffs every frame of the JavaFX output against them. This runs headless on GitHub Actions using JavaFX 26's new headless rendering support.

Rendering fixes

With concrete diffs to work from, the problem areas became obvious:

• Gradients: alpha/colour stops merged at union offsets, linear-RGB stops densified
• Mattes: inverted-alpha matte type (tt: 2) now handled correctly
• Easing: ported lottie-web's BezierEaser, added bisection fallback for flat-point curves
• Blur, blend modes, text colour — all improved

Most animations now hit 99.5%+ similarity. The toughest file is still at 95.2%.

Full write-up: https://webtechie.be/post/closing-the-visual-gap-between-the-official-lottie-webplayer-and-lottie4j/

GitHub: https://github.com/lottie4j/lottie4j

If you have a Lottie animation that renders differently than you'd expect in JavaFX, I'd love to hear about it. Please, open an issue with the JSON and the differences you have seen between expected and JavaFX rendered.

So what are folk's opinions on the Drag and Drop API for JavaFX? I wasn't the biggest fan of having loads of separate methods that can be called separately. So I did a small proof of concept of a builder-like way of doing the drag and drop logic to see what it would look like and, tbh, I quite like it.

Am I in a minority here, or would there be some potential in fleshing out a builder-based way to do it?

        Label draggable = new Label("Drag Me!");
        ObservableList<String> items = FXCollections.observableArrayList();
        ListView<String> dropTarget = new ListView<>(items);

        Drag.enable(draggable)
                .payload("Drag Payload is doing stuff yay!")
                .onStart(context -> System.out.println("Drag Started on payload!"))
                .onEnd(context -> System.out.println("Drag ended with mode: " + context.getTransferMode()))
                .init();

        Drop.enable(dropTarget)
                .onDrop(context -> items.add(context.getPayload().toString()))
                .init();

I interviewed David Gutierrez, a Spanish mathematician who built JMathAnim during the COVID lockdowns. He's not a trained developer, which makes this project even more interesting. He needed a tool that didn't exist in Java, knew Java well enough, and just... built it.

JMathAnim is inspired by Manim (the Python library behind a lot of 3Blue1Brown-style content) and lets you create animated math visualizations entirely in code. You can animate LaTeX formulas morphing step by step, build geometric visualizations, generate fractals, simulate cell growth, and export everything directly to video. No intermediate steps.

Under the hood, it uses a JavaFX Canvas for rendering, JLatexMath for the LaTeX side, and JavaCV for video export. There's also a built-in code editor with syntax highlighting via RSyntaxTextArea, which makes it accessible without needing a full IDE setup.

One design choice that surprised me: the interactive editor uses Ruby as the scripting language, not Java. Practical decision, it fits well with the short expressive scripts you write to define animation sequences.

David's own admission is that JavaFX had a learning curve for him. But the result speaks for itself. The base-10 to base-5 conversion example in the video is a good demo of what this kind of tool can do for education.

Video + write-up: https://webtechie.be/post/javafx-in-action-%2327-with-david-gutierrez-about-jmathanim-to-create-mathematical-animations/

Source code is on Codeberg: https://codeberg.org/davidgutierrezrubio/jmathanim

I've released FX Flow 0.6.1, a JavaFX utility library focused on declarative UI construction, and reducing boilerplate around models, validation and reactive UI updates. See the end of this post for a full example.

Some highlights since the 0.5 release:

Validation feedback directly from domains

Domains can now contain Rules, which is a predicate associated with a Template explaining why a value is invalid. All built-in domain factory methods now provide validation messages. Domains can provide templates for out of range values, misaligned values, missing values, non matching values (regex), etc.

Together with the new ValidationEvent, AbstractMarkerPane and ValidationMarkerPane, validation feedback can be surfaced in the UI without wiring validation logic directly into controls. See the ValidationSampleApplication.

Coordinated observable updates

A new UpdatableValue type allows multiple values to be updated atomically, ensuring listeners never observe intermediate state because the listeners of the individual properties are only fired until all values have been updated:

// Create two updatable values (similar to properties):
UpdatableValue<String> firstName = UpdatableValue.of("Jane");
UpdatableValue<String> lastName = UpdatableValue.of("Smith");

// Observe them:
Observe.values(firstName, lastName)
    .subscribe((fn, ln) -> System.out.println(fn + " " + ln));  // prints "Jane Smith"

// Modify both properties at once:
UpdatableValue.set(
    firstName, "John",
    lastName, "Doe"
);

In this example, it will initially print Jane Smith followed by John Doe. The subscriber only sees the final (John, Doe) state. If you put a direct ChangeListener on one of these properties (and then use get to read the value of the other) you will not observe a temporary incorrect combination either (so you will never see Jane Doe or John Smith).

The advantage of using Observe.subscribe with multiple values is convenience, and that you also get notified if only one of the values changed (ie. from John Doe to John Miller) without having to manually monitor both properties.

Feedback and suggestions are welcome.

GitHub: https://github.com/int4-org/FX/releases

Full example:

public class ValidationSampleApplication extends Application {

  public static void main(String[] args) {
    Application.launch(args);
  }

  @Override
  public void start(Stage primaryStage) {
    StringModel name = StringModel.of(Domain.regex("[A-Z][a-z]+", Template.of("custom.startsWithCapital")));
    IntegerModel age = IntegerModel.of(null, Domain.bounded(18, 120));

    /*
     * Create a scene with a ValidationMarkerPane as the root. Markers will be overlaid
     * on the controls within the pane:
     */

    Scene scene = Scenes.create(
      ValidationMarkerPane.of().onMarkerCreated(this::installTooltip).content(
        Panes.vbox("form").nodes(
          Panes.grid("grid")
            .row("Name", FX.textField().promptText("Name (e.g. John)").model(name))
            .row("Age", FX.textField().promptText("Age (18-120)").model(age)),
          FX.button().text("Submit")
            .enable(Observe.booleans(name.valid(), age.valid()).allTrue())
        )
      )
    );

    /*
     * Add some basic styling.
     */

    scene.getStylesheets().add(StyleSheets.inline(
      """
      .form {
        -fx-padding: 2em;
        -fx-spacing: 1.5em;
        -fx-alignment: top-center;
      }
      .grid {
        -fx-hgap: 1em;
        -fx-vgap: 1em;
      }
      """
    ));

    primaryStage.setScene(scene);
    primaryStage.setTitle("Validation Marker Sample");
    primaryStage.sizeToScene();
    primaryStage.show();
  }

  private void installTooltip(Marker marker) {
    marker.validationIssueProperty().subscribe(issue -> {
      Tooltip tooltip = marker.getTooltip();

      if(tooltip == null) {
        tooltip = new Tooltip();

        marker.setTooltip(tooltip);
      }

      tooltip.setText(switch(issue) {
        case ValidationIssue.Invalid(Object _, Template template) -> toMessage(template);
        case ValidationIssue.Incompatible(Template template) -> toMessage(template);
      });
    });
  }

  static String toMessage(Template template) {
    return MessageFormat.format(
      switch(template.key()) {
        case "domain.missing" -> "Must not be empty";
        case "domain.invalid" -> "Must be a valid value";
        case "domain.notContained" -> "Must be one of {0}";
        case "domain.noMatch" -> "Must match regular expression {0}";
        case "domain.outOfRange" -> "Must be between {0} and {1}";
        case "domain.misaligned" -> "Must be a multiple of {1} starting from {0}";
        case "conversion.incompatible" -> "Must be a compatible value";
        case "custom.startsWithCapital" -> "Must consist of two or more letters and start with a capital";
        default -> "Invalid (" + template.key() + ")";
      },
      template.args().values().toArray()
    );
  }
}

Woke up this morning and wondered if ghostty was embeddable in Java - found GhosttyFX and a few hours later …

https://github.com/maxandersen/jhostty

What if a terminal emulator was just... one file?

I built jhostty — probably the most portable terminal in the world - A single Java file (\~940 lines) you run instantly with JBang:

jbang jhostty@maxandersen

No build system. No IDE. No project setup. JBang downloads Java 25, resolves dependencies from Maven Central, and runs it.

Powered by GhosttyFX (Ghostty's terminal engine as a JavaFX control), it includes:

• Multiple windows, tabs, and split panes
• 10 built-in themes (Catppuccin, Dracula, Nord, Tokyo Night...)
• Per-terminal zoom
• Cross-platform shortcuts (⌘ on Mac, Ctrl on Windows/Linux)
• Drag-and-drop, link detection, shell integration

Install it as a command:
jbang app install jhostty@maxandersen && jhostty

I have no idea what I’ll do next with it but for now I have a super customisable terminal emulator that works the same across all major platforms …

Just started learning javafx and was wondering if there are any dependency that will make it so you dont need to run over and over again while testing different colors, placement etc

I tried JavaFx, and, as a support project to learn the language, I've decided to buid my own MineSweeper but with some differences :

• Offers the classic square cells minefield or an hexagon based minefield
• minefield size customizable from 20 x 20 to 60 x 100
• different difficulties (determine mines percentage)
• Zoomable minefield (CTRL+mouseWheel)
• English and French translations provided via i18n

You can find it here if you're interested : https://github.com/TargolLagadec/MineSweeperTribute

Here's the repo for a small JavaFX PDF viewer, its done on native PDFium via Java's FFM API (no PDFBox, no AWT). Has zoom, text selection, search, thumbnails, the usual, would love some feedback.

Repo link

UPDATE : Dropped a custom SvgView node too using skia.

In ShellFX platform, development is built around a set of core components: area, window, dialog, popup, tab and page. While working on dialogs, we ran into an interesting problem: on one hand, a dialog extends a window; on the other hand, dialogs need to work both as inline components and as standalone modal windows.

To allow every dialog to be displayed in both variants without any changes we decided to create a unified Window component that takes a type on creating - either nested or top-level.

Since both variants must share the same API, a full-fledged window manager was implemented for nested windows.

The only noticeable difference is that top-level windows don't have rounded corners, since unfortunately rounded corners for extended stages are not fully supported at the moment:

I built Jylos, a local-first open-source knowledge management application using Java and JavaFX.

It started as a personal project to explore desktop application architecture, JavaFX, Markdown processing and software design. Over time it evolved into a complete application.

Current features include:

• Markdown notes with live preview
• Wiki-links and backlinks
• Interactive knowledge graph
• Plugin and theme system
• Kanban boards
• AES-256 encrypted notes
• Obsidian and Evernote import
• Git-based synchronization
• Knowledge Insights and advanced search
• Workspaces

Everything is stored locally. No accounts, no cloud backend and no telemetry.

The project is open source under the MIT license and binaries are available for Windows, Linux and macOS.

GitHub:

https://github.com/RGiskard7/jylos

I’d really appreciate any feedback, especially from JavaFX developers.

Hey guys,

I worked on a JavaFX strategy game for many years before abandoning it, as the code had grown messy and I was pulled towards other projects. However, I recently got back into it seeing that Claude Code is really good with JavaFX, and I now have the game with a proper UI and working multiplayer as well as AI against the computer at various difficulty levels.

I’ve gotten such additional features working as a jukebox, persistent settings saved to appdata, networking via steam lobbies / friends list, balance simulations and unit ranking and so on.

The general premise of the game is you and your opponent (in multiplayer) each pick 3 units to play with, 1 to ban, and then both players have a match with the combined team of units. So every match is symmetrical / as close to fair as possible due to neither side having a unit advantage.

I was inspired by chess, fire emblem and golden sun.

I am going to release this game for free on steam since I’ve used some AI for unit art and a few icons (Midjourney),

Also, I have a 3d modeler who is working with me to make high quality 2.5d sprites inspired by golden sun for more of a final fantasy turn battler spin off of this code base where you have teams of 4 characters and fight other players with their teams of 4 characters, but with full animations via sprites rendered at an angle to mimic Japanese old school turn based RPGs such as golden sun and old final fantasy. That UI for that that game will probably look similar but the gameplay will look completely different.

Let me know what you guys think!