diff --git a/.github/workflows/build-natives.yaml b/.github/workflows/build-natives.yaml
index ed8ee7bf..a3a696d1 100644
--- a/.github/workflows/build-natives.yaml
+++ b/.github/workflows/build-natives.yaml
@@ -165,3 +165,21 @@ jobs:
           name: linux-natives-${{ matrix.arch }}
           path: darkmode-detector/src/main/resources/nucleus/native/linux-*/
           retention-days: 1
+
+      - name: Build nucleus-notification Linux native shared library
+        run: bash nucleus-notification/src/main/native/linux/build.sh
+        env:
+          CI: true
+
+      - name: Verify nucleus-notification Linux native
+        run: |
+          f="nucleus-notification/src/main/resources/nucleus/native/linux-${{ matrix.arch }}/libnucleus_notification.so"
+          if [ ! -f "$f" ]; then echo "MISSING: $f" >&2; exit 1; fi
+          echo "OK: $f ($(wc -c < "$f") bytes)"
+
+      - name: Upload nucleus-notification Linux shared library
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux-natives-notification-${{ matrix.arch }}
+          path: nucleus-notification/src/main/resources/nucleus/native/linux-*/
+          retention-days: 1
diff --git a/.github/workflows/publish-maven.yaml b/.github/workflows/publish-maven.yaml
index 4a0c0a44..3a6b7090 100644
--- a/.github/workflows/publish-maven.yaml
+++ b/.github/workflows/publish-maven.yaml
@@ -38,6 +38,20 @@ jobs:
           pattern: 'decorated-window-*'
           merge-multiple: true
 
+      - name: Download nucleus-notification x64 artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: nucleus-notification/src/main/resources/nucleus/native/
+          pattern: 'linux-natives-notification-x64'
+          merge-multiple: true
+
+      - name: Download nucleus-notification ARM64 artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: nucleus-notification/src/main/resources/nucleus/native/
+          pattern: 'linux-natives-notification-aarch64'
+          merge-multiple: true
+
       - name: Verify all natives present
         run: |
           EXPECTED=(
@@ -53,6 +67,8 @@ jobs:
             "native-ssl/src/main/resources/nucleus/native/win32-aarch64/nucleus_ssl.dll"
             "decorated-window/src/main/resources/nucleus/native/darwin-aarch64/libnucleus_macos.dylib"
             "decorated-window/src/main/resources/nucleus/native/darwin-x64/libnucleus_macos.dylib"
+            "nucleus-notification/src/main/resources/nucleus/native/linux-x64/libnucleus_notification.so"
+            "nucleus-notification/src/main/resources/nucleus/native/linux-aarch64/libnucleus_notification.so"
           )
           MISSING=0
           for f in "${EXPECTED[@]}"; do
diff --git a/.gitignore b/.gitignore
index 76c41d07..2a6ce5ae 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,6 +17,7 @@ site
 decorated-window/src/main/resources/nucleus/native/
 darkmode-detector/src/main/resources/nucleus/native/
 native-ssl/src/main/resources/nucleus/native/
+nucleus-notification/src/main/resources/nucleus/native/
 
 # MSVC build artifacts
 *.obj
diff --git a/core-runtime/src/main/kotlin/io/github/kdroidfilter/nucleus/core/runtime/tools/Logger.kt b/core-runtime/src/main/kotlin/io/github/kdroidfilter/nucleus/core/runtime/tools/Logger.kt
index ec406202..de33784c 100644
--- a/core-runtime/src/main/kotlin/io/github/kdroidfilter/nucleus/core/runtime/tools/Logger.kt
+++ b/core-runtime/src/main/kotlin/io/github/kdroidfilter/nucleus/core/runtime/tools/Logger.kt
@@ -49,31 +49,31 @@ private val timeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS
 
 private fun getCurrentTimestamp(): String = LocalDateTime.now().format(timeFormatter)
 
-internal fun debugln(message: () -> String) {
+public fun debugln(message: () -> String) {
     if (allowNucleusRuntimeLogging && composeNativeTrayLoggingLevel <= DEBUG) {
         println("[${getCurrentTimestamp()}] ${message()}")
     }
 }
 
-internal fun verboseln(message: () -> String) {
+public fun verboseln(message: () -> String) {
     if (allowNucleusRuntimeLogging && composeNativeTrayLoggingLevel <= VERBOSE) {
         println("[${getCurrentTimestamp()}] ${message()}", COLOR_LIGHT_GRAY)
     }
 }
 
-internal fun infoln(message: () -> String) {
+public fun infoln(message: () -> String) {
     if (allowNucleusRuntimeLogging && composeNativeTrayLoggingLevel <= INFO) {
         println("[${getCurrentTimestamp()}] ${message()}", COLOR_AQUA)
     }
 }
 
-internal fun warnln(message: () -> String) {
+public fun warnln(message: () -> String) {
     if (allowNucleusRuntimeLogging && composeNativeTrayLoggingLevel <= WARN) {
         println("[${getCurrentTimestamp()}] ${message()}", COLOR_ORANGE)
     }
 }
 
-internal fun errorln(message: () -> String) {
+public fun errorln(message: () -> String) {
     if (allowNucleusRuntimeLogging && composeNativeTrayLoggingLevel <= ERROR) {
         println("[${getCurrentTimestamp()}] ${message()}", COLOR_RED)
     }
diff --git a/example/build.gradle.kts b/example/build.gradle.kts
index 8976775d..bcf1cf69 100644
--- a/example/build.gradle.kts
+++ b/example/build.gradle.kts
@@ -24,6 +24,7 @@ dependencies {
     implementation(project(":updater-runtime"))
     implementation(project(":darkmode-detector"))
     implementation(project(":decorated-window-material"))
+    implementation(project(":nucleus-notification"))
 }
 
 val releaseVersion =
@@ -65,7 +66,7 @@ nucleus.application {
 
         // --- Native libs handling ---
         cleanupNativeLibs = true // Auto cleanup native libraries
-        enableAotCache = true // Enable AOT compilation cache
+        enableAotCache = false // Enable AOT compilation cache
         splashImage = "splash.png" // Splash screen image file
         homepage = "https://github.com/KdroidFilter/NucleusDemo"
 
diff --git a/example/config/ktlint/baseline.xml b/example/config/ktlint/baseline.xml
new file mode 100644
index 00000000..3a7c5950
--- /dev/null
+++ b/example/config/ktlint/baseline.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<baseline version="1.0">
+    <file name="src/main/kotlin/com/example/demo/Main.kt">
+        <error line="61" column="1" source="standard:no-unused-imports" />
+        <error line="324" column="63" source="standard:trailing-comma-on-call-site" />
+        <error line="329" column="10" source="standard:trailing-comma-on-call-site" />
+    </file>
+</baseline>
diff --git a/example/detekt-baseline.xml b/example/detekt-baseline.xml
new file mode 100644
index 00000000..334893d8
--- /dev/null
+++ b/example/detekt-baseline.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" ?>
+<SmellBaseline>
+  <ManuallySuppressedIssues/>
+  <CurrentIssues>
+    <ID>FunctionNaming:Main.kt$@OptIn(ExperimentalNotificationsApi::class) @Composable private fun NotificationButton()</ID>
+  </CurrentIssues>
+</SmellBaseline>
diff --git a/example/src/main/kotlin/com/example/demo/Main.kt b/example/src/main/kotlin/com/example/demo/Main.kt
index 6fad613c..a70854b2 100644
--- a/example/src/main/kotlin/com/example/demo/Main.kt
+++ b/example/src/main/kotlin/com/example/demo/Main.kt
@@ -56,6 +56,9 @@ import io.github.kdroidfilter.nucleus.core.runtime.DeepLinkHandler
 import io.github.kdroidfilter.nucleus.core.runtime.Platform
 import io.github.kdroidfilter.nucleus.core.runtime.SingleInstanceManager
 import io.github.kdroidfilter.nucleus.darkmodedetector.isSystemInDarkMode
+import io.github.kdroidfilter.nucleus.notification.builder.ExperimentalNotificationsApi
+import io.github.kdroidfilter.nucleus.notification.builder.notification
+import io.github.kdroidfilter.nucleus.notification.builder.sendNotification
 import io.github.kdroidfilter.nucleus.updater.NucleusUpdater
 import io.github.kdroidfilter.nucleus.updater.UpdateResult
 import io.github.kdroidfilter.nucleus.updater.provider.GitHubProvider
@@ -253,6 +256,10 @@ fun app() {
             ) {
                 NucleusAtom(atomSize = 200.dp)
 
+                Spacer(modifier = Modifier.height(24.dp))
+
+                NotificationButton()
+
                 if (currentDeepLink != null) {
                     Spacer(modifier = Modifier.height(16.dp))
                     Text(
@@ -300,6 +307,31 @@ fun app() {
     }
 }
 
+@OptIn(ExperimentalNotificationsApi::class)
+@Composable
+private fun NotificationButton() {
+    var notificationSent by remember { mutableStateOf(false) }
+
+    Button(
+        onClick = {
+            notificationSent = true
+            notification(
+                title = "Nucleus Demo",
+                smallIcon = "dialog-information",
+                message = "This is a test notification from Nucleus!",
+                onActivated = { println("Notification activated!") },
+                onDismissed = { reason -> println("Notification dismissed: $reason") },
+                onFailed = { println("Notification failed!") }
+            ) {
+                button("Reply") { println("Reply button clicked!") }
+                button("Dismiss") { println("Dismiss button clicked!") }
+            }.send()
+        }
+    ) {
+        Text(if (notificationSent) "Notification Sent!" else "Send Notification")
+    }
+}
+
 private enum class ThemeMode {
     System,
     Dark,
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 465968d6..ca21de32 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -14,6 +14,7 @@ jbrApi = "1.10.1"
 jna = "5.17.0"
 okhttp = "4.12.0"
 ktor = "3.4.0"
+kotlinxCoroutines = "1.10.2"
 
 [plugins]
 detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt"}
@@ -41,3 +42,4 @@ ktor-client-cio = { module = "io.ktor:ktor-client-cio", version.ref = "ktor" }
 ktor-client-java = { module = "io.ktor:ktor-client-java", version.ref = "ktor" }
 ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
 ktor-client-apache5 = { module = "io.ktor:ktor-client-apache5", version.ref = "ktor" }
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinxCoroutines" }
diff --git a/nucleus-notification/build.gradle.kts b/nucleus-notification/build.gradle.kts
new file mode 100644
index 00000000..8bc2450d
--- /dev/null
+++ b/nucleus-notification/build.gradle.kts
@@ -0,0 +1,145 @@
+import org.apache.tools.ant.taskdefs.condition.Os
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    kotlin("jvm")
+    alias(libs.plugins.vanniktechMavenPublish)
+}
+
+val publishVersion =
+    providers
+        .environmentVariable("GITHUB_REF")
+        .orNull
+        ?.removePrefix("refs/tags/v")
+        ?: "1.0.0"
+
+dependencies {
+    compileOnly(project(":core-runtime"))
+    implementation(libs.kotlinx.coroutines.core)
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_11)
+    }
+}
+
+val nativeResourceDir = layout.projectDirectory.dir("src/main/resources/nucleus/native")
+
+val buildNativeMacOs by tasks.registering(Exec::class) {
+    description = "Compiles the Objective-C JNI bridge into macOS dylibs (arm64 + x64)"
+    group = "build"
+    val hasPrebuilt =
+        nativeResourceDir
+            .dir("darwin-aarch64")
+            .file("libnucleus_notification.dylib")
+            .asFile
+            .exists()
+    enabled = Os.isFamily(Os.FAMILY_MAC) && !hasPrebuilt
+
+    val nativeDir = layout.projectDirectory.dir("src/main/native/macos")
+    inputs.dir(nativeDir)
+    outputs.dir(nativeResourceDir)
+    workingDir(nativeDir)
+    commandLine("bash", "build.sh")
+}
+
+val buildNativeLinux by tasks.registering(Exec::class) {
+    description = "Compiles the C JNI bridge into Linux shared library (x64 + aarch64)"
+    group = "build"
+    val hasPrebuiltX64 = nativeResourceDir
+        .dir("linux-x64")
+        .file("libnucleus_notification.so")
+        .asFile
+        .exists()
+    // Build if x64 is missing (local dev) or if CI is detected (for ARM64)
+    val isCI = System.getenv("CI") != null
+    enabled = (Os.isFamily(Os.FAMILY_UNIX) && !Os.isFamily(Os.FAMILY_MAC)) && (!hasPrebuiltX64 || isCI)
+
+    val nativeDir = layout.projectDirectory.dir("src/main/native/linux")
+    inputs.dir(nativeDir)
+    outputs.dir(nativeResourceDir)
+    workingDir(nativeDir)
+    commandLine("bash", "build.sh")
+}
+
+// Task to ensure ARM64 is built before publishing (CI only)
+val buildNativeLinuxArm64ForPublish by tasks.registering(Exec::class) {
+    description = "Cross-compiles ARM64 Linux native library for publishing"
+    group = "publish"
+    val isCI = System.getenv("CI") != null
+    val hasArm64 = nativeResourceDir
+        .dir("linux-aarch64")
+        .file("libnucleus_notification.so")
+        .asFile
+        .exists()
+    
+    // Only run in CI when publishing and ARM64 not already built
+    enabled = isCI && !hasArm64
+
+    val nativeDir = layout.projectDirectory.dir("src/main/native/linux")
+    inputs.dir(nativeDir)
+    outputs.dir(nativeResourceDir.dir("linux-aarch64"))
+    workingDir(nativeDir)
+    
+    // Set CI flag to force ARM64 build
+    environment("CI", "true")
+    commandLine("bash", "build.sh")
+}
+
+tasks.processResources {
+    dependsOn(buildNativeMacOs)
+    dependsOn(buildNativeLinux)
+}
+
+tasks.configureEach {
+    if (name == "sourcesJar") {
+        dependsOn(buildNativeMacOs)
+        dependsOn(buildNativeLinux)
+    }
+    // Ensure ARM64 is built before publishing
+    if (name.startsWith("publish") || name.startsWith("publishTo")) {
+        dependsOn(buildNativeLinuxArm64ForPublish)
+    }
+}
+
+mavenPublishing {
+    coordinates("io.github.kdroidfilter", "nucleus.notification", publishVersion)
+
+    pom {
+        name.set("Nucleus Notification")
+        description.set("Desktop notifications for Compose Desktop across Windows, macOS and Linux")
+        url.set("https://github.com/kdroidFilter/Nucleus")
+
+        licenses {
+            license {
+                name.set("MIT License")
+                url.set("https://opensource.org/licenses/MIT")
+            }
+        }
+
+        developers {
+            developer {
+                id.set("kdroidfilter")
+                name.set("kdroidFilter")
+                url.set("https://github.com/kdroidFilter")
+            }
+        }
+
+        scm {
+            url.set("https://github.com/kdroidFilter/Nucleus")
+            connection.set("scm:git:git://github.com/kdroidFilter/Nucleus.git")
+            developerConnection.set("scm:git:ssh://git@github.com/kdroidFilter/Nucleus.git")
+        }
+    }
+
+    publishToMavenCentral()
+    if (project.hasProperty("signingInMemoryKey")) {
+        signAllPublications()
+    }
+}
diff --git a/nucleus-notification/detekt-baseline.xml b/nucleus-notification/detekt-baseline.xml
new file mode 100644
index 00000000..163e51a0
--- /dev/null
+++ b/nucleus-notification/detekt-baseline.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" ?>
+<SmellBaseline>
+  <ManuallySuppressedIssues/>
+  <CurrentIssues>
+    <ID>EmptyFunctionBlock:NoOpNotificationProvider.kt$NoOpNotificationProvider${ }</ID>
+    <ID>LongParameterList:NotificationBuilder.kt$( title: String = "", message: String = "", largeIcon: String? = null, smallIcon: String? = null, onActivated: (() -&gt; Unit)? = null, onDismissed: ((DismissalReason) -&gt; Unit)? = null, onFailed: (() -&gt; Unit)? = null, builderAction: NotificationBuilder.() -&gt; Unit = {} )</ID>
+    <ID>LongParameterList:NotificationBuilder.kt$( title: String = "", message: String = "", largeImage: String? = null, smallIcon: String? = null, onActivated: (() -&gt; Unit)? = null, onDismissed: ((DismissalReason) -&gt; Unit)? = null, onFailed: (() -&gt; Unit)? = null, builderAction: NotificationBuilder.() -&gt; Unit = {} )</ID>
+    <ID>LongParameterList:NotificationBuilder.kt$NotificationBuilder$( var title: String = "", var message: String = "", var largeImagePath: String?, var smallIconPath: String? = null, var onActivated: (() -&gt; Unit)? = null, var onDismissed: ((DismissalReason) -&gt; Unit)? = null, var onFailed: (() -&gt; Unit)? = null, )</ID>
+    <ID>MagicNumber:MacNotificationProvider.kt$MacNotificationProvider$100</ID>
+    <ID>MaxLineLength:LinuxNotificationProvider.kt$LinuxNotificationProvider.&lt;no name provided&gt;$infoln { "LinuxNotificationProvider: Closed by user interaction - NOT calling onDismissed" }</ID>
+    <ID>MaxLineLength:LinuxNotificationProvider.kt$LinuxNotificationProvider.&lt;no name provided&gt;$warnln { "LinuxNotificationProvider: Could not find builder ID for notification ptr: $notificationPtr" }</ID>
+    <ID>SwallowedException:LinuxNotificationProvider.kt$LinuxNotificationProvider$e: Exception</ID>
+    <ID>SwallowedException:MacNotificationProvider.kt$MacNotificationProvider$e: Exception</ID>
+    <ID>TooGenericExceptionCaught:LinuxNotificationProvider.kt$LinuxNotificationProvider$e: Exception</ID>
+    <ID>TooGenericExceptionCaught:MacNotificationProvider.kt$MacNotificationProvider$e: Exception</ID>
+    <ID>TooGenericExceptionCaught:NativeNotificationBridge.kt$NativeNotificationBridge$e: Exception</ID>
+    <ID>TooManyFunctions:NativeNotificationBridge.kt$NativeNotificationBridge</ID>
+  </CurrentIssues>
+</SmellBaseline>
diff --git a/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/builder/NotificationBuilder.kt b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/builder/NotificationBuilder.kt
new file mode 100644
index 00000000..999567f3
--- /dev/null
+++ b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/builder/NotificationBuilder.kt
@@ -0,0 +1,94 @@
+package io.github.kdroidfilter.nucleus.notification.builder
+
+import io.github.kdroidfilter.nucleus.notification.model.Button
+import io.github.kdroidfilter.nucleus.notification.model.DismissalReason
+import io.github.kdroidfilter.nucleus.notification.mac.MacNotificationProvider
+import io.github.kdroidfilter.nucleus.notification.linux.LinuxNotificationProvider
+import io.github.kdroidfilter.nucleus.notification.noop.NoOpNotificationProvider
+import java.util.Locale
+
+@Suppress("ExperimentalAnnotationRetention")
+@RequiresOptIn(
+    level = RequiresOptIn.Level.WARNING,
+    message = "This notifications API is experimental and may change in the future."
+)
+@Retention(AnnotationRetention.BINARY)
+annotation class ExperimentalNotificationsApi
+
+@ExperimentalNotificationsApi
+fun notification(
+    title: String = "",
+    message: String = "",
+    largeIcon: String? = null,
+    smallIcon: String? = null,
+    onActivated: (() -> Unit)? = null,
+    onDismissed: ((DismissalReason) -> Unit)? = null,
+    onFailed: (() -> Unit)? = null,
+    builderAction: NotificationBuilder.() -> Unit = {}
+): Notification {
+    val builder = NotificationBuilder(title, message, largeIcon, smallIcon, onActivated, onDismissed, onFailed)
+    builder.builderAction()
+    return Notification(builder)
+}
+
+@ExperimentalNotificationsApi
+suspend fun sendNotification(
+    title: String = "",
+    message: String = "",
+    largeImage: String? = null,
+    smallIcon: String? = null,
+    onActivated: (() -> Unit)? = null,
+    onDismissed: ((DismissalReason) -> Unit)? = null,
+    onFailed: (() -> Unit)? = null,
+    builderAction: NotificationBuilder.() -> Unit = {}
+): Notification {
+    val notif = notification(title, message, largeImage, smallIcon, onActivated, onDismissed, onFailed, builderAction)
+    notif.send()
+    return notif
+}
+
+class Notification internal constructor(private val builder: NotificationBuilder) {
+    fun send() {
+        val provider = getNotificationProvider()
+        provider.sendNotification(builder)
+    }
+
+    fun hide() {
+        val provider = getNotificationProvider()
+        provider.hideNotification(builder)
+    }
+}
+
+class NotificationBuilder(
+    var title: String = "",
+    var message: String = "",
+    var largeImagePath: String?,
+    var smallIconPath: String? = null,
+    var onActivated: (() -> Unit)? = null,
+    var onDismissed: ((DismissalReason) -> Unit)? = null,
+    var onFailed: (() -> Unit)? = null,
+) {
+    internal val buttons = mutableListOf<Button>()
+    internal val id: Int = generateUniqueId()
+
+    companion object {
+        private var lastId = 0
+
+        private fun generateUniqueId(): Int {
+            return ++lastId
+        }
+    }
+
+    fun button(title: String, onClick: () -> Unit) {
+        buttons.add(Button(title, onClick))
+    }
+}
+
+fun getNotificationProvider(): NotificationProvider {
+    val osName = System.getProperty("os.name", "").lowercase(Locale.US)
+    return when {
+        osName.contains("mac") || osName.contains("darwin") -> MacNotificationProvider()
+        osName.contains("linux") -> LinuxNotificationProvider()
+        else -> NoOpNotificationProvider()
+    }
+}
diff --git a/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/builder/NotificationProvider.kt b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/builder/NotificationProvider.kt
new file mode 100644
index 00000000..1056b15f
--- /dev/null
+++ b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/builder/NotificationProvider.kt
@@ -0,0 +1,8 @@
+package io.github.kdroidfilter.nucleus.notification.builder
+
+import io.github.kdroidfilter.nucleus.notification.model.DismissalReason
+
+interface NotificationProvider {
+    fun sendNotification(builder: NotificationBuilder)
+    fun hideNotification(builder: NotificationBuilder)
+}
diff --git a/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/linux/LinuxNotificationProvider.kt b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/linux/LinuxNotificationProvider.kt
new file mode 100644
index 00000000..22c747d0
--- /dev/null
+++ b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/linux/LinuxNotificationProvider.kt
@@ -0,0 +1,322 @@
+package io.github.kdroidfilter.nucleus.notification.linux
+
+import io.github.kdroidfilter.nucleus.core.runtime.tools.debugln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.errorln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.infoln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.warnln
+import io.github.kdroidfilter.nucleus.notification.builder.NotificationBuilder
+import io.github.kdroidfilter.nucleus.notification.builder.NotificationProvider
+import io.github.kdroidfilter.nucleus.notification.model.DismissalReason
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import java.io.File
+import java.nio.file.Files
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
+
+class LinuxNotificationProvider : NotificationProvider {
+    // Use AtomicBoolean for thread-safe access
+    private val isMainLoopRunning = AtomicBoolean(false)
+    
+    // Single coroutine scope - reuse and manage properly
+    private var coroutineScope: CoroutineScope? = null
+    
+    private val debugMode: Boolean = true
+    
+    // Track active notifications: builder.id -> notificationPtr
+    private val activeNotifications = ConcurrentHashMap<Int, Long>()
+    
+    // Reverse lookup: notificationPtr -> builder.id
+    private val notificationPtrToId = ConcurrentHashMap<Long, Int>()
+    
+    // Track if notification was closed by user interaction (click/button) vs natural dismiss
+    private val userInteractedNotifications = ConcurrentHashMap<Int, Boolean>()
+    
+    // Map notification ID to button callbacks: builder.id -> (buttonLabel -> callback)
+    private val buttonCallbacks = ConcurrentHashMap<Int, MutableMap<String, () -> Unit>>()
+    
+    // Store onActivated callbacks: builder.id -> callback
+    private val activatedCallbacks = ConcurrentHashMap<Int, () -> Unit>()
+    
+    // Store onDismissed callbacks: builder.id -> callback
+    private val dismissedCallbacks = ConcurrentHashMap<Int, (DismissalReason) -> Unit>()
+
+    init {
+        NativeNotificationBridge.load()
+        if (debugMode) {
+            NativeNotificationBridge.setDebugMode(1)
+        }
+        
+        // Set up the global button callback handler
+        val buttonCallback = object : ButtonClickedCallback() {
+            override fun invoke(notificationPtr: Long, buttonId: String, userData: Long) {
+                infoln { "LinuxNotificationProvider: Button clicked: $buttonId (ptr: $notificationPtr)" }
+                // Find the correct builder ID using notification pointer
+                val builderId = notificationPtrToId[notificationPtr]
+                if (builderId != null) {
+                    userInteractedNotifications[builderId] = true
+                    // Look up callback for this specific notification
+                    buttonCallbacks[builderId]?.get(buttonId)?.invoke()
+                } else {
+                    warnln { "LinuxNotificationProvider: Could not find builder ID for notification ptr: $notificationPtr" }
+                }
+            }
+        }
+        NativeNotificationBridge.setButtonCallback(buttonCallback)
+        
+        // Set up closed callback (clicked callback is set per-notification in sendNotification)
+        val closedCallback = object : NotificationClosedCallback() {
+            override fun invoke(notificationPtr: Long, userData: Long) {
+                infoln { "LinuxNotificationProvider: Notification closed (ptr: $notificationPtr)" }
+                val builderId = notificationPtrToId[notificationPtr]
+                if (builderId != null) {
+                    if (userInteractedNotifications[builderId] == true) {
+                        infoln { "LinuxNotificationProvider: Closed by user interaction - NOT calling onDismissed" }
+                    } else {
+                        infoln { "LinuxNotificationProvider: Closed naturally - calling onDismissed" }
+                        // Call onDismissed callback
+                        dismissedCallbacks[builderId]?.invoke(DismissalReason.UserCanceled)
+                    }
+                    // Cleanup
+                    activeNotifications.remove(builderId)
+                    notificationPtrToId.remove(notificationPtr)
+                    userInteractedNotifications.remove(builderId)
+                    buttonCallbacks.remove(builderId)
+                    activatedCallbacks.remove(builderId)
+                    dismissedCallbacks.remove(builderId)
+                    
+                    // Stop main loop if no more active notifications
+                    if (activeNotifications.isEmpty()) {
+                        stopMainLoop()
+                    }
+                }
+            }
+        }
+        // Note: callback is set per-notification to pass the correct notificationPtr
+    }
+
+    private fun getOrCreateCoroutineScope(): CoroutineScope {
+        return coroutineScope ?: CoroutineScope(SupervisorJob() + Dispatchers.IO).also {
+            coroutineScope = it
+        }
+    }
+
+    override fun sendNotification(builder: NotificationBuilder) {
+        // Reuse existing scope or create new one - don't cancel to avoid interrupting active notifications
+        val scope = getOrCreateCoroutineScope()
+        
+        scope.launch {
+            try {
+                val appIconPath = builder.smallIconPath
+                infoln { "LinuxNotificationProvider: Sending notification with title: ${builder.title}" }
+
+                // Initialize the notification system
+                val appName = "Nucleus"
+                if (NativeNotificationBridge.init(appName) == 0) {
+                    errorln { "LinuxNotificationProvider: Failed to initialize notifications." }
+                    builder.onFailed?.invoke()
+                    return@launch
+                }
+
+                val notificationPtr: Long = try {
+                    NativeNotificationBridge.createNotification(
+                        summary = builder.title,
+                        body = builder.message,
+                        iconPath = appIconPath
+                    )
+                } catch (e: Exception) {
+                    errorln { "LinuxNotificationProvider: Exception creating notification: ${e.message}" }
+                    -1L
+                }
+
+                if (notificationPtr <= 0L) {
+                    errorln { "LinuxNotificationProvider: Failed to create notification." }
+                    builder.onFailed?.invoke()
+                    return@launch
+                }
+
+                // Track the notification
+                activeNotifications[builder.id] = notificationPtr
+                notificationPtrToId[notificationPtr] = builder.id
+                userInteractedNotifications[builder.id] = false
+
+                // Store onActivated callback
+                builder.onActivated?.let { activatedCallbacks[builder.id] = it }
+                
+                // Store onDismissed callback
+                builder.onDismissed?.let { dismissedCallbacks[builder.id] = it }
+
+                // Set clicked callback for this notification
+                if (builder.onActivated != null) {
+                    val clickedCallback = object : NotificationClickedCallback() {
+                        override fun invoke(notificationPtr: Long, userData: Long) {
+                            userInteractedNotifications[builder.id] = true
+                            builder.onActivated?.invoke()
+                        }
+                    }
+                    NativeNotificationBridge.setNotificationClickedCallback(notificationPtr, clickedCallback)
+                }
+
+                // Set closed callback for this notification
+                if (builder.onDismissed != null) {
+                    val closedCallback = object : NotificationClosedCallback() {
+                        override fun invoke(notificationPtr: Long, userData: Long) {
+                            if (userInteractedNotifications[builder.id] == true) {
+                                infoln { "LinuxNotificationProvider: Closed by user interaction - NOT calling onDismissed" }
+                            } else {
+                                infoln { "LinuxNotificationProvider: Closed naturally - calling onDismissed" }
+                                builder.onDismissed?.invoke(DismissalReason.UserCanceled)
+                            }
+                        }
+                    }
+                    NativeNotificationBridge.setNotificationClosedCallback(notificationPtr, closedCallback)
+                }
+
+                // Set large image
+                builder.largeImagePath?.let { path ->
+                    try {
+                        val file = File(path)
+                        val filePath = if (file.exists() && file.isFile) {
+                            file.absolutePath
+                        } else {
+                            extractToTempIfDifferent(path)?.absolutePath
+                        }
+                        filePath?.let {
+                            NativeNotificationBridge.setNotificationImage(notificationPtr, it)
+                        }
+                    } catch (e: Exception) {
+                        warnln { "LinuxNotificationProvider: Exception processing large image: ${e.message}" }
+                    }
+                }
+
+                // Add buttons - store callbacks for this specific notification
+                val buttonMap = mutableMapOf<String, () -> Unit>()
+                builder.buttons.forEach { button ->
+                    buttonMap[button.label] = button.onClick
+                    NativeNotificationBridge.addButtonToNotification(
+                        notification = notificationPtr,
+                        buttonId = button.label,
+                        buttonLabel = button.label
+                    )
+                }
+                buttonCallbacks[builder.id] = buttonMap
+
+                // Send notification
+                val result: Int = try {
+                    NativeNotificationBridge.sendNotification(notificationPtr)
+                } catch (e: Exception) {
+                    errorln { "LinuxNotificationProvider: Exception sending notification: ${e.message}" }
+                    -1
+                }
+
+                if (result == 0) {
+                    infoln { "LinuxNotificationProvider: Notification sent successfully." }
+                    startMainLoop()
+                } else {
+                    errorln { "LinuxNotificationProvider: Failed to send notification." }
+                    builder.onFailed?.invoke()
+                    cleanupNotification(builder.id, notificationPtr)
+                }
+            } catch (e: Exception) {
+                errorln { "LinuxNotificationProvider: Critical exception in sendNotification: ${e.message}" }
+                builder.onFailed?.invoke()
+            }
+        }
+    }
+
+    override fun hideNotification(builder: NotificationBuilder) {
+        try {
+            val notificationPtr = activeNotifications[builder.id]
+            if (notificationPtr != null) {
+                try {
+                    NativeNotificationBridge.closeNotification(notificationPtr)
+                    infoln { "LinuxNotificationProvider: Notification hide called for ID: ${builder.id}" }
+                } catch (e: Exception) {
+                    warnln { "LinuxNotificationProvider: Exception hiding notification: ${e.message}" }
+                }
+
+                cleanupNotification(builder.id, notificationPtr)
+            } else {
+                warnln { "LinuxNotificationProvider: No active notification found with ID: ${builder.id}" }
+            }
+        } catch (e: Exception) {
+            errorln { "LinuxNotificationProvider: Critical exception in hideNotification: ${e.message}" }
+        }
+    }
+
+    private fun cleanupNotification(builderId: Int, notificationPtr: Long) {
+        try {
+            NativeNotificationBridge.cleanupNotification(notificationPtr)
+        } catch (e: Exception) {
+            warnln { "LinuxNotificationProvider: Exception cleaning up notification: ${e.message}" }
+        }
+
+        activeNotifications.remove(builderId)
+        notificationPtrToId.remove(notificationPtr)
+        userInteractedNotifications.remove(builderId)
+        buttonCallbacks.remove(builderId)
+        activatedCallbacks.remove(builderId)
+        dismissedCallbacks.remove(builderId)
+        infoln { "LinuxNotificationProvider: Notification cleaned up: $builderId" }
+
+        // Stop main loop if no more active notifications
+        if (activeNotifications.isEmpty()) {
+            stopMainLoop()
+        }
+    }
+
+    private fun startMainLoop() {
+        // Use atomic compare-and-set to avoid race condition
+        if (isMainLoopRunning.compareAndSet(false, true)) {
+            infoln { "LinuxNotificationProvider: Starting main loop..." }
+            Thread {
+                try {
+                    NativeNotificationBridge.runMainLoop()
+                } catch (e: Exception) {
+                    warnln { "LinuxNotificationProvider: Exception in main loop: ${e.message}" }
+                } finally {
+                    isMainLoopRunning.set(false)
+                }
+            }.apply {
+                isDaemon = true
+                start()
+            }
+        }
+    }
+
+    private fun stopMainLoop() {
+        if (isMainLoopRunning.compareAndSet(true, false)) {
+            infoln { "LinuxNotificationProvider: Stopping main loop..." }
+            try {
+                NativeNotificationBridge.quitMainLoop()
+            } catch (e: Exception) {
+                warnln { "LinuxNotificationProvider: Exception stopping main loop: ${e.message}" }
+            }
+            coroutineScope?.cancel()
+            coroutineScope = null
+            try {
+                NativeNotificationBridge.cleanup()
+            } catch (e: Exception) {
+                warnln { "LinuxNotificationProvider: Exception during cleanup: ${e.message}" }
+            }
+        }
+    }
+
+    private fun extractToTempIfDifferent(path: String): File? {
+        return try {
+            val resourceStream = LinuxNotificationProvider::class.java.getResourceAsStream("/$path")
+                ?: return null
+            val tempDir = Files.createTempDirectory("nucleus-notification-linux")
+            val tempFile = tempDir.resolve(path.substringAfterLast("/"))
+            resourceStream.use { Files.copy(it, tempFile) }
+            tempFile.toFile().deleteOnExit()
+            tempDir.toFile().deleteOnExit()
+            tempFile.toFile()
+        } catch (e: Exception) {
+            null
+        }
+    }
+}
diff --git a/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/linux/NativeNotificationBridge.kt b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/linux/NativeNotificationBridge.kt
new file mode 100644
index 00000000..de01cb1e
--- /dev/null
+++ b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/linux/NativeNotificationBridge.kt
@@ -0,0 +1,119 @@
+package io.github.kdroidfilter.nucleus.notification.linux
+
+import io.github.kdroidfilter.nucleus.core.runtime.tools.debugln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.infoln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.warnln
+import java.nio.file.Files
+import java.nio.file.Path
+
+internal object NativeNotificationBridge {
+    private var loaded = false
+
+    fun load() {
+        if (loaded) return
+
+        try {
+            System.loadLibrary("nucleus_notification")
+            loaded = true
+            infoln { "NativeNotificationBridge (Linux): Library loaded via System.loadLibrary" }
+            return
+        } catch (_: UnsatisfiedLinkError) {
+            debugln { "NativeNotificationBridge (Linux): System.loadLibrary failed, trying resource extraction" }
+        }
+
+        try {
+            val arch = System.getProperty("os.arch").let {
+                when (it) {
+                    "aarch64", "arm64" -> "aarch64"
+                    else -> "x64"
+                }
+            }
+            val resourcePath = "/nucleus/native/linux-$arch/libnucleus_notification.so"
+            val stream = NativeNotificationBridge::class.java.getResourceAsStream(resourcePath)
+                ?: throw UnsatisfiedLinkError("Native library not found in JAR at $resourcePath")
+            val tempDir = Files.createTempDirectory("nucleus-native-linux")
+            val tempLib = tempDir.resolve("libnucleus_notification.so")
+            stream.use { Files.copy(it, tempLib) }
+            tempLib.toFile().deleteOnExit()
+            tempDir.toFile().deleteOnExit()
+            System.load(tempLib.toAbsolutePath().toString())
+            loaded = true
+            infoln { "NativeNotificationBridge (Linux): Library loaded via resource extraction" }
+        } catch (e: Exception) {
+            warnln {
+                "NativeNotificationBridge (Linux): " +
+                    "Failed to load nucleus_notification native library: ${e.message}"
+            }
+        }
+    }
+
+    val isLoaded: Boolean get() = loaded
+
+    @JvmStatic
+    external fun setDebugMode(enable: Int)
+
+    @JvmStatic
+    external fun init(appName: String): Int
+
+    @JvmStatic
+    external fun createNotification(
+        summary: String,
+        body: String,
+        iconPath: String?
+    ): Long
+
+    @JvmStatic
+    external fun addButtonToNotification(
+        notification: Long,
+        buttonId: String,
+        buttonLabel: String
+    )
+
+    @JvmStatic
+    external fun setNotificationClickedCallback(
+        notification: Long,
+        callback: NotificationClickedCallback?
+    )
+
+    @JvmStatic
+    external fun setNotificationClosedCallback(
+        notification: Long,
+        callback: NotificationClosedCallback?
+    )
+
+    @JvmStatic
+    external fun setButtonCallback(callback: ButtonClickedCallback?)
+
+    @JvmStatic
+    external fun setNotificationImage(notification: Long, imagePath: String)
+
+    @JvmStatic
+    external fun sendNotification(notification: Long): Int
+
+    @JvmStatic
+    external fun closeNotification(notification: Long): Int
+
+    @JvmStatic
+    external fun cleanupNotification(notification: Long)
+
+    @JvmStatic
+    external fun runMainLoop()
+
+    @JvmStatic
+    external fun quitMainLoop()
+
+    @JvmStatic
+    external fun cleanup()
+}
+
+abstract class NotificationClickedCallback {
+    abstract fun invoke(notificationPtr: Long, userData: Long)
+}
+
+abstract class NotificationClosedCallback {
+    abstract fun invoke(notificationPtr: Long, userData: Long)
+}
+
+abstract class ButtonClickedCallback {
+    abstract fun invoke(notificationPtr: Long, buttonId: String, userData: Long)
+}
diff --git a/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/mac/MacNotificationProvider.kt b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/mac/MacNotificationProvider.kt
new file mode 100644
index 00000000..98bc3194
--- /dev/null
+++ b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/mac/MacNotificationProvider.kt
@@ -0,0 +1,163 @@
+package io.github.kdroidfilter.nucleus.notification.mac
+
+import io.github.kdroidfilter.nucleus.core.runtime.tools.debugln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.errorln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.infoln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.warnln
+import io.github.kdroidfilter.nucleus.notification.builder.NotificationBuilder
+import io.github.kdroidfilter.nucleus.notification.builder.NotificationProvider
+import io.github.kdroidfilter.nucleus.notification.model.DismissalReason
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.io.File
+import java.nio.file.Files
+import java.util.concurrent.ConcurrentHashMap
+
+class MacNotificationProvider : NotificationProvider {
+    private val activeNotifications = ConcurrentHashMap<Int, Long>()
+    private var coroutineScope: CoroutineScope? = null
+
+    init {
+        NativeNotificationBridge.load()
+    }
+
+    override fun sendNotification(builder: NotificationBuilder) {
+        coroutineScope = CoroutineScope(Dispatchers.IO).also { scope ->
+            scope.launch {
+                try {
+                    val appIconPath = builder.smallIconPath
+                    infoln { "MacNotificationProvider: Sending notification with title: ${builder.title}" }
+
+                    val notificationPtr: Long = try {
+                        NativeNotificationBridge.createNotification(
+                            title = builder.title,
+                            body = builder.message,
+                            iconPath = appIconPath
+                        )
+                    } catch (e: Exception) {
+                        errorln { "MacNotificationProvider: Exception creating notification: ${e.message}" }
+                        -1L
+                    }
+
+                    if (notificationPtr <= 0L) {
+                        errorln { "MacNotificationProvider: Failed to create notification." }
+                        builder.onFailed?.invoke()
+                        return@launch
+                    }
+
+                    activeNotifications[builder.id] = notificationPtr
+
+                    builder.onActivated?.let { onActivated ->
+                        val callback = object : NotificationClickedCallback() {
+                            override fun invoke(notificationPtr: Long, userData: Long) {
+                                onActivated()
+                            }
+                        }
+                        NativeNotificationBridge.setNotificationClickedCallback(notificationPtr, callback)
+                    }
+
+                    builder.onDismissed?.let { onDismissed ->
+                        val callback = object : NotificationClosedCallback() {
+                            override fun invoke(notificationPtr: Long, userData: Long) {
+                                onDismissed(DismissalReason.UserCanceled)
+                            }
+                        }
+                        NativeNotificationBridge.setNotificationClosedCallback(notificationPtr, callback)
+                    }
+
+                    builder.largeImagePath?.let { path ->
+                        try {
+                            val file = File(path)
+                            val filePath = if (file.exists() && file.isFile) {
+                                file.absolutePath
+                            } else {
+                                extractToTempIfDifferent(path)?.absolutePath
+                            }
+                            filePath?.let {
+                                NativeNotificationBridge.setNotificationImage(notificationPtr, "file://$it")
+                            }
+                        } catch (e: Exception) {
+                            warnln { "MacNotificationProvider: Exception processing large image: ${e.message}" }
+                        }
+                    }
+
+                    builder.buttons.forEach { button ->
+                        NativeNotificationBridge.addButtonToNotification(
+                            notification = notificationPtr,
+                            buttonId = button.label,
+                            buttonLabel = button.label
+                        )
+                    }
+
+                    val result: Int = try {
+                        NativeNotificationBridge.sendNotification(notificationPtr)
+                    } catch (e: Exception) {
+                        errorln { "MacNotificationProvider: Exception sending notification: ${e.message}" }
+                        -1
+                    }
+
+                    if (result == 0) {
+                        infoln { "MacNotificationProvider: Notification sent successfully." }
+                    } else {
+                        errorln { "MacNotificationProvider: Failed to send notification." }
+                        builder.onFailed?.invoke()
+                        activeNotifications.remove(builder.id)
+                        try {
+                            NativeNotificationBridge.cleanupNotification(notificationPtr)
+                        } catch (e: Exception) {
+                            warnln { "MacNotificationProvider: Exception cleaning up notification: ${e.message}" }
+                        }
+                    }
+                } catch (e: Exception) {
+                    errorln { "MacNotificationProvider: Critical exception in sendNotification: ${e.message}" }
+                    builder.onFailed?.invoke()
+                }
+            }
+        }
+    }
+
+    override fun hideNotification(builder: NotificationBuilder) {
+        try {
+            val notificationPtr = activeNotifications[builder.id]
+            if (notificationPtr != null) {
+                try {
+                    NativeNotificationBridge.hideNotification(notificationPtr)
+                    infoln { "MacNotificationProvider: Notification hide called for ID: ${builder.id}" }
+                    Thread.sleep(100)
+                    NativeNotificationBridge.hideNotification(notificationPtr)
+                } catch (e: Exception) {
+                    warnln { "MacNotificationProvider: Exception hiding notification: ${e.message}" }
+                }
+
+                try {
+                    NativeNotificationBridge.cleanupNotification(notificationPtr)
+                } catch (e: Exception) {
+                    warnln { "MacNotificationProvider: Exception cleaning up notification: ${e.message}" }
+                }
+
+                activeNotifications.remove(builder.id)
+                infoln { "MacNotificationProvider: Notification hidden and cleaned up: ${builder.id}" }
+            } else {
+                warnln { "MacNotificationProvider: No active notification found with ID: ${builder.id}" }
+            }
+        } catch (e: Exception) {
+            errorln { "MacNotificationProvider: Critical exception in hideNotification: ${e.message}" }
+        }
+    }
+
+    private fun extractToTempIfDifferent(path: String): File? {
+        return try {
+            val resourceStream = MacNotificationProvider::class.java.getResourceAsStream("/$path")
+                ?: return null
+            val tempDir = Files.createTempDirectory("nucleus-notification")
+            val tempFile = tempDir.resolve(path.substringAfterLast("/"))
+            resourceStream.use { Files.copy(it, tempFile) }
+            tempFile.toFile().deleteOnExit()
+            tempDir.toFile().deleteOnExit()
+            tempFile.toFile()
+        } catch (e: Exception) {
+            null
+        }
+    }
+}
diff --git a/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/mac/NativeNotificationBridge.kt b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/mac/NativeNotificationBridge.kt
new file mode 100644
index 00000000..911fa248
--- /dev/null
+++ b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/mac/NativeNotificationBridge.kt
@@ -0,0 +1,90 @@
+package io.github.kdroidfilter.nucleus.notification.mac
+
+import io.github.kdroidfilter.nucleus.core.runtime.tools.debugln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.infoln
+import io.github.kdroidfilter.nucleus.core.runtime.tools.warnln
+import java.nio.file.Files
+
+internal object NativeNotificationBridge {
+    private var loaded = false
+
+    fun load() {
+        if (loaded) return
+
+        try {
+            System.loadLibrary("nucleus_notification")
+            loaded = true
+            infoln { "NativeNotificationBridge: Library loaded via System.loadLibrary" }
+            return
+        } catch (_: UnsatisfiedLinkError) {
+            debugln { "NativeNotificationBridge: System.loadLibrary failed, trying resource extraction" }
+        }
+
+        try {
+            val arch = System.getProperty("os.arch").let {
+                if (it == "aarch64" || it == "arm64") "aarch64" else "x64"
+            }
+            val resourcePath = "/nucleus/native/darwin-$arch/libnucleus_notification.dylib"
+            val stream = NativeNotificationBridge::class.java.getResourceAsStream(resourcePath)
+                ?: throw UnsatisfiedLinkError("Native library not found in JAR at $resourcePath")
+            val tempDir = Files.createTempDirectory("nucleus-native")
+            val tempLib = tempDir.resolve("libnucleus_notification.dylib")
+            stream.use { Files.copy(it, tempLib) }
+            tempLib.toFile().deleteOnExit()
+            tempDir.toFile().deleteOnExit()
+            System.load(tempLib.toAbsolutePath().toString())
+            loaded = true
+            infoln { "NativeNotificationBridge: Library loaded via resource extraction" }
+        } catch (e: Exception) {
+            warnln { "NativeNotificationBridge: Failed to load nucleus_notification native library: ${e.message}" }
+        }
+    }
+
+    val isLoaded: Boolean get() = loaded
+
+    @JvmStatic
+    external fun createNotification(title: String, body: String, iconPath: String?): Long
+
+    @JvmStatic
+    external fun addButtonToNotification(
+        notification: Long,
+        buttonId: String,
+        buttonLabel: String
+    )
+
+    @JvmStatic
+    external fun setNotificationClickedCallback(
+        notification: Long,
+        callback: NotificationClickedCallback?
+    )
+
+    @JvmStatic
+    external fun setNotificationClosedCallback(
+        notification: Long,
+        callback: NotificationClosedCallback?
+    )
+
+    @JvmStatic
+    external fun setNotificationImage(notification: Long, imagePath: String)
+
+    @JvmStatic
+    external fun sendNotification(notification: Long): Int
+
+    @JvmStatic
+    external fun hideNotification(notification: Long)
+
+    @JvmStatic
+    external fun cleanupNotification(notification: Long)
+}
+
+abstract class NotificationClickedCallback {
+    abstract fun invoke(notificationPtr: Long, userData: Long)
+}
+
+abstract class NotificationClosedCallback {
+    abstract fun invoke(notificationPtr: Long, userData: Long)
+}
+
+abstract class ButtonClickedCallback {
+    abstract fun invoke(notificationPtr: Long, buttonId: String, userData: Long)
+}
diff --git a/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/model/Button.kt b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/model/Button.kt
new file mode 100644
index 00000000..a12183a9
--- /dev/null
+++ b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/model/Button.kt
@@ -0,0 +1,3 @@
+package io.github.kdroidfilter.nucleus.notification.model
+
+data class Button(val label: String, val onClick: () -> Unit)
diff --git a/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/model/DismissalReason.kt b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/model/DismissalReason.kt
new file mode 100644
index 00000000..9fc351d7
--- /dev/null
+++ b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/model/DismissalReason.kt
@@ -0,0 +1,8 @@
+package io.github.kdroidfilter.nucleus.notification.model
+
+enum class DismissalReason {
+    UserCanceled,
+    ApplicationHidden,
+    TimedOut,
+    Unknown
+}
diff --git a/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/noop/NoOpNotificationProvider.kt b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/noop/NoOpNotificationProvider.kt
new file mode 100644
index 00000000..d091b602
--- /dev/null
+++ b/nucleus-notification/src/main/kotlin/io/github/kdroidfilter/nucleus/notification/noop/NoOpNotificationProvider.kt
@@ -0,0 +1,13 @@
+package io.github.kdroidfilter.nucleus.notification.noop
+
+import io.github.kdroidfilter.nucleus.notification.builder.NotificationBuilder
+import io.github.kdroidfilter.nucleus.notification.builder.NotificationProvider
+
+class NoOpNotificationProvider : NotificationProvider {
+    override fun sendNotification(builder: NotificationBuilder) {
+        builder.onFailed?.invoke()
+    }
+
+    override fun hideNotification(builder: NotificationBuilder) {
+    }
+}
diff --git a/nucleus-notification/src/main/native/linux/NucleusNotificationBridge.c b/nucleus-notification/src/main/native/linux/NucleusNotificationBridge.c
new file mode 100644
index 00000000..03d7d6a2
--- /dev/null
+++ b/nucleus-notification/src/main/native/linux/NucleusNotificationBridge.c
@@ -0,0 +1,454 @@
+#include <libnotify/notify.h>
+#include <glib.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <jni.h>
+
+/* Global variables */
+static JavaVM *g_jvm = NULL;
+static GMainLoop *main_loop = NULL;
+static int debug_mode = 0;
+
+/* Global references to callbacks - stored for callback invocation */
+static jobject g_clickedCallbackObj = NULL;
+static jobject g_closedCallbackObj = NULL;
+static jobject g_buttonCallbackObj = NULL;
+static jmethodID g_clickedMethod = NULL;
+static jmethodID g_closedMethod = NULL;
+static jmethodID g_buttonMethod = NULL;
+
+/* Active notifications map - maps notification ID to callback data */
+static GHashTable *notifications_map = NULL;
+
+/* Debug logging */
+static void debug_log(const char *format, ...) {
+    if (debug_mode) {
+        va_list args;
+        va_start(args, format);
+        vprintf(format, args);
+        va_end(args);
+    }
+}
+
+/* Suppress unused parameter warnings */
+#define UNUSED(x) (void)(x)
+
+/* Get JNI environment - thread safe */
+static JNIEnv* get_jni_env() {
+    JNIEnv *env = NULL;
+    if (g_jvm) {
+        int getEnvResult = (*g_jvm)->GetEnv(g_jvm, (void**)&env, JNI_VERSION_1_8);
+        if (getEnvResult == JNI_EDETACHED) {
+            (*g_jvm)->AttachCurrentThread(g_jvm, (void**)&env, NULL);
+        }
+    }
+    return env;
+}
+
+/* Invoke Java callback on click */
+static void invoke_clicked_callback(jlong notification_ptr) {
+    if (g_clickedCallbackObj && g_clickedMethod) {
+        JNIEnv *env = get_jni_env();
+        if (env) {
+            (*env)->CallVoidMethod(env, g_clickedCallbackObj, g_clickedMethod, notification_ptr, (jlong)NULL);
+        }
+    }
+}
+
+/* Invoke Java callback on close */
+static void invoke_closed_callback(jlong notification_ptr) {
+    if (g_closedCallbackObj && g_closedMethod) {
+        JNIEnv *env = get_jni_env();
+        if (env) {
+            (*env)->CallVoidMethod(env, g_closedCallbackObj, g_closedMethod, notification_ptr, (jlong)NULL);
+        }
+    }
+}
+
+/* Invoke Java button callback - passes button label as second parameter */
+static void invoke_button_callback(jlong notification_ptr, const char *button_label) {
+    if (g_buttonCallbackObj && g_buttonMethod) {
+        JNIEnv *env = get_jni_env();
+        if (env) {
+            jstring buttonStr = (*env)->NewStringUTF(env, button_label);
+            (*env)->CallVoidMethod(env, g_buttonCallbackObj, g_buttonMethod, notification_ptr, buttonStr, (jlong)NULL);
+            (*env)->DeleteLocalRef(env, buttonStr);
+        }
+    }
+}
+
+/* Button callback - calls Java button callback */
+static void button_action_callback(NotifyNotification *notification, char *action, gpointer user_data) {
+    jlong ptr = (jlong)(intptr_t)user_data;
+    debug_log("Button clicked: %s (ptr: %ld)\n", action, (long)ptr);
+    invoke_button_callback(ptr, action);
+    UNUSED(notification);
+}
+
+/* Default click callback */
+static void default_click_callback(NotifyNotification *notification, char *action, gpointer user_data) {
+    jlong ptr = (jlong)(intptr_t)user_data;
+    debug_log("Notification clicked (ptr: %ld)\n", (long)ptr);
+    invoke_clicked_callback(ptr);
+    UNUSED(notification);
+    UNUSED(action);
+}
+
+/* Closed signal callback */
+static void notification_closed_callback(NotifyNotification *notification, gpointer user_data) {
+    jlong ptr = (jlong)(intptr_t)user_data;
+    debug_log("Notification closed (ptr: %ld)\n", (long)ptr);
+    invoke_closed_callback(ptr);
+    UNUSED(notification);
+}
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
+    g_jvm = vm;
+
+    notifications_map = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
+
+    debug_log("JNI_OnLoad: Linux Notification Bridge initialized\n");
+
+    UNUSED(reserved);
+    return JNI_VERSION_1_8;
+}
+
+/* Set debug mode */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_setDebugMode(
+    JNIEnv *env, jclass clazz, jint enable) {
+    UNUSED(env);
+    UNUSED(clazz);
+    debug_mode = enable;
+    debug_log("Debug mode %s\n", enable ? "enabled" : "disabled");
+}
+
+/* Initialize notification library */
+JNIEXPORT jint JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_init(
+    JNIEnv *env, jclass clazz, jstring japp_name) {
+
+    UNUSED(clazz);
+
+    if (notify_is_initted()) {
+        debug_log("Notification system already initialized\n");
+        return 1;
+    }
+
+    const char *app_name = japp_name ? (*env)->GetStringUTFChars(env, japp_name, NULL) : "Nucleus";
+
+    int result = notify_init(app_name) ? 1 : 0;
+
+    if (japp_name) (*env)->ReleaseStringUTFChars(env, japp_name, app_name);
+
+    if (result) {
+        debug_log("Notification system initialized\n");
+    } else {
+        debug_log("Failed to initialize notification system\n");
+    }
+
+    return result;
+}
+
+/* Create notification */
+JNIEXPORT jlong JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_createNotification(
+    JNIEnv *env, jclass clazz, jstring jsummary, jstring jbody, jstring jicon_path) {
+
+    UNUSED(clazz);
+
+    if (!notify_is_initted()) {
+        debug_log("Notification system not initialized\n");
+        return -1;
+    }
+
+    const char *summary = jsummary ? (*env)->GetStringUTFChars(env, jsummary, NULL) : "";
+    const char *body = jbody ? (*env)->GetStringUTFChars(env, jbody, NULL) : "";
+    const char *icon_path = jicon_path ? (*env)->GetStringUTFChars(env, jicon_path, NULL) : NULL;
+
+    debug_log("Creating notification - Summary: %s, Body: %s, Icon: %s\n",
+              summary, body, icon_path ? icon_path : "none");
+
+    NotifyNotification *notification = notify_notification_new(summary, body, icon_path);
+
+    if (jsummary) (*env)->ReleaseStringUTFChars(env, jsummary, summary);
+    if (jbody) (*env)->ReleaseStringUTFChars(env, jbody, body);
+    if (jicon_path) (*env)->ReleaseStringUTFChars(env, jicon_path, icon_path);
+
+    if (notification == NULL) {
+        debug_log("Failed to create notification\n");
+        return -1;
+    }
+
+    /* Generate a unique ID for this notification */
+    static int notification_id = 0;
+    intptr_t ptr_value = ++notification_id;
+
+    /* Store notification pointer for callbacks */
+    g_hash_table_insert(notifications_map, GINT_TO_POINTER(ptr_value), notification);
+
+    debug_log("Notification created with ID: %ld\n", (long)ptr_value);
+
+    return (jlong)ptr_value;
+}
+
+/* Add button to notification */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_addButtonToNotification(
+    JNIEnv *env, jclass clazz, jlong notification_ptr, jstring jbutton_id, jstring jbutton_label) {
+
+    UNUSED(clazz);
+
+    NotifyNotification *notification = g_hash_table_lookup(notifications_map, GINT_TO_POINTER(notification_ptr));
+    if (notification == NULL) {
+        debug_log("Cannot add button: notification not found\n");
+        return;
+    }
+
+    const char *button_id = jbutton_id ? (*env)->GetStringUTFChars(env, jbutton_id, NULL) : "";
+    const char *button_label = jbutton_label ? (*env)->GetStringUTFChars(env, jbutton_label, NULL) : "";
+
+    debug_log("Adding button - ID: %s, Label: %s\n", button_id, button_label);
+
+    /* Use callback with user_data containing the notification ptr */
+    notify_notification_add_action(notification, button_id, button_label,
+                                  button_action_callback, (gpointer)notification_ptr, NULL);
+
+    if (jbutton_id) (*env)->ReleaseStringUTFChars(env, jbutton_id, button_id);
+    if (jbutton_label) (*env)->ReleaseStringUTFChars(env, jbutton_label, button_label);
+}
+
+/* Set notification clicked callback */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_setNotificationClickedCallback(
+    JNIEnv *env, jclass clazz, jlong notification_ptr, jobject callback) {
+
+    if (g_clickedCallbackObj) {
+        (*env)->DeleteGlobalRef(env, g_clickedCallbackObj);
+        g_clickedCallbackObj = NULL;
+        g_clickedMethod = NULL;
+    }
+
+    if (callback) {
+        g_clickedCallbackObj = (*env)->NewGlobalRef(env, callback);
+        jclass cls = (*env)->GetObjectClass(env, callback);
+        g_clickedMethod = (*env)->GetMethodID(env, cls, "invoke", "(JJ)V");
+        debug_log("Clicked callback set\n");
+    }
+
+    /* Also set up the notification click action */
+    NotifyNotification *notification = g_hash_table_lookup(notifications_map, GINT_TO_POINTER(notification_ptr));
+    if (notification && callback) {
+        notify_notification_add_action(notification, "default", "Default",
+                                      default_click_callback, (gpointer)notification_ptr, NULL);
+    }
+
+    UNUSED(clazz);
+}
+
+/* Set notification closed callback */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_setNotificationClosedCallback(
+    JNIEnv *env, jclass clazz, jlong notification_ptr, jobject callback) {
+
+    if (g_closedCallbackObj) {
+        (*env)->DeleteGlobalRef(env, g_closedCallbackObj);
+        g_closedCallbackObj = NULL;
+        g_closedMethod = NULL;
+    }
+
+    if (callback) {
+        g_closedCallbackObj = (*env)->NewGlobalRef(env, callback);
+        jclass cls = (*env)->GetObjectClass(env, callback);
+        g_closedMethod = (*env)->GetMethodID(env, cls, "invoke", "(JJ)V");
+        debug_log("Closed callback set\n");
+    }
+
+    /* Connect to closed signal */
+    NotifyNotification *notification = g_hash_table_lookup(notifications_map, GINT_TO_POINTER(notification_ptr));
+    if (notification && callback) {
+        g_signal_connect(notification, "closed", G_CALLBACK(notification_closed_callback), (gpointer)notification_ptr);
+    }
+
+    UNUSED(clazz);
+}
+
+/* Set button callback */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_setButtonCallback(
+    JNIEnv *env, jclass clazz, jobject callback) {
+
+    if (g_buttonCallbackObj) {
+        (*env)->DeleteGlobalRef(env, g_buttonCallbackObj);
+        g_buttonCallbackObj = NULL;
+        g_buttonMethod = NULL;
+    }
+
+    if (callback) {
+        g_buttonCallbackObj = (*env)->NewGlobalRef(env, callback);
+        jclass cls = (*env)->GetObjectClass(env, callback);
+        g_buttonMethod = (*env)->GetMethodID(env, cls, "invoke", "(JLjava/lang/String;J)V");
+        debug_log("Button callback set\n");
+    }
+
+    UNUSED(clazz);
+}
+
+/* Set notification image from file */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_setNotificationImage(
+    JNIEnv *env, jclass clazz, jlong notification_ptr, jstring jimage_path) {
+
+    UNUSED(clazz);
+
+    NotifyNotification *notification = g_hash_table_lookup(notifications_map, GINT_TO_POINTER(notification_ptr));
+    if (notification == NULL) {
+        debug_log("Cannot set image: notification not found\n");
+        return;
+    }
+
+    const char *image_path = jimage_path ? (*env)->GetStringUTFChars(env, jimage_path, NULL) : NULL;
+
+    if (image_path) {
+        debug_log("Loading image from: %s\n", image_path);
+
+        GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(image_path, NULL);
+        if (pixbuf != NULL) {
+            notify_notification_set_image_from_pixbuf(notification, pixbuf);
+            g_object_unref(pixbuf);
+            debug_log("Image set successfully\n");
+        } else {
+            debug_log("Failed to load image: %s\n", image_path);
+        }
+
+        (*env)->ReleaseStringUTFChars(env, jimage_path, image_path);
+    }
+}
+
+/* Send notification */
+JNIEXPORT jint JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_sendNotification(
+    JNIEnv *env, jclass clazz, jlong notification_ptr) {
+
+    UNUSED(env);
+    UNUSED(clazz);
+
+    NotifyNotification *notification = g_hash_table_lookup(notifications_map, GINT_TO_POINTER(notification_ptr));
+    if (notification == NULL) {
+        debug_log("Cannot send notification: not found\n");
+        return -1;
+    }
+
+    debug_log("Sending notification\n");
+
+    GError *error = NULL;
+    if (!notify_notification_show(notification, &error)) {
+        debug_log("Failed to send notification: %s\n", error ? error->message : "unknown error");
+        if (error) g_error_free(error);
+        return -1;
+    }
+
+    debug_log("Notification sent successfully\n");
+    return 0;
+}
+
+/* Close notification */
+JNIEXPORT jint JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_closeNotification(
+    JNIEnv *env, jclass clazz, jlong notification_ptr) {
+
+    UNUSED(env);
+    UNUSED(clazz);
+
+    NotifyNotification *notification = g_hash_table_lookup(notifications_map, GINT_TO_POINTER(notification_ptr));
+    if (notification == NULL) {
+        debug_log("Cannot close notification: not found\n");
+        return -1;
+    }
+
+    debug_log("Closing notification\n");
+
+    GError *error = NULL;
+    if (!notify_notification_close(notification, &error)) {
+        debug_log("Failed to close notification: %s\n", error ? error->message : "unknown error");
+        if (error) g_error_free(error);
+        return -1;
+    }
+
+    g_hash_table_remove(notifications_map, GINT_TO_POINTER(notification_ptr));
+
+    debug_log("Notification closed successfully\n");
+    return 0;
+}
+
+/* Cleanup notification */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_cleanupNotification(
+    JNIEnv *env, jclass clazz, jlong notification_ptr) {
+
+    UNUSED(env);
+    UNUSED(clazz);
+
+    debug_log("Cleaning up notification: %ld\n", (long)notification_ptr);
+
+    NotifyNotification *notification = g_hash_table_lookup(notifications_map, GINT_TO_POINTER(notification_ptr));
+    if (notification != NULL) {
+        g_object_unref(notification);
+    }
+    g_hash_table_remove(notifications_map, GINT_TO_POINTER(notification_ptr));
+}
+
+/* Run main loop */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_runMainLoop(
+    JNIEnv *env, jclass clazz) {
+
+    UNUSED(env);
+    UNUSED(clazz);
+
+    if (main_loop == NULL) {
+        main_loop = g_main_loop_new(NULL, FALSE);
+    }
+
+    debug_log("Starting main loop\n");
+    g_main_loop_run(main_loop);
+}
+
+/* Quit main loop */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_quitMainLoop(
+    JNIEnv *env, jclass clazz) {
+
+    UNUSED(env);
+    UNUSED(clazz);
+
+    debug_log("Stopping main loop\n");
+
+    if (main_loop != NULL && g_main_loop_is_running(main_loop)) {
+        g_main_loop_quit(main_loop);
+        g_main_loop_unref(main_loop);
+        main_loop = NULL;
+    }
+}
+
+/* Cleanup all resources */
+JNIEXPORT void JNICALL Java_io_github_kdroidfilter_nucleus_notification_linux_NativeNotificationBridge_cleanup(
+    JNIEnv *env, jclass clazz) {
+
+    UNUSED(clazz);
+
+    debug_log("Cleaning up all resources\n");
+
+    if (notifications_map) {
+        g_hash_table_destroy(notifications_map);
+        notifications_map = NULL;
+    }
+
+    if (main_loop) {
+        if (g_main_loop_is_running(main_loop)) {
+            g_main_loop_quit(main_loop);
+        }
+        g_main_loop_unref(main_loop);
+        main_loop = NULL;
+    }
+
+    notify_uninit();
+
+    if (g_clickedCallbackObj && env) {
+        (*env)->DeleteGlobalRef(env, g_clickedCallbackObj);
+        g_clickedCallbackObj = NULL;
+    }
+    if (g_closedCallbackObj && env) {
+        (*env)->DeleteGlobalRef(env, g_closedCallbackObj);
+        g_closedCallbackObj = NULL;
+    }
+}
diff --git a/nucleus-notification/src/main/native/linux/build.sh b/nucleus-notification/src/main/native/linux/build.sh
new file mode 100644
index 00000000..45b67fc3
--- /dev/null
+++ b/nucleus-notification/src/main/native/linux/build.sh
@@ -0,0 +1,120 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SRC="$SCRIPT_DIR/NucleusNotificationBridge.c"
+RESOURCE_DIR="$SCRIPT_DIR/../../resources/nucleus/native"
+OUT_DIR_X64="$RESOURCE_DIR/linux-x64"
+OUT_DIR_ARM64="$RESOURCE_DIR/linux-aarch64"
+
+# Check for Java
+if [ -z "${JAVA_HOME:-}" ]; then
+    if command -v java &> /dev/null; then
+        JAVA_HOME=$(dirname "$(dirname "$(readlink -f "$(which java)")")")
+    fi
+fi
+
+if [ -z "${JAVA_HOME:-}" ]; then
+    echo "ERROR: JAVA_HOME not set and java not found in PATH" >&2
+    exit 1
+fi
+
+JNI_INCLUDE="$JAVA_HOME/include"
+JNI_INCLUDE_LINUX="$JAVA_HOME/include/linux"
+
+if [ ! -d "$JNI_INCLUDE" ]; then
+    echo "ERROR: JNI headers not found at $JNI_INCLUDE" >&2
+    exit 1
+fi
+
+# Check for required libraries
+if ! command -v pkg-config &> /dev/null; then
+    echo "ERROR: pkg-config not found. Install it to detect libraries." >&2
+    exit 1
+fi
+
+# Get library flags
+PKG_CFLAGS=$(pkg-config --cflags libnotify glib-2.0 gdk-pixbuf-2.0 2>/dev/null || echo "")
+PKG_LIBS=$(pkg-config --libs libnotify glib-2.0 gdk-pixbuf-2.0 2>/dev/null || echo "")
+
+if [ -z "$PKG_LIBS" ]; then
+    echo "ERROR: Required libraries not found. Install with:" >&2
+    echo "  sudo apt install libnotify-dev libglib2.0-dev libgdk-pixbuf2.0-dev" >&2
+    exit 1
+fi
+
+# Create output directories
+mkdir -p "$OUT_DIR_X64" "$OUT_DIR_ARM64"
+
+echo "Building Linux native notification library..."
+echo "  Source: $SRC"
+echo "  Java: $JAVA_HOME"
+
+# Common flags
+COMMON_FLAGS=(
+    -shared
+    -fPIC
+    -O2
+    -Wall
+    -Wextra
+    -fvisibility=hidden
+    -I"$JNI_INCLUDE"
+    -I"$JNI_INCLUDE_LINUX"
+    $PKG_CFLAGS
+)
+
+# Build for x86_64 (native) - always
+echo ""
+echo "Building for linux-x64..."
+gcc "${COMMON_FLAGS[@]}" \
+    -m64 \
+    -o "$OUT_DIR_X64/libnucleus_notification.so" "$SRC" \
+    $PKG_LIBS
+strip -s "$OUT_DIR_X64/libnucleus_notification.so"
+echo "  Built: $OUT_DIR_X64/libnucleus_notification.so"
+ls -lh "$OUT_DIR_X64/libnucleus_notification.so"
+
+# Check for ARM64 cross-compiler
+BUILD_ARM64=false
+if command -v aarch64-linux-gnu-gcc &> /dev/null; then
+    BUILD_ARM64=true
+fi
+
+# Also check CI environment variable
+if [ -n "${CI:-}" ]; then
+    echo "  CI detected, attempting ARM64 build..."
+    BUILD_ARM64=true
+fi
+
+if [ "$BUILD_ARM64" = true ]; then
+    echo ""
+    echo "Building for linux-aarch64 (ARM64)..."
+    
+    # Try cross-compile with aarch64-linux-gnu-gcc
+    aarch64-linux-gnu-gcc "${COMMON_FLAGS[@]}" \
+        -march=armv8-a \
+        -o "$OUT_DIR_ARM64/libnucleus_notification.so" "$SRC" \
+        $PKG_LIBS 2>/dev/null || {
+        echo "  WARNING: ARM64 cross-compile failed - this is expected on non-ARM64 hosts without proper sysroot"
+        rm -rf "$OUT_DIR_ARM64"
+        echo "  ARM64 build skipped (handled in CI)"
+    }
+    
+    if [ -f "$OUT_DIR_ARM64/libnucleus_notification.so" ]; then
+        aarch64-linux-gnu-strip -s "$OUT_DIR_ARM64/libnucleus_notification.so"
+        echo "  Built: $OUT_DIR_ARM64/libnucleus_notification.so"
+        ls -lh "$OUT_DIR_ARM64/libnucleus_notification.so"
+    fi
+else
+    echo ""
+    echo "Note: ARM64 build skipped (not needed for x64 host)"
+    echo "      ARM64 cross-compilation handled in CI pipeline"
+    rm -rf "$OUT_DIR_ARM64"
+fi
+
+echo ""
+echo "Build complete!"
+echo ""
+echo "Output files:"
+ls -lh "$OUT_DIR_X64/libnucleus_notification.so" 2>/dev/null || true
+ls -lh "$OUT_DIR_ARM64/libnucleus_notification.so" 2>/dev/null || true
diff --git a/nucleus-notification/src/main/native/macos/NucleusNotificationBridge.m b/nucleus-notification/src/main/native/macos/NucleusNotificationBridge.m
new file mode 100644
index 00000000..122af3eb
--- /dev/null
+++ b/nucleus-notification/src/main/native/macos/NucleusNotificationBridge.m
@@ -0,0 +1,305 @@
+#import <Cocoa/Cocoa.h>
+#import <UserNotifications/UserNotifications.h>
+#import <jni.h>
+
+static JavaVM *g_jvm = NULL;
+
+static NSMutableDictionary *g_notifications = nil;
+static NSObject *g_callbackLock = nil;
+static jobject g_clickedCallbackObj = NULL;
+static jobject g_closedCallbackObj = NULL;
+static jobject g_buttonCallbackObj = NULL;
+static jmethodID g_clickedMethod = NULL;
+static jmethodID g_closedMethod = NULL;
+static jmethodID g_buttonMethod = NULL;
+static BOOL g_isBundleValid = NO;
+static BOOL g_notificationsAvailable = NO;
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
+    g_jvm = vm;
+    g_notifications = [[NSMutableDictionary alloc] init];
+    g_callbackLock = [[NSObject alloc] init];
+    
+    NSBundle *mainBundle = [NSBundle mainBundle];
+    if (mainBundle && mainBundle.bundleURL) {
+        NSString *bundlePath = mainBundle.bundleURL.path;
+        if (bundlePath && bundlePath.length > 0 && ![bundlePath hasSuffix:@"/bin"]) {
+            g_isBundleValid = YES;
+        }
+    }
+    
+    return JNI_VERSION_1_8;
+}
+
+@interface NotificationCenterDelegate : NSObject <UNUserNotificationCenterDelegate>
+@end
+
+@implementation NotificationCenterDelegate
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+       didReceiveNotificationResponse:(UNNotificationResponse *)response
+                withCompletionHandler:(void (^)(void))completionHandler {
+    NSString *identifier = response.notification.request.identifier;
+    NSDictionary *notifDict = nil;
+    
+    @synchronized(g_callbackLock) {
+        notifDict = g_notifications[identifier];
+    }
+    
+    if (notifDict && g_jvm) {
+        JNIEnv *env = NULL;
+        (*g_jvm)->GetEnv(g_jvm, (void**)&env, JNI_VERSION_1_8);
+        
+        if (env) {
+            NSString *actionId = response.actionIdentifier;
+            NSNumber *ptrNum = notifDict[@"ptr"];
+            jlong ptr = [ptrNum longValue];
+            
+            if ([actionId isEqualToString:UNNotificationDefaultActionIdentifier]) {
+                if (g_clickedCallbackObj && g_clickedMethod) {
+                    (*env)->CallVoidMethod(env, g_clickedCallbackObj, g_clickedMethod, ptr, (jlong)NULL);
+                }
+            } else if (g_buttonCallbackObj && g_buttonMethod) {
+                const char *buttonIdChars = [actionId UTF8String];
+                jstring buttonIdStr = (*env)->NewStringUTF(env, buttonIdChars);
+                (*env)->CallVoidMethod(env, g_buttonCallbackObj, g_buttonMethod, ptr, buttonIdStr, (jlong)NULL);
+            }
+        }
+    }
+    
+    completionHandler();
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+       willPresentNotification:(UNNotification *)notification
+       withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
+    if (@available(macOS 11.0, *)) {
+        completionHandler(UNNotificationPresentationOptionBanner | UNNotificationPresentationOptionSound);
+    } else {
+        completionHandler(UNNotificationPresentationOptionAlert | UNNotificationPresentationOptionSound);
+    }
+}
+
+@end
+
+static NotificationCenterDelegate *g_delegate = NULL;
+
+static void ensureDelegate() {
+    if (!g_isBundleValid) {
+        return;
+    }
+    
+    if (g_delegate == NULL) {
+        @try {
+            g_delegate = [[NotificationCenterDelegate alloc] init];
+            [[UNUserNotificationCenter currentNotificationCenter] setDelegate:g_delegate];
+            
+            [[UNUserNotificationCenter currentNotificationCenter] requestAuthorizationWithOptions:(UNAuthorizationOptionAlert | UNAuthorizationOptionSound | UNAuthorizationOptionBadge)
+                completionHandler:^(BOOL granted, NSError * _Nullable error) {
+                    if (error) {
+                        NSLog(@"Notification authorization error: %@", error);
+                    }
+                    g_notificationsAvailable = granted;
+                }];
+            g_notificationsAvailable = YES;
+        } @catch (NSException *exception) {
+            NSLog(@"Exception initializing notifications: %@", exception);
+            g_notificationsAvailable = NO;
+        }
+    }
+}
+
+JNIEXPORT jlong JNICALL
+Java_io_github_kdroidfilter_nucleus_notification_mac_NativeNotificationBridge_createNotification(
+    JNIEnv *env, jclass clazz, jstring jtitle, jstring jbody, jstring jiconPath) {
+
+    if (!g_isBundleValid) {
+        NSLog(@"Notifications require running from an app bundle, not from bin directory");
+        return -1;
+    }
+
+    ensureDelegate();
+
+    if (!g_notificationsAvailable) {
+        return -1;
+    }
+
+    const char *titleChars = jtitle ? (*env)->GetStringUTFChars(env, jtitle, NULL) : "";
+    const char *bodyChars = jbody ? (*env)->GetStringUTFChars(env, jbody, NULL) : "";
+    
+    NSString *titleStr = [NSString stringWithUTF8String:titleChars ? titleChars : ""];
+    NSString *bodyStr = [NSString stringWithUTF8String:bodyChars ? bodyChars : ""];
+
+    if (jtitle) (*env)->ReleaseStringUTFChars(env, jtitle, titleChars);
+    if (jbody) (*env)->ReleaseStringUTFChars(env, jbody, bodyChars);
+
+    NSUUID *uuid = [NSUUID UUID];
+    NSString *identifier = [uuid UUIDString];
+    jlong ptrValue = (jlong)(intptr_t)arc4random();
+
+    NSDictionary *notifDict = @{
+        @"title": titleStr ?: @"",
+        @"body": bodyStr ?: @"",
+        @"identifier": identifier,
+        @"ptr": @(ptrValue)
+    };
+
+    @synchronized(g_callbackLock) {
+        g_notifications[identifier] = notifDict;
+    }
+
+    return ptrValue;
+}
+
+JNIEXPORT void JNICALL
+Java_io_github_kdroidfilter_nucleus_notification_mac_NativeNotificationBridge_addButtonToNotification(
+    JNIEnv *env, jclass clazz, jlong notificationPtr, jstring jbuttonId, jstring jbuttonLabel) {
+    const char *buttonIdChars = jbuttonId ? (*env)->GetStringUTFChars(env, jbuttonId, NULL) : "";
+    const char *buttonLabelChars = jbuttonLabel ? (*env)->GetStringUTFChars(env, jbuttonLabel, NULL) : "";
+    
+    if (jbuttonId) (*env)->ReleaseStringUTFChars(env, jbuttonId, buttonIdChars);
+    if (jbuttonLabel) (*env)->ReleaseStringUTFChars(env, jbuttonLabel, buttonLabelChars);
+}
+
+JNIEXPORT void JNICALL
+Java_io_github_kdroidfilter_nucleus_notification_mac_NativeNotificationBridge_setNotificationClickedCallback(
+    JNIEnv *env, jclass clazz, jlong notificationPtr, jobject callback) {
+
+    if (g_clickedCallbackObj) {
+        (*env)->DeleteGlobalRef(env, g_clickedCallbackObj);
+        g_clickedCallbackObj = NULL;
+    }
+
+    if (callback) {
+        g_clickedCallbackObj = (*env)->NewGlobalRef(env, callback);
+        g_clickedMethod = (*env)->GetMethodID(env, (*env)->GetObjectClass(env, callback), "invoke", "(JJ)V");
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_io_github_kdroidfilter_nucleus_notification_mac_NativeNotificationBridge_setNotificationClosedCallback(
+    JNIEnv *env, jclass clazz, jlong notificationPtr, jobject callback) {
+
+    if (g_closedCallbackObj) {
+        (*env)->DeleteGlobalRef(env, g_closedCallbackObj);
+        g_closedCallbackObj = NULL;
+    }
+
+    if (callback) {
+        g_closedCallbackObj = (*env)->NewGlobalRef(env, callback);
+        g_closedMethod = (*env)->GetMethodID(env, (*env)->GetObjectClass(env, callback), "invoke", "(JJ)V");
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_io_github_kdroidfilter_nucleus_notification_mac_NativeNotificationBridge_setNotificationImage(
+    JNIEnv *env, jclass clazz, jlong notificationPtr, jstring jimagePath) {
+}
+
+JNIEXPORT jint JNICALL
+Java_io_github_kdroidfilter_nucleus_notification_mac_NativeNotificationBridge_sendNotification(
+    JNIEnv *env, jclass clazz, jlong notificationPtr) {
+
+    if (!g_isBundleValid || !g_notificationsAvailable) {
+        return -1;
+    }
+
+    __block NSString *foundIdentifier = nil;
+
+    @synchronized(g_callbackLock) {
+        for (NSString *key in g_notifications) {
+            NSDictionary *dict = g_notifications[key];
+            if ([[dict[@"ptr"] stringValue] isEqualToString:[NSString stringWithFormat:@"%ld", (long)notificationPtr]]) {
+                foundIdentifier = key;
+                break;
+            }
+        }
+    }
+
+    if (!foundIdentifier) {
+        return -1;
+    }
+
+    NSDictionary *notifDict = nil;
+    @synchronized(g_callbackLock) {
+        notifDict = g_notifications[foundIdentifier];
+    }
+
+    UNMutableNotificationContent *content = [[UNMutableNotificationContent alloc] init];
+    content.title = notifDict[@"title"];
+    content.body = notifDict[@"body"];
+
+    UNNotificationTrigger *trigger = [UNTimeIntervalNotificationTrigger triggerWithTimeInterval:0.1 repeats:NO];
+    UNNotificationRequest *request = [UNNotificationRequest requestWithIdentifier:foundIdentifier
+                                                                          content:content
+                                                                          trigger:trigger];
+
+    @try {
+        [[UNUserNotificationCenter currentNotificationCenter] addNotificationRequest:request
+            withCompletionHandler:^(NSError * _Nullable error) {
+                if (error) {
+                    NSLog(@"Error sending notification: %@", error);
+                }
+            }];
+    } @catch (NSException *exception) {
+        NSLog(@"Exception sending notification: %@", exception);
+        return -1;
+    }
+
+    return 0;
+}
+
+JNIEXPORT void JNICALL
+Java_io_github_kdroidfilter_nucleus_notification_mac_NativeNotificationBridge_hideNotification(
+    JNIEnv *env, jclass clazz, jlong notificationPtr) {
+
+    if (!g_isBundleValid || !g_notificationsAvailable) {
+        return;
+    }
+
+    __block NSString *foundIdentifier = nil;
+
+    @synchronized(g_callbackLock) {
+        for (NSString *key in g_notifications) {
+            NSDictionary *dict = g_notifications[key];
+            if ([[dict[@"ptr"] stringValue] isEqualToString:[NSString stringWithFormat:@"%ld", (long)notificationPtr]]) {
+                foundIdentifier = key;
+                break;
+            }
+        }
+    }
+
+    if (foundIdentifier) {
+        @try {
+            [[UNUserNotificationCenter currentNotificationCenter] removeDeliveredNotificationsWithIdentifiers:@[foundIdentifier]];
+        } @catch (NSException *exception) {
+            NSLog(@"Exception hiding notification: %@", exception);
+        }
+        @synchronized(g_callbackLock) {
+            [g_notifications removeObjectForKey:foundIdentifier];
+        }
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_io_github_kdroidfilter_nucleus_notification_mac_NativeNotificationBridge_cleanupNotification(
+    JNIEnv *env, jclass clazz, jlong notificationPtr) {
+
+    __block NSString *foundIdentifier = nil;
+
+    @synchronized(g_callbackLock) {
+        for (NSString *key in g_notifications) {
+            NSDictionary *dict = g_notifications[key];
+            if ([[dict[@"ptr"] stringValue] isEqualToString:[NSString stringWithFormat:@"%ld", (long)notificationPtr]]) {
+                foundIdentifier = key;
+                break;
+            }
+        }
+    }
+
+    if (foundIdentifier) {
+        @synchronized(g_callbackLock) {
+            [g_notifications removeObjectForKey:foundIdentifier];
+        }
+    }
+}
diff --git a/nucleus-notification/src/main/native/macos/build.sh b/nucleus-notification/src/main/native/macos/build.sh
new file mode 100644
index 00000000..f816c444
--- /dev/null
+++ b/nucleus-notification/src/main/native/macos/build.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SRC="$SCRIPT_DIR/NucleusNotificationBridge.m"
+RESOURCE_DIR="$SCRIPT_DIR/../../resources/nucleus/native"
+OUT_DIR_ARM64="$RESOURCE_DIR/darwin-aarch64"
+OUT_DIR_X64="$RESOURCE_DIR/darwin-x64"
+
+if [ -z "${JAVA_HOME:-}" ]; then
+    JAVA_HOME=$(/usr/libexec/java_home 2>/dev/null || true)
+fi
+if [ -z "${JAVA_HOME:-}" ]; then
+    echo "ERROR: JAVA_HOME not set and /usr/libexec/java_home failed." >&2
+    exit 1
+fi
+
+JNI_INCLUDE="$JAVA_HOME/include"
+JNI_INCLUDE_DARWIN="$JAVA_HOME/include/darwin"
+
+if [ ! -d "$JNI_INCLUDE" ]; then
+    echo "ERROR: JNI headers not found at $JNI_INCLUDE" >&2
+    exit 1
+fi
+
+mkdir -p "$OUT_DIR_ARM64" "$OUT_DIR_X64"
+
+COMMON_FLAGS=(
+    -dynamiclib
+    -I"$JNI_INCLUDE" -I"$JNI_INCLUDE_DARWIN"
+    -framework Cocoa
+    -framework UserNotifications
+    -mmacosx-version-min=10.14
+    -fobjc-arc
+    -Oz
+    -flto
+    -fvisibility=hidden
+    -Wl,-dead_strip
+    -Wl,-x
+)
+
+clang -arch arm64 "${COMMON_FLAGS[@]}" \
+    -o "$OUT_DIR_ARM64/libnucleus_notification.dylib" "$SRC"
+strip -x "$OUT_DIR_ARM64/libnucleus_notification.dylib"
+
+clang -arch x86_64 "${COMMON_FLAGS[@]}" \
+    -o "$OUT_DIR_X64/libnucleus_notification.dylib" "$SRC"
+strip -x "$OUT_DIR_X64/libnucleus_notification.dylib"
+
+echo "Built per-architecture dylibs:"
+ls -lh "$OUT_DIR_ARM64/libnucleus_notification.dylib"
+ls -lh "$OUT_DIR_X64/libnucleus_notification.dylib"
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 12b92772..bcab6cdc 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -38,4 +38,5 @@ include(":native-http-okhttp")
 include(":native-http-ktor")
 include(":decorated-window")
 include(":decorated-window-material")
+include(":nucleus-notification")
 includeBuild("plugin-build")