How Nucleus splits its runtime into independently versioned Gradle modules and how to add the ones you need.

Nucleus is a set of independently versioned Gradle modules. One umbrella module brings the runtime essentials, and every other capability is a separate module you add when you need it, so your build carries only what your app uses.

The umbrella module

Add nucleus-application to pull in the runtime essentials:

build.gradle.kts

dependencies {
    implementation("dev.nucleusframework:nucleus.nucleus-application:2.0.7")
}

This pulls in three runtime modules:

core-runtime — platform detection, native-library loading, the deep-link handler, the single-instance lock, and app metadata.
aot-runtime — AOT cache mode detection.
graalvm-runtime — the SVM substitutions and the initializer called from nucleusApplication { }.

It also brings the shared Compose window code in decorated-window-core, so you add only a window backend on top. Everything else is opt-in.

Window modules

Every app uses exactly one window backend, plus an optional style adapter.

Module	Role
`decorated-window-core`	Shared Compose styling, themes, and icon sets. Pulled in by the others.
`decorated-window-tao`	Rust-native backend (Tao). Default for new projects.
`decorated-window-jbr` / `decorated-window-jni` / `decorated-window-awt`	AWT backend. Deprecated, will be removed in a future Nucleus release.
`decorated-window-jewel`	Style adapter — IntelliJ Platform look.
`decorated-window-material2`	Style adapter — Material 2.
`decorated-window-material3`	Style adapter — Material 3.

Pick exactly one backend (-tao, or one of the deprecated AWT modules), and zero or one style adapter.

OS integration modules

Capability	Module
Notifications (cross-platform DSL)	`notification-common`
Notifications (macOS)	`notification-macos`
Notifications (Windows Toast)	`notification-windows`
Notifications (Linux DBus)	`notification-linux`
Dock menu (macOS)	`launcher-macos`
Jump lists, taskbar buttons (Windows)	`launcher-windows`
Unity quicklist (Linux)	`launcher-linux`
Native menu bar (macOS)	`menu-macos`
Taskbar progress	`taskbar-progress`, `taskbar-progress-tao`
Dark-mode detection	`darkmode-detector`
System accent color	`system-color`
Global hotkeys	`global-hotkey`
Media controls (Now Playing / SMTC / MPRIS)	`media-control`
System info (CPU, RAM, GPU, batteries)	`system-info`
Energy / efficiency mode	`energy-manager`
Auto-launch at login	`autolaunch`
Scheduler (cron / periodic / boot)	`scheduler`
Scheduler testing (virtual clock)	`scheduler-testing`
File-system watcher	`fs-watcher`
macOS service management	`service-management-macos`
Linux HiDPI scale detection	`linux-hidpi`
SF Symbols catalogue	`sf-symbols`
FreeDesktop icon names	`freedesktop-icons`

Performance and networking modules

Capability	Module
Native trust manager (OS keychain CAs)	`native-ssl`
`java.net.http.HttpClient` with native trust	`native-http`
OkHttp with native trust	`native-http-okhttp`
Ktor with native trust	`native-http-ktor`
Auto-update	`updater-runtime`

Add a module

Declare the umbrella, one window backend, and any capability modules you need:

build.gradle.kts

val nucleusVersion = "<version>"

dependencies {
    implementation("dev.nucleusframework:nucleus.nucleus-application:$nucleusVersion")
    implementation("dev.nucleusframework:nucleus.decorated-window-tao:$nucleusVersion")

    // Add the capabilities you need
    implementation("dev.nucleusframework:nucleus.notification-common:$nucleusVersion")
    implementation("dev.nucleusframework:nucleus.global-hotkey:$nucleusVersion")
    implementation("dev.nucleusframework:nucleus.system-info:$nucleusVersion")
}

Pin every nucleus.* artifact to the same version. The modules release together.

How modules compose

Most modules depend on core-runtime for platform detection and app metadata. A few standalone catalogues, such as sf-symbols and freedesktop-icons, carry no runtime dependency. Some modules depend on each other: notification-common orchestrates the per-OS notification modules, and taskbar-progress-tao depends on nucleus-application to add extension functions on NucleusWindow.

The Gradle plugin injects nucleus-app.properties into the classpath at build time, so any module reads your app's identity through NucleusApp.appId, NucleusApp.version, NucleusApp.aumid, and the other properties without extra wiring.

When the GraalVM build runs, each module's reachability metadata is bundled in automatically, so there is no reflection config to maintain by hand.

What's next

Architecture — how the layers fit together.
OS integration — concrete recipes per capability.
Reference: Gradle DSL — full coordinates and version table.

Modules