Goldberry is an open-source, declarative UI toolkit for Java 25+. A window is three lines, a screen is a KDL file that reloads while it runs, and the same code runs as a plain jar on any JDK or compiles with GraalVM into one native binary. No JNI, no bundled web engine. Apache 2.0.
v2026.1 calendar versions: YEAR.RELEASE · Open source · Apache 2.0
Built on
The showcase is one widget tree in a single window. These are the toolkit's own golden images, the frames its tests compare against.
A desktop UI toolkit for Java that owns its whole pipeline, from the stylesheet to the pixel, so nothing sits between your code and the window.
Read the bookDeclarative
A widget is an immutable Java record with a pure build(), or the same tree as a KDL node. The element tree behind it persists, so state and :hover survive a parent re-describing its child.
Real CSS, real flexbox
A genuine CSS subset with variables, cascade and transitions, laid out by Yoga. Every colour is a --gb-* token, so a theme switch restyles controls whose rules never mention one. Stylesheets and markup hot-reload.
Light to ship
The same application runs as a plain jar, with the native library in a classifier jar, or compiles with GraalVM native image into one 41 MiB executable with that library inside it. Frames are rasterized on the CPU, so plain UI needs no GPU context, and only the damaged region is repainted.
Any JDK 25+, one BOM, and a window on screen before the coffee is poured. GraalVM is a third step, and an optional one.
1 · Build file
The BOM pins the version; the goldberry artifact brings common, natives, core and widgets. The native library arrives as classifier jars, one per platform you run on.
repositories { mavenCentral()}dependencies { implementation platform('io.github.digitalsmile:goldberry-bom:2026.1') // common, natives, core and widgets in one implementation 'io.github.digitalsmile:goldberry' // optional: Markdown and HTML, video and audio, the GPU lane implementation 'io.github.digitalsmile:goldberry-html' // the native library, one classifier per platform you run on runtimeOnly 'io.github.digitalsmile:goldberry-natives::linux-x64' runtimeOnly 'io.github.digitalsmile:goldberry-natives::linux-aarch64' runtimeOnly 'io.github.digitalsmile:goldberry-natives::macos-aarch64' runtimeOnly 'io.github.digitalsmile:goldberry-natives::windows-x64'}
<dependencyManagement> <dependencies> <dependency> <groupId>io.github.digitalsmile</groupId> <artifactId>goldberry-bom</artifactId> <version>2026.1</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies></dependencyManagement><dependencies> <dependency> <groupId>io.github.digitalsmile</groupId> <artifactId>goldberry</artifactId> </dependency> <dependency> <groupId>io.github.digitalsmile</groupId> <artifactId>goldberry-natives</artifactId> <classifier>linux-x64</classifier> <scope>runtime</scope> </dependency></dependencies>
2 · Plain Java
Three lines. No backend to name, no event loop to write. Runs as an ordinary jar; nothing to install beyond the jars themselves.
var window = Window.open("Hello", 960, 640);window.onPaint(frame -> frame.fill(0xFF2E3440));Goldberry.run();// Work that is not instant goes off the UI thread// and comes back on it:Goldberry.async(() -> loadTheThing()) .thenAccept(thing -> window.title(thing.name()));
# Any JDK 25 or newer. Nothing to install beyond the jars../gradlew run# macOS: AppKit wants the process's first thread, exactly as for# LWJGL or SWT. `gradlew run` passes the flag; a plain launch needs it:java -XstartOnFirstThread -jar app.jar
3 · Optional: GraalVM
The same application, compiled ahead of time with GraalVM native image. One executable, the native library inside it, no JDK on the user's machine.
# Optional. Needs a GraalVM for Java 25+; the result needs nothing../gradlew :example:nativeImage -Pgraalvm.home=/path/to/graalvm# One self-contained file, the native library inside it../example/build/native/goldberry-showcase-linux-x64
// @Model fields become observable at build time, so native image// needs no reflection and no reachability metadata from you.@Modelclass Form { String name; // bound from markup: text-input bind="name" @Action void save() { /* named from markup: button press="save" */ }}
79 names a KDL file can use today
Hand-written Foreign Function & Memory bindings on Java 25+.
Linux, Windows and macOS are peer platforms from the first commit.
Typography is part of the toolkit, not something the platform decides.
goldberry-media drives FFmpeg from Java; audio leaves through SDL, video is a widget.
The CPU path never needs a GPU context. goldberry-gpu adds one, bound to SDL_GPU.
web-view drives the desktop's own engine through a separate optional library.
@Model, @Bind and @Action make ordinary field assignments observable.
Markdown, HTML and charts render as ordinary widgets, with no browser engine underneath.
Numbers from the repository's own traces and benchmarks, in milliseconds and microseconds.
The README's own start-up trace, on a plain JDK. The first line is the JVM; the last three are the toolkit.
With GraalVM native image the first line is the one that changes: there is no JVM to start and no classes to load, so the executable reaches its first frame after the toolkit's own work.
Per frame, once the window is up.
Measured on one Linux machine. The three-platform run of the same benchmarks is in progress. Details
Nord's sixteen colours alias into --gb-* tokens; everything else is metrics the widgets obey: a 4 px ramp, a type scale, two densities, three materials and a motion scale. Switch the theme and every control restyles, though no widget's rule names a colour.
Variables, cascade, pseudo-classes and transitions, laid out by Yoga flexbox. A stylesheet names tokens, never colours, and reloads while the application runs. The class on a KDL node is the whole contract with it.
/* Alias tokens: the only place a colour is named. */:root { --gb-accent: var(--nord10); --gb-surface: var(--nord1); --gb-text: var(--nord4); --gb-button-bg: var(--nord3); --gb-button-danger-bg: var(--nord11);}
button { background: var(--gb-button-bg); color: var(--gb-text); border-radius: var(--gb-radius-md); transition: background var(--gb-motion-fast);}button:hover { background: var(--gb-button-bg-hover); }button:focus-visible { outline: 2px solid var(--gb-accent); }button.danger { background: var(--gb-button-danger-bg); color: var(--gb-button-danger-text);}
// The class is the whole contract between markup and stylesheet.row { spacer button press="dismiss" "Cancel" button class="danger" press="delete" "Delete"}
Where Goldberry sits next to the other ways of putting a window on screen from the JVM.
| Goldberry on a JDK | Goldberry, GraalVM native | JavaFX | Swing | Compose for Desktop | SWT | |
|---|---|---|---|---|---|---|
| Language | Java 25+ | Java 25+ | Java | Java | Kotlin | Java |
| Licence | Apache 2.0 | Apache 2.0 | GPL v2 + Classpath exception | GPL v2 + Classpath exception | Apache 2.0 | EPL 2.0 |
| UI model | Declarative: immutable records with a pure build(), or KDL markup | Same | Scene graph; imperative or FXML | Imperative component tree | Declarative @Composable functions | Imperative, native widgets |
| Markup | KDL, hot-reloaded while running | KDL, hot-reloaded while running | FXML | None | None, code only | None |
| Styling and layout | A real CSS subset and Yoga flexbox | Same | JavaFX CSS dialect (-fx-*), layout panes | Look and Feel, layout managers | Kotlin modifiers | Platform look, layout managers |
| Rendering | Own pipeline: Blend2D on the CPU; GPU composition and canvas3d optional | Same | Prism, GPU with software fallback | Java2D | Skia (Skiko), GPU | The platform toolkit: GTK, Win32, Cocoa |
| Text | HarfBuzz shaping; Inter and JetBrains Mono embedded; colour emoji | Same | Platform shaping through Prism | Java2D | Skia | Platform |
| What you ship | Your jars plus the goldberry-natives classifier jar; any JDK 25+ | One executable, no JDK, about 41 MiB for the whole showcase | jlink runtime or jpackage with a JDK inside | jpackage with a JDK inside | jpackage with a JDK inside | jpackage with a JDK inside |
| Start-up | JVM start, then about 330 ms of toolkit work to the first frame | The toolkit's work only; no JVM to start | JVM start, then the FX runtime | JVM start, then AWT | JVM start, then Skiko | JVM start, then the platform toolkit |
| GraalVM native image | Optional | First-class: the binding schema and the weaver are designed for it | Through GluonFX | Partial AWT support, not on every platform | Community experiments only | Community experiments only |
| Native code | One static library over FFM, no JNI | Same, linked into the executable | Bundled natives over JNI | Inside the JDK | Skiko over JNI | JNI into the platform toolkit |
| Third-party Java dependencies | None | None | None beyond the FX modules | None | Kotlin runtime, Skiko, Compose runtime | None |
| Platforms | Linux (Wayland, X11), Windows, macOS | Same | Linux, Windows, macOS, mobile through Gluon | Linux, Windows, macOS | Linux, Windows, macOS | Linux, Windows, macOS |
| Headless testing | Headless backend, golden images per platform, virtual frame clock | Same | Monocle, TestFX | Headless AWT, no pixel goldens built in | Compose UI testing | SWTBot |
| Accessibility | Keyboard, focus ring, WCAG AA contrast and roles; no screen-reader bridge yet | Same | Yes | Yes | Yes, through AWT | Yes, native |
An open-source, declarative desktop UI toolkit for Java 25+. Widgets are immutable Java records or KDL markup, styled with a real CSS subset and laid out with Yoga flexbox, drawn by its own rendering pipeline. Licensed under Apache 2.0.
Java 25 or newer. It uses the Foreign Function & Memory API, so there is no JNI and no third-party Java dependency.
No. Goldberry runs as a plain jar on any JDK 25+. GraalVM native image is an optional, supported target that produces one self-contained executable, with the native library inside it.
Linux (Wayland and X11), Windows and macOS, as peer platforms behind one SDL3 backend. There is also a headless backend for tests and servers.
No. Frames are rasterized on the CPU with Blend2D across worker threads. The goldberry-gpu module adds GPU composition, a canvas3d layer and GPU video presentation when you want them.
Apache License 2.0, with no contributor licence agreement and no commercial edition. The source is on GitHub at DigitalSmile/goldberry.
Add the goldberry-bom to Gradle or Maven, then the goldberry artifact plus the goldberry-natives classifier jars for the platforms you run on. Coordinates are under io.github.digitalsmile.
goldberry-gpu binds SDL_GPU. Windows composite through the GPU by default and on the CPU where they cannot, canvas3d is a layer an application renders into, and video-view shows its pictures through a GPU layer: 4K60 with every picture shown.
Audio and video playback with hardware decode, track switching, text subtitles, network streams read through a cache, and the operating system's own decoders behind the Decoder SPI.
Blend2D 0.21.3, HarfBuzz 14.5.0, SDL 3.4.16, md4c 0.6.0 and Gradle 9.7.1. The emoji face is now Noto Color Emoji, shipped as goldberry-emoji and drawn from its paint graphs.
Every push to master publishes the next line's -SNAPSHOT of the toolkit, the BOM and the optional modules to the Central Portal snapshot repository.
Add the BOM, open a window, and describe the rest in KDL and CSS. No CLA, no commercial edition, no telemetry.
One self-contained GraalVM native binary per platform. No JDK needed. Binaries are attached to each release tag; the buttons open the releases page.
