Add desktop services: open URI, notify, appearance, bell, and paths

wsap_term keeps per-platform code for opening links, notifications, the
bell, high-contrast detection, the executable and bundle paths, and the
default locale. These now live behind <yasl/desktop.h>.

On Linux, src/platform/freedesktop serves both backends. Opening a URI
runs xdg-open from PATH through a double fork, so the opener gets default
signal dispositions, an empty mask, a new session, and none of the
application's descriptors. Notifications and the Settings portal use the
session bus through libdbus-1, an optional dependency behind -Ddbus.
Appearance falls back to GTK_THEME without a portal. The bell uses
xdg-system-bell on Wayland and the XKB bell on X11.

Cocoa implements the same calls with NSWorkspace, UserNotifications, the
effective appearance, NSBeep, the bundle, and CFLocale. That code is not
built or run here; it needs a macOS check.

The desktop test runs under dbus-run-session against a fake notification
server and portal, and uses a fake xdg-open to check argument passing,
signal state, and descriptor inheritance.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

14 files changed, 548 insertions, 1 deletions

diff --git a/src/platform/cocoa/desktop.m b/src/platform/cocoa/desktop.m
new file mode 100644
index 0000000..526cbb9
--- /dev/null
+++ b/src/platform/cocoa/desktop.m
@@ -0,0 +1,145 @@
+#import <AppKit/AppKit.h>
+#import <UserNotifications/UserNotifications.h>
+
+#include "common/desktop.h"
+#include "yasl/desktop.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <limits.h>
+#include <mach-o/dyld.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static size_t copy_str(char *buf, size_t cap, const char *s)
+{
+    size_t len = s ? strlen(s) : 0;
+    if (!len || len >= cap) return 0;
+    memcpy(buf, s, len + 1);
+    return len;
+}
+
+bool desktop_open_uri(const char *uri)
+{
+    @autoreleasepool {
+        NSString *str = [NSString stringWithUTF8String:uri];
+        NSURL *url = str ? [NSURL URLWithString:str] : nil;
+        return url && [[NSWorkspace sharedWorkspace] openURL:url];
+    }
+}
+
+/* Show banners while the application is in front, too. */
+@interface YaslNotificationDelegate : NSObject <UNUserNotificationCenterDelegate>
+@end
+
+@implementation YaslNotificationDelegate
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+       willPresentNotification:(UNNotification *)notification
+         withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler
+{
+    (void)center;
+    (void)notification;
+    completionHandler(UNNotificationPresentationOptionBanner);
+}
+@end
+
+static YaslNotificationDelegate *notification_delegate;
+static bool authorization_requested;
+
+/* UNUserNotificationCenter raises an exception outside an app bundle. */
+static bool notifications_available(void)
+{
+    NSBundle *bundle = [NSBundle mainBundle];
+    return bundle.bundleIdentifier && [bundle.bundlePath.pathExtension isEqualToString:@"app"];
+}
+
+bool desktop_notify(const char *app_id, const char *title, const char *body)
+{
+    (void)app_id;
+    if (!notifications_available()) return false;
+    @autoreleasepool {
+        NSString *heading = [NSString stringWithUTF8String:title];
+        NSString *message = [NSString stringWithUTF8String:body];
+        if (!heading || !message) return false;
+        UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+        if (!notification_delegate) {
+            notification_delegate = [[YaslNotificationDelegate alloc] init];
+            center.delegate = notification_delegate;
+        }
+        if (!authorization_requested) {
+            authorization_requested = true;
+            [center requestAuthorizationWithOptions:UNAuthorizationOptionAlert
+                                  completionHandler:^(BOOL granted, NSError *error) {
+                (void)granted;
+                (void)error;
+            }];
+        }
+        UNMutableNotificationContent *content = [[UNMutableNotificationContent alloc] init];
+        content.title = heading;
+        content.body = message;
+        UNNotificationRequest *request =
+            [UNNotificationRequest requestWithIdentifier:[[NSUUID UUID] UUIDString]
+                                                 content:content
+                                                 trigger:nil];
+        [content release];
+        [center addNotificationRequest:request withCompletionHandler:nil];
+        return true;
+    }
+}
+
+uint32_t desktop_appearance(void)
+{
+    @autoreleasepool {
+        uint32_t flags = 0;
+        NSAppearanceName name = [NSApp.effectiveAppearance
+            bestMatchFromAppearancesWithNames:@[NSAppearanceNameAqua, NSAppearanceNameDarkAqua]];
+        if ([name isEqualToString:NSAppearanceNameDarkAqua])
+            flags |= YASL_APPEARANCE_DARK;
+        else if (name)
+            flags |= YASL_APPEARANCE_LIGHT;
+        if ([NSWorkspace sharedWorkspace].accessibilityDisplayShouldIncreaseContrast)
+            flags |= YASL_APPEARANCE_HIGH_CONTRAST;
+        return flags;
+    }
+}
+
+size_t desktop_executable_path(char *buf, size_t cap)
+{
+    char raw[PATH_MAX];
+    uint32_t size = sizeof(raw);
+    char resolved[PATH_MAX];
+    if (_NSGetExecutablePath(raw, &size) != 0 || !realpath(raw, resolved)) return 0;
+    return copy_str(buf, cap, resolved);
+}
+
+size_t desktop_resource_dir(char *buf, size_t cap)
+{
+    @autoreleasepool {
+        NSBundle *bundle = [NSBundle mainBundle];
+        if (!bundle.bundleIdentifier || ![bundle.bundlePath.pathExtension isEqualToString:@"app"])
+            return 0;
+        NSString *path = bundle.resourcePath;
+        return path ? copy_str(buf, cap, path.fileSystemRepresentation) : 0;
+    }
+}
+
+size_t desktop_default_locale(char *buf, size_t cap)
+{
+    /* Identifiers such as "zh-Hans_CN" are not POSIX names, so build the name
+     * from the language and region codes alone. */
+    char name[64] = "en_US.UTF-8";
+    CFLocaleRef locale = CFLocaleCopyCurrent();
+    if (locale) {
+        CFStringRef language = CFLocaleGetValue(locale, kCFLocaleLanguageCode);
+        CFStringRef region = CFLocaleGetValue(locale, kCFLocaleCountryCode);
+        char lang[16], reg[16];
+        if (language && CFStringGetCString(language, lang, sizeof(lang), kCFStringEncodingUTF8) && lang[0]) {
+            if (region && CFStringGetCString(region, reg, sizeof(reg), kCFStringEncodingUTF8) && reg[0])
+                snprintf(name, sizeof(name), "%s_%s.UTF-8", lang, reg);
+            else
+                snprintf(name, sizeof(name), "%s.UTF-8", lang);
+        }
+        CFRelease(locale);
+    }
+    return copy_str(buf, cap, name);
+}
diff --git a/src/platform/cocoa/meson.build b/src/platform/cocoa/meson.build
index 8230376..5fc5f5e 100644
--- a/src/platform/cocoa/meson.build
+++ b/src/platform/cocoa/meson.build
@@ -1 +1 @@
-sources += files('window.m', 'keymap.c')
+sources += files('window.m', 'desktop.m', 'keymap.c')
diff --git a/src/platform/cocoa/window.m b/src/platform/cocoa/window.m
index 811a7c6..75dce54 100644
--- a/src/platform/cocoa/window.m
+++ b/src/platform/cocoa/window.m
@@ -1366,6 +1366,7 @@ struct cocoa_display *cocoa_display_open(struct yasl_loop *loop, const struct ya
         darwin_ctx.cbs = &darwin_ctx.base.callbacks;
         darwin_ctx.ud = spec->ud;
         if (spec->app_id) darwin_ctx.app_id = strdup(spec->app_id);
+        darwin_ctx.base.app_id = darwin_ctx.app_id;
     }
     return &darwin_ctx;
 }
@@ -2191,6 +2192,14 @@ static bool impl_surface_place_under_pointer(struct yasl_surface *s, struct yasl
     return cocoa_surface_place_under_pointer((struct cocoa_surface *)s, at);
 }
 
+static bool impl_surface_bell(struct yasl_surface *s)
+{
+    assert([NSThread isMainThread]);
+    (void)s;
+    NSBeep();
+    return true;
+}
+
 static void *impl_display_get_native_handle(struct yasl_display *d)
 {
     return d ? (void *)NSApp : NULL;
@@ -2249,6 +2258,7 @@ const struct yasl_backend_ops yasl_cocoa_backend = {
     .surface_show_window_menu = impl_surface_show_window_menu,
     .surface_drag_carry = impl_surface_drag_carry,
     .surface_place_under_pointer = impl_surface_place_under_pointer,
+    .surface_bell = impl_surface_bell,
     .display_get_native_handle = impl_display_get_native_handle,
     .surface_get_native_handle = impl_surface_get_native_handle,
     .surface_get_native_frame = impl_surface_get_native_frame,
diff --git a/src/platform/freedesktop/dbus.c b/src/platform/freedesktop/dbus.c
new file mode 100644
index 0000000..abca900
--- /dev/null
+++ b/src/platform/freedesktop/dbus.c
@@ -0,0 +1,187 @@
+#define _GNU_SOURCE
+#include "platform/freedesktop/dbus.h"
+
+#if YASL_HAS_DBUS
+
+#include <dbus/dbus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+/* The portal may need activation on first use; bound how long a query blocks. */
+#define PORTAL_TIMEOUT_MS 1000
+
+static DBusConnection *bus;
+
+/* The session bus address, without libdbus's X11 autolaunch fallback. */
+static char *session_address(void)
+{
+    const char *env = getenv("DBUS_SESSION_BUS_ADDRESS");
+    if (env && *env) return strdup(env);
+    const char *run = getenv("XDG_RUNTIME_DIR");
+    if (!run || !*run) return NULL;
+    char path[4096];
+    struct stat st;
+    if (snprintf(path, sizeof(path), "%s/bus", run) >= (int)sizeof(path) ||
+        stat(path, &st) != 0 || !S_ISSOCK(st.st_mode))
+        return NULL;
+    char *escaped = dbus_address_escape_value(path);
+    if (!escaped) return NULL;
+    char *address = NULL;
+    if (asprintf(&address, "unix:path=%s", escaped) < 0) address = NULL;
+    dbus_free(escaped);
+    return address;
+}
+
+static DBusConnection *session_bus(void)
+{
+    if (bus && dbus_connection_get_is_connected(bus)) return bus;
+    if (bus) {
+        dbus_connection_close(bus);
+        dbus_connection_unref(bus);
+        bus = NULL;
+    }
+    char *address = session_address();
+    if (!address) return NULL;
+    DBusError err;
+    dbus_error_init(&err);
+    DBusConnection *c = dbus_connection_open_private(address, &err);
+    free(address);
+    if (!c) {
+        dbus_error_free(&err);
+        return NULL;
+    }
+    dbus_connection_set_exit_on_disconnect(c, FALSE);
+    if (!dbus_bus_register(c, &err)) {
+        dbus_error_free(&err);
+        dbus_connection_close(c);
+        dbus_connection_unref(c);
+        return NULL;
+    }
+    bus = c;
+    return bus;
+}
+
+bool bus_notify(const char *app, const char *title, const char *body)
+{
+    DBusConnection *c = session_bus();
+    if (!c) return false;
+    DBusMessage *msg = dbus_message_new_method_call("org.freedesktop.Notifications",
+            "/org/freedesktop/Notifications", "org.freedesktop.Notifications", "Notify");
+    if (!msg) return false;
+
+    const char *icon = "";
+    dbus_uint32_t replaces = 0;
+    dbus_int32_t expire = -1;
+    DBusMessageIter it, sub, entry, value;
+    dbus_message_iter_init_append(msg, &it);
+    bool ok = dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &app) &&
+        dbus_message_iter_append_basic(&it, DBUS_TYPE_UINT32, &replaces) &&
+        dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &icon) &&
+        dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &title) &&
+        dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &body);
+    /* No actions. */
+    ok = ok && dbus_message_iter_open_container(&it, DBUS_TYPE_ARRAY, "s", &sub) &&
+        dbus_message_iter_close_container(&it, &sub);
+    /* Hints: desktop-entry names the application's .desktop file. */
+    const char *hint = "desktop-entry";
+    ok = ok && dbus_message_iter_open_container(&it, DBUS_TYPE_ARRAY, "{sv}", &sub) &&
+        dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, NULL, &entry) &&
+        dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &hint) &&
+        dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "s", &value) &&
+        dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &app) &&
+        dbus_message_iter_close_container(&entry, &value) &&
+        dbus_message_iter_close_container(&sub, &entry) &&
+        dbus_message_iter_close_container(&it, &sub);
+    ok = ok && dbus_message_iter_append_basic(&it, DBUS_TYPE_INT32, &expire);
+
+    if (ok) {
+        dbus_message_set_no_reply(msg, TRUE);
+        ok = dbus_connection_send(c, msg, NULL);
+        if (ok) dbus_connection_flush(c);
+    }
+    dbus_message_unref(msg);
+    return ok;
+}
+
+/* Read an integer from it, unwrapping variants: Settings.Read nests one more. */
+static bool iter_int(DBusMessageIter *it, int64_t *out)
+{
+    DBusMessageIter inner[4];
+    int depth = 0;
+    while (dbus_message_iter_get_arg_type(it) == DBUS_TYPE_VARIANT && depth < 4) {
+        dbus_message_iter_recurse(it, &inner[depth]);
+        it = &inner[depth++];
+    }
+    DBusBasicValue v;
+    switch (dbus_message_iter_get_arg_type(it)) {
+    case DBUS_TYPE_BYTE: dbus_message_iter_get_basic(it, &v); *out = v.byt; return true;
+    case DBUS_TYPE_BOOLEAN: dbus_message_iter_get_basic(it, &v); *out = v.bool_val; return true;
+    case DBUS_TYPE_INT16: dbus_message_iter_get_basic(it, &v); *out = v.i16; return true;
+    case DBUS_TYPE_UINT16: dbus_message_iter_get_basic(it, &v); *out = v.u16; return true;
+    case DBUS_TYPE_INT32: dbus_message_iter_get_basic(it, &v); *out = v.i32; return true;
+    case DBUS_TYPE_UINT32: dbus_message_iter_get_basic(it, &v); *out = v.u32; return true;
+    case DBUS_TYPE_INT64: dbus_message_iter_get_basic(it, &v); *out = v.i64; return true;
+    case DBUS_TYPE_UINT64:
+        dbus_message_iter_get_basic(it, &v);
+        if (v.u64 > INT64_MAX) return false;
+        *out = (int64_t)v.u64;
+        return true;
+    default: return false;
+    }
+}
+
+bool portal_read_int(const char *ns, const char *key, int64_t *out)
+{
+    DBusConnection *c = session_bus();
+    if (!c) return false;
+    /* ReadOne is portal version 2; older portals only have Read. */
+    static const char *const methods[] = {"ReadOne", "Read"};
+    for (int i = 0; i < 2; i++) {
+        DBusMessage *msg = dbus_message_new_method_call("org.freedesktop.portal.Desktop",
+                "/org/freedesktop/portal/desktop", "org.freedesktop.portal.Settings", methods[i]);
+        if (!msg) return false;
+        if (!dbus_message_append_args(msg, DBUS_TYPE_STRING, &ns, DBUS_TYPE_STRING, &key,
+                                      DBUS_TYPE_INVALID)) {
+            dbus_message_unref(msg);
+            return false;
+        }
+        DBusError err;
+        dbus_error_init(&err);
+        DBusMessage *reply = dbus_connection_send_with_reply_and_block(c, msg,
+                PORTAL_TIMEOUT_MS, &err);
+        dbus_message_unref(msg);
+        if (!reply) {
+            bool retry = dbus_error_has_name(&err, DBUS_ERROR_UNKNOWN_METHOD);
+            dbus_error_free(&err);
+            if (retry) continue;
+            return false;
+        }
+        DBusMessageIter it;
+        bool ok = dbus_message_iter_init(reply, &it) && iter_int(&it, out);
+        dbus_message_unref(reply);
+        return ok;
+    }
+    return false;
+}
+
+#else
+
+bool bus_notify(const char *app, const char *title, const char *body)
+{
+    (void)app;
+    (void)title;
+    (void)body;
+    return false;
+}
+
+bool portal_read_int(const char *ns, const char *key, int64_t *out)
+{
+    (void)ns;
+    (void)key;
+    (void)out;
+    return false;
+}
+
+#endif
diff --git a/src/platform/freedesktop/dbus.h b/src/platform/freedesktop/dbus.h
new file mode 100644
index 0000000..3b1662b
--- /dev/null
+++ b/src/platform/freedesktop/dbus.h
@@ -0,0 +1,16 @@
+#ifndef YASL_FREEDESKTOP_DBUS_H
+#define YASL_FREEDESKTOP_DBUS_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+/* Session-bus helpers. The first call opens a private connection that later
+ * calls reuse. Each returns false when YASL is built without libdbus-1 or no
+ * session bus is reachable. Call from one thread at a time. */
+
+/* Send org.freedesktop.Notifications.Notify without waiting for a reply. */
+bool bus_notify(const char *app, const char *title, const char *body);
+/* Read an integer setting through the XDG Settings portal, waiting briefly. */
+bool portal_read_int(const char *ns, const char *key, int64_t *out);
+
+#endif
diff --git a/src/platform/freedesktop/desktop.c b/src/platform/freedesktop/desktop.c
new file mode 100644
index 0000000..a8b9bc7
--- /dev/null
+++ b/src/platform/freedesktop/desktop.c
@@ -0,0 +1,150 @@
+#define _GNU_SOURCE
+#include "common/desktop.h"
+#include "platform/freedesktop/dbus.h"
+#include "yasl/desktop.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+extern char **environ;
+
+static size_t copy_str(char *buf, size_t cap, const char *s)
+{
+    size_t len = strlen(s);
+    if (!len || len >= cap) return 0;
+    memcpy(buf, s, len + 1);
+    return len;
+}
+
+/* Find an executable in PATH, like execvp but before forking. */
+static bool find_program(const char *name, char *out, size_t cap)
+{
+    const char *path = getenv("PATH");
+    if (!path || !*path) path = "/usr/local/bin:/usr/bin:/bin";
+    size_t name_len = strlen(name);
+    while (*path) {
+        const char *end = strchr(path, ':');
+        size_t dir_len = end ? (size_t)(end - path) : strlen(path);
+        if (dir_len && dir_len + 1 + name_len < cap) {
+            memcpy(out, path, dir_len);
+            out[dir_len] = '/';
+            memcpy(out + dir_len + 1, name, name_len + 1);
+            if (access(out, X_OK) == 0) return true;
+        }
+        if (!end) break;
+        path = end + 1;
+    }
+    return false;
+}
+
+bool desktop_open_uri(const char *uri)
+{
+    char program[4096];
+    if (!find_program("xdg-open", program, sizeof(program))) return false;
+    char *argv[] = {"xdg-open", (char *)uri, NULL};
+
+    /* Prepare everything before fork: the children of a threaded process may
+     * only make async-signal-safe calls. */
+    struct sigaction dfl = {.sa_handler = SIG_DFL};
+    sigemptyset(&dfl.sa_mask);
+    sigset_t none;
+    sigemptyset(&none);
+    long max_fd = sysconf(_SC_OPEN_MAX);
+    if (max_fd < 0 || max_fd > 65536) max_fd = 65536;
+
+    /* The middle child exits at once, so the opener is reparented away from
+     * the application and never needs reaping here. */
+    pid_t pid = fork();
+    if (pid < 0) return false;
+    if (pid == 0) {
+        setsid();
+        pid_t opener = fork();
+        if (opener != 0) _exit(opener < 0 ? 1 : 0);
+        for (int sig = 1; sig < NSIG; sig++)
+            if (sig != SIGKILL && sig != SIGSTOP) sigaction(sig, &dfl, NULL);
+        sigprocmask(SIG_SETMASK, &none, NULL);
+        int null = open("/dev/null", O_RDONLY);
+        if (null > 0) {
+            dup2(null, STDIN_FILENO);
+            close(null);
+        }
+        /* Keep application descriptors, such as pty masters, out of the opener. */
+#ifdef SYS_close_range
+        if (syscall(SYS_close_range, 3u, ~0u, 0u) != 0)
+#endif
+            for (int fd = 3; fd < max_fd; fd++) close(fd);
+        execve(program, argv, environ);
+        _exit(127);
+    }
+
+    int status;
+    pid_t done;
+    do {
+        done = waitpid(pid, &status, 0);
+    } while (done < 0 && errno == EINTR);
+    /* An application reaper can collect the middle child first. */
+    if (done < 0) return errno == ECHILD;
+    return WIFEXITED(status) && WEXITSTATUS(status) == 0;
+}
+
+bool desktop_notify(const char *app_id, const char *title, const char *body)
+{
+    return bus_notify(app_id ? app_id : "yasl", title, body);
+}
+
+uint32_t desktop_appearance(void)
+{
+    uint32_t flags = 0;
+    bool portal = false;
+    int64_t value;
+    if (portal_read_int("org.freedesktop.appearance", "color-scheme", &value)) {
+        portal = true;
+        if (value == 1) flags |= YASL_APPEARANCE_DARK;
+        else if (value == 2) flags |= YASL_APPEARANCE_LIGHT;
+    }
+    if (portal_read_int("org.freedesktop.appearance", "contrast", &value)) {
+        portal = true;
+        if (value == 1) flags |= YASL_APPEARANCE_HIGH_CONTRAST;
+    }
+    if (portal) return flags;
+
+    /* GTK_THEME is "Name" or "Name:variant", as in "Adwaita:dark". */
+    const char *theme = getenv("GTK_THEME");
+    if (!theme) return 0;
+    if (strstr(theme, "HighContrast")) flags |= YASL_APPEARANCE_HIGH_CONTRAST;
+    if (strstr(theme, ":dark") || strstr(theme, "HighContrastInverse"))
+        flags |= YASL_APPEARANCE_DARK;
+    return flags;
+}
+
+size_t desktop_executable_path(char *buf, size_t cap)
+{
+    /* readlink truncates silently, so a full buffer may hold a cut path. */
+    ssize_t len = readlink("/proc/self/exe", buf, cap);
+    if (len <= 0 || (size_t)len >= cap) return 0;
+    buf[len] = '\0';
+    return (size_t)len;
+}
+
+size_t desktop_resource_dir(char *buf, size_t cap)
+{
+    (void)buf;
+    (void)cap;
+    return 0;
+}
+
+size_t desktop_default_locale(char *buf, size_t cap)
+{
+    static const char *const vars[] = {"LC_ALL", "LC_CTYPE", "LANG"};
+    for (size_t i = 0; i < sizeof(vars) / sizeof(vars[0]); i++) {
+        const char *v = getenv(vars[i]);
+        if (v && *v) return copy_str(buf, cap, v);
+    }
+    return copy_str(buf, cap, "C.UTF-8");
+}
diff --git a/src/platform/freedesktop/meson.build b/src/platform/freedesktop/meson.build
new file mode 100644
index 0000000..6f43895
--- /dev/null
+++ b/src/platform/freedesktop/meson.build
@@ -0,0 +1 @@
+sources += files('desktop.c', 'dbus.c')
diff --git a/src/platform/meson.build b/src/platform/meson.build
index 892969f..593353c 100644
--- a/src/platform/meson.build
+++ b/src/platform/meson.build
@@ -3,6 +3,10 @@
 if system == 'linux' or system == 'darwin'
     subdir('posix')
 endif
+# Desktop services shared by the Linux backends.
+if system == 'linux'
+    subdir('freedesktop')
+endif
 
 if has_wayland
     subdir('wayland')
diff --git a/src/platform/wayland/api.h b/src/platform/wayland/api.h
index e5e933e..6c3154c 100644
--- a/src/platform/wayland/api.h
+++ b/src/platform/wayland/api.h
@@ -38,5 +38,6 @@ bool wayland_surface_start_interactive_resize(struct wayland_surface *s, enum ya
 bool wayland_surface_show_window_menu(struct wayland_surface *s, struct yasl_vector2i pos);
 bool wayland_surface_drag_carry(struct wayland_surface *s, struct yasl_vector2i offset);
 bool wayland_surface_place_under_pointer(struct wayland_surface *s, struct yasl_vector2i at);
+bool wayland_surface_bell(struct wayland_surface *s);
 
 #endif
diff --git a/src/platform/wayland/backend.c b/src/platform/wayland/backend.c
index c3c7bed..c6272ce 100644
--- a/src/platform/wayland/backend.c
+++ b/src/platform/wayland/backend.c
@@ -177,6 +177,11 @@ static bool impl_surface_place_under_pointer(struct yasl_surface *s, struct yasl
     return wayland_surface_place_under_pointer((struct wayland_surface *)s, at);
 }
 
+static bool impl_surface_bell(struct yasl_surface *s)
+{
+    return wayland_surface_bell((struct wayland_surface *)s);
+}
+
 static void *impl_display_get_native_handle(struct yasl_display *d)
 {
     struct wayland_display *w = (struct wayland_display *)d;
@@ -225,6 +230,7 @@ const struct yasl_backend_ops yasl_wayland_backend = {
     .surface_show_window_menu = impl_surface_show_window_menu,
     .surface_drag_carry = impl_surface_drag_carry,
     .surface_place_under_pointer = impl_surface_place_under_pointer,
+    .surface_bell = impl_surface_bell,
     .display_get_native_handle = impl_display_get_native_handle,
     .surface_get_native_handle = impl_surface_get_native_handle,
 };
diff --git a/src/platform/wayland/internal.h b/src/platform/wayland/internal.h
index c35db7f..84a603d 100644
--- a/src/platform/wayland/internal.h
+++ b/src/platform/wayland/internal.h
@@ -25,6 +25,7 @@
 #include "protocols/primary-selection-unstable-v1-client-protocol.h"
 #include "protocols/relative-pointer-unstable-v1-client-protocol.h"
 #include "protocols/pointer-constraints-unstable-v1-client-protocol.h"
+#include "protocols/xdg-system-bell-v1-client-protocol.h"
 
 #include <fcntl.h>
 #include <limits.h>
@@ -217,6 +218,7 @@ struct wayland_display {
     struct wp_cursor_shape_manager_v1 *cursor_shape_mgr;
     struct zwp_relative_pointer_manager_v1 *relative_pointer_mgr;
     struct zwp_pointer_constraints_v1 *pointer_constraints;
+    struct xdg_system_bell_v1 *system_bell;
     struct wl_cursor_theme *cursor_theme;
     const char *cursor_theme_name;
     struct zwp_tablet_manager_v2 *tablet_mgr;
diff --git a/src/platform/wayland/shell.c b/src/platform/wayland/shell.c
index a12bd4d..8795989 100644
--- a/src/platform/wayland/shell.c
+++ b/src/platform/wayland/shell.c
@@ -214,6 +214,8 @@ static void registry_global(void *data, struct wl_registry *registry,
     } else if (strcmp(interface, zwp_pointer_constraints_v1_interface.name) == 0) {
         c->pointer_constraints = wl_registry_bind(registry, name,
                 &zwp_pointer_constraints_v1_interface, 1);
+    } else if (strcmp(interface, xdg_system_bell_v1_interface.name) == 0) {
+        c->system_bell = wl_registry_bind(registry, name, &xdg_system_bell_v1_interface, 1);
     } else if (strcmp(interface, wp_fractional_scale_manager_v1_interface.name) == 0) {
         c->scale_mgr = wl_registry_bind(registry, name,
                 &wp_fractional_scale_manager_v1_interface, 1);
@@ -403,3 +405,10 @@ int surface_init_shell(struct wayland_surface *w, const char *title)
     }
     return 0;
 }
+
+bool wayland_surface_bell(struct wayland_surface *w)
+{
+    if (!w || w->closed || !w->conn || !w->conn->system_bell || !w->surface) return false;
+    xdg_system_bell_v1_ring(w->conn->system_bell, w->surface);
+    return true;
+}
diff --git a/src/platform/wayland/surface.c b/src/platform/wayland/surface.c
index 0f6d7d7..cf1877d 100644
--- a/src/platform/wayland/surface.c
+++ b/src/platform/wayland/surface.c
@@ -202,6 +202,7 @@ static void display_free(struct wayland_display *c)
     if (c->cursor_shape_mgr) wp_cursor_shape_manager_v1_destroy(c->cursor_shape_mgr);
     if (c->relative_pointer_mgr) zwp_relative_pointer_manager_v1_destroy(c->relative_pointer_mgr);
     if (c->pointer_constraints) zwp_pointer_constraints_v1_destroy(c->pointer_constraints);
+    if (c->system_bell) xdg_system_bell_v1_destroy(c->system_bell);
     if (c->cursor_theme) wl_cursor_theme_destroy(c->cursor_theme);
     if (c->tablet_mgr) zwp_tablet_manager_v2_destroy(c->tablet_mgr);
     if (c->text_input_mgr) zwp_text_input_manager_v3_destroy(c->text_input_mgr);
@@ -246,6 +247,7 @@ struct wayland_display *wayland_display_open(struct yasl_loop *loop, const struc
         c->cbs = &c->base.callbacks;
         c->ud = spec->ud;
         if (spec->app_id) c->app_id = strdup(spec->app_id);
+        c->base.app_id = c->app_id;
     }
     c->xkb_ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
     c->wl = c->xkb_ctx ? wl_display_connect(NULL) : NULL;
diff --git a/src/platform/x11/window.c b/src/platform/x11/window.c
index f60a878..be1ff32 100644
--- a/src/platform/x11/window.c
+++ b/src/platform/x11/window.c
@@ -1601,6 +1601,7 @@ static struct yasl_display *display_open(struct yasl_loop *loop,
     }
     d->base.loop = d->loop;
     d->app_id = strdup(spec && spec->app_id ? spec->app_id : "YASL");
+    d->base.app_id = d->app_id;
     if (!d->loop || !d->app_id) {
         if (d->owns_loop) yasl_loop_destroy(d->loop);
         free(d->app_id);
@@ -1803,6 +1804,18 @@ static bool place(struct yasl_surface *base, struct yasl_vector2i at)
     return true;
 }
 
+static bool bell(struct yasl_surface *base)
+{
+    struct x11_surface *s = (struct x11_surface *)base;
+    struct x11_display *d = (struct x11_display *)base->display;
+    if (s->destroyed || !d->native) return false;
+    /* The XKB bell names the window, so the window manager can flash it. */
+    if (!XkbBell(d->native, s->window, 0, None))
+        XBell(d->native, 0);
+    XFlush(d->native);
+    return true;
+}
+
 static void drag_end(struct x11_display *d, enum yasl_drag_end how)
 {
     if (!d || !d->drag.active) return;
@@ -2045,6 +2058,7 @@ const struct yasl_backend_ops yasl_x11_backend = {
     .surface_set_cursor = cursor,
     .surface_drag_carry = drag_carry,
     .surface_place_under_pointer = place,
+    .surface_bell = bell,
     .surface_start_interactive_move = interactive_move,
     .surface_start_interactive_resize = interactive_resize,
     .surface_show_window_menu = show_window_menu,