From 1da03a79522a0f3423c9b32daa5493989ecd331b Mon Sep 17 00:00:00 2001
From: Hue <skeptikal.monke@gmail.com>
Date: Sun, 21 Dec 2025 02:13:29 +0100
Subject: [PATCH 1/4] =?UTF-8?q?panel=C2=A0:=20add=20backlight=20control=20?=
 =?UTF-8?q?widget?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add backlight widget to control display brightness.
Handles sysfs devices and external external monitors that implement MCCS.
MCCS depends on libddcutil, and is not built if it is not detected.
---
 .github/workflows/ci.yaml                 |   2 +-
 meson.build                               |   6 +
 meson_options.txt                         |   6 +
 metadata/panel.xml                        |  33 ++
 src/panel/meson.build                     |   9 +
 src/panel/panel.cpp                       |  13 +-
 src/panel/widgets/backlight/backlight.cpp | 269 ++++++++++++++
 src/panel/widgets/backlight/backlight.hpp | 165 +++++++++
 src/panel/widgets/backlight/ddcutil.cpp   | 225 ++++++++++++
 src/panel/widgets/backlight/sysfs.cpp     | 404 ++++++++++++++++++++++
 src/util/icon-select.hpp                  |   8 +
 11 files changed, 1138 insertions(+), 2 deletions(-)
 create mode 100644 src/panel/widgets/backlight/backlight.cpp
 create mode 100644 src/panel/widgets/backlight/backlight.hpp
 create mode 100644 src/panel/widgets/backlight/ddcutil.cpp
 create mode 100644 src/panel/widgets/backlight/sysfs.cpp

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 9d1f28a9..8efbedf8 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -9,7 +9,7 @@ jobs:
     steps:
       - run: echo 'http://dl-cdn.alpinelinux.org/alpine/v3.22/community' > /etc/apk/repositories
       - run: echo 'http://dl-cdn.alpinelinux.org/alpine/v3.22/main' >> /etc/apk/repositories
-      - run: apk --no-cache add git g++ binutils pkgconf meson ninja musl-dev gtkmm4-dev vala gobject-introspection gobject-introspection-dev pulseaudio-dev pipewire-dev wireplumber-dev libdbusmenu-glib-dev alsa-lib-dev yyjson-dev linux-pam-dev util-linux-login openssl-dev
+      - run: apk --no-cache add git g++ binutils pkgconf meson ninja musl-dev gtkmm4-dev vala gobject-introspection gobject-introspection-dev ddcutil pulseaudio-dev pipewire-dev wireplumber-dev libdbusmenu-glib-dev alsa-lib-dev yyjson-dev linux-pam-dev util-linux-login openssl-dev
       - run: echo 'http://dl-cdn.alpinelinux.org/alpine/edge/testing' >> /etc/apk/repositories
       - run: echo 'http://dl-cdn.alpinelinux.org/alpine/edge/main' >> /etc/apk/repositories
       - run: apk --no-cache add wayland-protocols wayfire-dev gtk4-layer-shell-dev gtk4-layer-shell
diff --git a/meson.build b/meson.build
index 36d56db6..9f5f4cf4 100644
--- a/meson.build
+++ b/meson.build
@@ -28,6 +28,8 @@ libpulse = dependency('libpulse', required: get_option('volume-widget'))
 libgvc = subproject('gvc', default_options: ['static=true'], required: get_option('volume-widget'))
 pipewire = dependency('libpipewire-0.3', required: get_option('wp-mixer-widget'))
 wireplumber = dependency('wireplumber-0.5', required: get_option('wp-mixer-widget'))
+ddcutil = dependency('libddcutil-5', required: get_option('ddcutil'))
+ddcutil = dependency('ddcutil', required: get_option('ddcutil'))
 dbusmenu_gtk = dependency('dbusmenu-glib-0.4')
 xkbregistry = dependency('xkbregistry')
 json = subproject('wf-json').get_variable('wfjson')
@@ -57,6 +59,10 @@ if wireplumber.found()
 	add_project_arguments('-DHAVE_WIREPLUMBER=1', language: 'cpp')
 endif
 
+if ddcutil.found()
+	add_project_arguments('-DHAVE_DDCUTIL=1', language: 'cpp')
+endif
+
 needs_libinotify = ['freebsd', 'dragonfly'].contains(host_machine.system())
 libinotify = dependency('libinotify', required: needs_libinotify)
 
diff --git a/meson_options.txt b/meson_options.txt
index 377f3cc3..73207a98 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -10,6 +10,12 @@ option(
     value: 'auto',
     description: 'Build wireplumber mixer widget',
 )
+option(
+    'ddcutil',
+    type: 'feature',
+    value: 'auto',
+    description: 'Build external monitor support for backlight widget'
+)
 option(
     'wayland-logout',
     type: 'boolean',
diff --git a/metadata/panel.xml b/metadata/panel.xml
index cb53132d..1fc1baa8 100644
--- a/metadata/panel.xml
+++ b/metadata/panel.xml
@@ -395,6 +395,39 @@
 	</option>
 	</group>
 	<group>
+	<group>
+	<_short>Backlight</_short>
+	<option name="light_popup_on_change" type="bool">
+		<_short>Popup on change</_short>
+		<default>true</default>
+	</option>
+	<option name="light_popup_timeout" type="double">
+		<_short>Popup timeout</_short>
+		<default>2.5</default>
+		<min>0</min>
+	</option>
+	<option name="light_slider_length" type="int">
+		<_short>Slider length</_short>
+		<default>300</default>
+		<min>1</min>
+	</option>
+	<option name="light_scroll_sensitivity" type="double">
+		<_short>Scroll sensitivity</_short>
+		<default>1</default>
+	</option>
+	<option name="light_invert_scroll" type="bool">
+		<_short>Invert scroll</_short>
+		<_long>
+			Inverts which scroll direction raises and lowers display brightness
+		</_long>
+		<default>false</default>
+	</option>
+	<option name="light_icon_size" type="int">
+		<_short>Light icon size</_short>
+		<default>0</default>
+		<min>0</min>
+	</option>
+	</group>
 	<_short>Notifications</_short>
 	<option name="notifications_autohide_timeout" type="double">
 		<_short>Notifications Display Timeout</_short>
diff --git a/src/panel/meson.build b/src/panel/meson.build
index 65c9793e..ed8b4ee5 100644
--- a/src/panel/meson.build
+++ b/src/panel/meson.build
@@ -21,6 +21,8 @@ widget_sources = [
   'widgets/tray/host.cpp',
   'widgets/tray/dbusmenu.cpp',
   'widgets/workspace-switcher.cpp',
+  'widgets/backlight/backlight.cpp',
+  'widgets/backlight/sysfs.cpp',
 ]
 
 deps = [
@@ -35,6 +37,13 @@ deps = [
   json,
 ]
 
+if ddcutil.found()
+  widget_sources += 'widgets/backlight/ddcutil.cpp'
+  deps += ddcutil
+else
+  message('Libddcutil not found, light widget will not support external monitors.')
+endif
+
 if libpulse.found()
   widget_sources += [
     'widgets/volume.cpp',
diff --git a/src/panel/panel.cpp b/src/panel/panel.cpp
index 04fd2fc6..0b81446b 100644
--- a/src/panel/panel.cpp
+++ b/src/panel/panel.cpp
@@ -33,6 +33,7 @@
 #ifdef HAVE_WIREPLUMBER
     #include "widgets/wp-mixer/wp-mixer.hpp"
 #endif
+#include "widgets/backlight/backlight.hpp"
 #include "widgets/window-list/window-list.hpp"
 #include "widgets/notifications/notification-center.hpp"
 #include "widgets/tray/tray.hpp"
@@ -188,6 +189,15 @@ class WayfirePanel::impl
 #endif
         }
 
+        if (name == "backlight")
+        {
+            return Widget(new WayfireBacklight(output));
+#ifndef HAVE_DDCUTIL
+            std::cout << "Built without DDC/CI support, backlight widget "
+                         " doesn’t support external monitors." << std::endl;
+#endif
+        }
+
         if (name == "window-list")
         {
             return Widget(new WayfireWindowList(output));
@@ -533,7 +543,8 @@ void WayfirePanelApp::on_activate()
         {"panel/wp_icon_size", ".wp-mixer"},
         {"panel/wp_popup_icon_size", ".mute-toggle, .default-button"},
         {"panel/notifications_icon_size", ".notification-center "},
-        {"panel/tray_icon_size", ".tray-button"}
+        {"panel/tray_icon_size", ".tray-button"},
+        {"panel/light_icon_size", ".light"}
     };
     for (auto pair : icon_sizes_args)
     {
diff --git a/src/panel/widgets/backlight/backlight.cpp b/src/panel/widgets/backlight/backlight.cpp
new file mode 100644
index 00000000..ae776a49
--- /dev/null
+++ b/src/panel/widgets/backlight/backlight.cpp
@@ -0,0 +1,269 @@
+#include <gdkmm/monitor.h>
+#include <memory>
+#include <pulse/proplist.h>
+#include <wayland-client-core.h>
+#include <wayland-client-protocol.h>
+
+#include "backlight.hpp"
+#include "wf-popover.hpp"
+#include "wf-shell-app.hpp"
+#include "icon-select.hpp"
+
+#define ICON(volume) icon_from_range(brightness_display_icons, volume)
+
+WfLightControl::WfLightControl(WayfireBacklight *_parent)
+{
+    parent = _parent;
+
+    scale.set_range(0.0, 1.0);
+    slider_length.set_callback([=] ()
+    {
+        scale.set_size_request(slider_length.value());
+    });
+    scale.set_size_request(slider_length.value());
+
+    scale.set_user_changed_callback([this] ()
+    {
+        this->set_brightness(scale.get_target_value());
+    });
+
+    set_orientation(Gtk::Orientation::VERTICAL);
+    append(label);
+    append(scale);
+
+    // scroll
+    auto scroll_gesture = Gtk::EventControllerScroll::create();
+    scroll_gesture->signal_scroll().connect([=] (double dx, double dy)
+    {
+        double change = 0;
+
+        if (scroll_gesture->get_unit() == Gdk::ScrollUnit::WHEEL)
+        {
+            // +- number of clicks.
+            change = (dy * parent->scroll_sensitivity) / 10;
+        } else
+        {
+            // Number of pixels expected to have scrolled. usually in 100s
+            change = (dy * parent->scroll_sensitivity) / 100;
+        }
+
+        if (!(parent->invert_scroll))
+        {
+            change *= -1;
+        }
+
+        // correct for a "good feeling" change at sensitivity 1
+        change *= 0.2;
+
+        double newv = get_scale_target_value() + change;
+        newv = std::clamp(newv, 0.0, 1.0);
+        set_brightness(newv);
+        set_scale_target_value(newv);
+        return true;
+    }, true);
+    scroll_gesture->set_flags(Gtk::EventControllerScroll::Flags::VERTICAL);
+    add_controller(scroll_gesture);
+}
+
+WayfireBacklight*WfLightControl::get_parent()
+{
+    return parent;
+}
+
+void WfLightControl::set_scale_target_value(double brightness)
+{
+    scale.set_target_value(brightness);
+    update_parent_icon();
+}
+
+double WfLightControl::get_scale_target_value()
+{
+    return scale.get_target_value();
+}
+
+void WfLightControl::update_parent_icon()
+{
+    if (parent->ctrl_this_display.get() == this)
+    {
+        parent->update_icon();
+        if (parent->popup_on_change && !parent->button->get_active())
+        {
+            parent->button->activate();
+            parent->check_set_popover_timeout();
+        }
+    }
+}
+
+void LightManager::add_widget(WayfireBacklight *widget)
+{
+    widgets.push_back(widget);
+    catch_up_widget(widget);
+}
+
+void LightManager::rem_widget(WayfireBacklight *widget)
+{
+    strip_widget(widget);
+    widgets.erase(find(widgets.begin(), widgets.end(), widget));
+}
+
+WayfireBacklight::WayfireBacklight(WayfireOutput *_output)
+{
+    output = _output;
+}
+
+WayfireBacklight::~WayfireBacklight()
+{
+    SysfsSurveillor::get().rem_widget(this);
+#ifdef HAVE_DDCUTIL
+    DdcaSurveillor::get().rem_widget(this);
+#endif
+}
+
+void WayfireBacklight::init(Gtk::Box *container)
+{
+    button = std::make_unique<WayfireMenuButton>("panel");
+    button->add_css_class("widget-icon");
+    button->add_css_class("backlight");
+    button->add_css_class("flat");
+    button->get_children()[0]->add_css_class("flat");
+    button->set_child(icon);
+    button->show();
+    popover = button->get_popover();
+    popover->set_autohide(false);
+
+    // layout
+    box.append(display_box);
+    box.set_orientation(Gtk::Orientation::VERTICAL);
+
+    disp_othr_sep.set_orientation(Gtk::Orientation::HORIZONTAL);
+    box.append(disp_othr_sep);
+    box.append(other_box);
+
+    display_label.set_text("This monitor");
+    display_box.append(display_label);
+    display_box.set_orientation(Gtk::Orientation::VERTICAL);
+    display_label.add_css_class("this-monitor");
+
+    other_label.set_text("Other monitors");
+    other_box.append(other_label);
+    other_box.set_orientation(Gtk::Orientation::VERTICAL);
+    display_label.add_css_class("other-monitors");
+
+    // scroll to brighten and dim the monitor the panel is on
+    auto scroll_gesture = Gtk::EventControllerScroll::create();
+    scroll_gesture->signal_scroll().connect([=] (double dx, double dy)
+    {
+        if (!ctrl_this_display)
+        {
+            return false;
+        }
+
+        double change = 0;
+
+        if (scroll_gesture->get_unit() == Gdk::ScrollUnit::WHEEL)
+        {
+            // +- number of clicks.
+            change = (dy * scroll_sensitivity) / 10;
+        } else
+        {
+            // Number of pixels expected to have scrolled. usually in 100s
+            change = (dy * scroll_sensitivity) / 100;
+        }
+
+        if (!invert_scroll)
+        {
+            change *= -1;
+        }
+
+        // correct for a "good feeling" change at sensitivity 1
+        change *= 0.2;
+
+        double newv = ctrl_this_display->get_scale_target_value() + change;
+        newv = std::clamp(newv, 0.0, 1.0);
+        ctrl_this_display->set_brightness(newv);
+        ctrl_this_display->set_scale_target_value(newv);
+        return true;
+    }, true);
+    scroll_gesture->set_flags(Gtk::EventControllerScroll::Flags::VERTICAL);
+    button->add_controller(scroll_gesture);
+
+    popover->set_child(box);
+    popover->get_style_context()->add_class("backlight-popover");
+
+    container->append(*button);
+
+    SysfsSurveillor::get().add_widget(this);
+#ifdef HAVE_DDCUTIL
+    DdcaSurveillor::get().add_widget(this);
+#endif
+
+    update_icon();
+}
+
+void WayfireBacklight::add_control(std::shared_ptr<WfLightControl> control)
+{
+    auto connector = output->monitor->get_connector();
+    if (control->get_connector() == connector)
+    {
+        if (!ctrl_this_display)
+        {
+            ctrl_this_display = std::shared_ptr(control);
+            display_box.append(*control);
+            update_icon();
+        }
+    } else
+    {
+        other_box.append(*control);
+    }
+
+    controls.push_back(control);
+}
+
+void WayfireBacklight::rem_control(WfLightControl *control)
+{
+    if (control == ctrl_this_display.get())
+    {
+        display_box.remove(*control);
+        ctrl_this_display = nullptr;
+        update_icon();
+    } else
+    {
+        other_box.remove(*control);
+    }
+
+    controls.erase(std::remove_if(controls.begin(), controls.end(),
+        [control] (const std::shared_ptr<WfLightControl>& c) { return c.get() == control; }),
+        controls.end());
+}
+
+void WayfireBacklight::update_icon()
+{
+    // if none, show unavailable
+    if (!ctrl_this_display)
+    {
+        icon.set_from_icon_name(ICON(-1));
+        return;
+    }
+
+    icon.set_from_icon_name(ICON(ctrl_this_display->get_scale_target_value()));
+}
+
+bool WayfireBacklight::on_popover_timeout(int timer)
+{
+    popover_timeout.disconnect();
+    popover->popdown();
+    return false;
+}
+
+void WayfireBacklight::check_set_popover_timeout()
+{
+    popover_timeout.disconnect();
+
+    popover_timeout = Glib::signal_timeout().connect(sigc::bind(sigc::mem_fun(*this,
+        &WayfireBacklight::on_popover_timeout), 0), popup_timeout * 1000);
+}
+
+void WayfireBacklight::cancel_popover_timeout()
+{
+    popover_timeout.disconnect();
+}
diff --git a/src/panel/widgets/backlight/backlight.hpp b/src/panel/widgets/backlight/backlight.hpp
new file mode 100644
index 00000000..04bb01ce
--- /dev/null
+++ b/src/panel/widgets/backlight/backlight.hpp
@@ -0,0 +1,165 @@
+#include <gtkmm.h>
+#include <memory>
+#include <sigc++/connection.h>
+#include <filesystem>
+#include <thread>
+
+#ifdef HAVE_DDCUTIL
+extern "C" {
+    #include <ddcutil_types.h>
+    #include <ddcutil_c_api.h>
+    #include <ddcutil_status_codes.h>
+}
+#endif
+
+#include "wf-shell-app.hpp"
+#include "widget.hpp"
+#include "animated-scale.hpp"
+
+class WayfireBacklight;
+
+class WfLightControl : public Gtk::Box
+{
+  protected:
+    WayfireAnimatedScale scale;
+    Gtk::Label label;
+    WayfireBacklight *parent;
+    std::vector<sigc::connection> signals;
+
+    void update_parent_icon();
+
+    WfOption<int> slider_length{"panel/light_slider_length"};
+
+  public:
+    WfLightControl(WayfireBacklight *parent);
+
+    virtual std::string get_connector() = 0;
+    virtual std::string get_name() = 0;
+    WayfireBacklight *get_parent();
+
+    void set_scale_target_value(double value);
+    double get_scale_target_value();
+    // a double from 0 to 1 for min to max
+    virtual void set_brightness(double brightness) = 0;
+    virtual double get_brightness() = 0;
+};
+
+class LightManager
+{
+  protected:
+    LightManager()
+    {}
+    // managed widgets
+    std::vector<WayfireBacklight*> widgets;
+
+    virtual void catch_up_widget(WayfireBacklight *widget) = 0;
+    virtual void strip_widget(WayfireBacklight *widget)    = 0;
+
+  public:
+    void add_widget(WayfireBacklight *widget);
+    void rem_widget(WayfireBacklight *widget);
+};
+
+// singleton that monitors sysfs and calls the necessary functions
+// monitors appearance and deletion of backlight devices
+// and the brightness of each of them
+class SysfsSurveillor : public LightManager
+{
+  private:
+    SysfsSurveillor();
+    void handle_inotify_events();
+    bool check_perms(std::filesystem::path);
+    void add_dev(std::filesystem::path);
+    void rem_dev(std::filesystem::path);
+    void catch_up_widget(WayfireBacklight *widget);
+    void strip_widget(WayfireBacklight *widget);
+
+    static inline std::unique_ptr<SysfsSurveillor> instance;
+
+    int fd; // inotify file descriptor
+
+    // stores the data that goes with the inotify watch descriptor (the int)
+    // the controls are all the controls which represent this device, to be updated
+    std::map<
+        int,
+        std::pair<
+            std::filesystem::path,
+            std::vector<std::shared_ptr<WfLightControl>>
+        >
+    > wd_to_path_controls;
+
+    // watch descriptors for files (so, a device) being added or removed
+    int wd_additions, wd_removal;
+
+    // managed widgets
+    std::vector<WayfireBacklight*> widgets;
+
+    // thread on which to run handle_inotify_event on loop
+    std::thread inotify_thread;
+
+  public:
+    ~SysfsSurveillor();
+
+    static SysfsSurveillor& get();
+};
+
+#ifdef HAVE_DDCUTIL
+class DdcaSurveillor : public LightManager
+{
+  private:
+    DdcaSurveillor();
+    void catch_up_widget(WayfireBacklight *widget);
+    void strip_widget(WayfireBacklight *widget);
+    static void on_display_change(DDCA_Display_Status_Event event);
+
+    static inline std::unique_ptr<DdcaSurveillor> instance;
+
+  public:
+    ~DdcaSurveillor();
+
+    std::map<DDCA_Display_Ref, std::vector<std::shared_ptr<WfLightControl>>> ref_to_controls;
+
+    static DdcaSurveillor& get();
+};
+#endif
+
+class WayfireBacklight : public WayfireWidget
+{
+  private:
+    void init(Gtk::Box *container) override;
+
+    WayfireOutput *output;
+
+    Gtk::Image icon;
+    Gtk::Popover *popover;
+    Gtk::Box box, display_box, other_box;
+    Gtk::Label display_label, other_label;
+    Gtk::Separator disp_othr_sep;
+    sigc::connection popover_timeout;
+
+    WfOption<double> popup_timeout{"panel/light_popup_timeout"};
+
+    bool on_popover_timeout(int timer);
+
+  public:
+    WayfireBacklight(WayfireOutput *output);
+    ~WayfireBacklight();
+
+    std::unique_ptr<WayfireMenuButton> button;
+
+    WfOption<double> scroll_sensitivity{"panel/light_scroll_sensitivity"};
+    WfOption<bool> invert_scroll{"panel/light_invert_scroll"};
+    WfOption<bool> popup_on_change{"panel/light_popup_on_change"};
+
+    std::shared_ptr<WfLightControl> ctrl_this_display;
+
+    std::vector<std::shared_ptr<WfLightControl>> controls;
+
+    void check_set_popover_timeout();
+    void cancel_popover_timeout();
+
+    void add_control(std::shared_ptr<WfLightControl> control);
+    void rem_control(WfLightControl *control);
+
+    void update_icon();
+};
diff --git a/src/panel/widgets/backlight/ddcutil.cpp b/src/panel/widgets/backlight/ddcutil.cpp
new file mode 100644
index 00000000..5ddbef66
--- /dev/null
+++ b/src/panel/widgets/backlight/ddcutil.cpp
@@ -0,0 +1,225 @@
+#include <ddcutil_types.h>
+#include <ddcutil_c_api.h>
+#include <ddcutil_status_codes.h>
+
+#include <iostream>
+#include <thread>
+
+#include "backlight.hpp"
+
+#define VCP_BRIGHTNESS_CODE 0x10
+
+void show_err(std::string location, DDCA_Status status)
+{
+    if (!status && (status != DDCRC_OK))
+    {
+        std::cerr << location << " :" << ddca_rc_name(status) << " : " << ddca_rc_desc(status) << "\n";
+    }
+}
+
+class WfLightDdcaControl : public WfLightControl
+{
+  private:
+    DDCA_Display_Ref ref;
+    DDCA_Display_Info2 *info;
+    std::string connector;
+    int max;
+    double brightness_wish;
+    bool wish_pending = false;
+
+    int get_max()
+    {
+        return max;
+    }
+
+  public:
+    WfLightDdcaControl(WayfireBacklight *parent, DDCA_Display_Ref _ref) : WfLightControl(parent)
+    {
+        ref = _ref;
+
+        DDCA_Status status;
+
+        // we want Info2 for the connector name
+        status = ddca_get_display_info2(ref, &info);
+
+        // drm_card_connector is something like cardX-<connector-name>
+        connector = std::string(info->drm_card_connector);
+        connector = connector.substr(connector.find("-") + 1, connector.size());
+
+        DDCA_Display_Handle handle;
+        ddca_open_display2(info->dref, false, &handle);
+        show_err("open display", status);
+
+        DDCA_Non_Table_Vcp_Value value;
+        status = ddca_get_non_table_vcp_value(handle, VCP_BRIGHTNESS_CODE, &value);
+        max    = value.mh << 8 | value.ml;
+        ddca_close_display(handle);
+        scale.set_target_value(get_brightness());
+        update_parent_icon();
+        label.set_text(get_name());
+    }
+
+    std::string get_connector()
+    {
+        return connector;
+    }
+
+    std::string get_name()
+    {
+        return std::string(info->model_name);
+    }
+
+    void set_brightness(double brightness)
+    {
+        brightness_wish = brightness;
+
+        // set the value in another thread to not block panel, as it can take a while
+        // even if we accidentally have another call go through, it’s no biggie
+        if (!wish_pending)
+        {
+            wish_pending = true;
+            std::thread(writevcp, this).detach();
+        }
+
+        parent->cancel_popover_timeout();
+        update_parent_icon();
+
+        // we don’t really have a good way to track changes to the monitor’s brightness, so here,
+        // we don’t update on external changes and just update the controls of the other widgets
+        // see watching for VCP changes : https://github.com/rockowitz/ddcutil/issues/589
+        for (auto control : DdcaSurveillor::get().ref_to_controls[ref])
+        {
+            control->set_scale_target_value(brightness);
+        }
+    }
+
+    static void writevcp(WfLightDdcaControl *control)
+    {
+        double target = control->brightness_wish;
+
+        DDCA_Display_Handle handle;
+        DDCA_Status status = ddca_open_display2(control->info->dref, false, &handle);
+        show_err("open display", status);
+
+        uint16_t value = (uint16_t)(control->get_max() * target);
+        uint8_t sh     = value >> 8;
+        uint8_t sl     = value & 0xFF;
+        status = ddca_set_non_table_vcp_value(handle, VCP_BRIGHTNESS_CODE, sh, sl);
+        show_err("set brigthness", status);
+        ddca_close_display(handle);
+
+        // value changed again, re-run
+        // for this to be infinite recursion, the user needs to constantly keep
+        // moving the slider before the write is done, should be safe enough
+        if (control->brightness_wish != target)
+        {
+            writevcp(control);
+        }
+
+        control->wish_pending = false;
+    }
+
+    double get_brightness()
+    {
+        DDCA_Display_Handle handle;
+        DDCA_Status status = ddca_open_display2(info->dref, false, &handle);
+        show_err("open display", status);
+
+        DDCA_Non_Table_Vcp_Value value;
+        status = ddca_get_non_table_vcp_value(handle, VCP_BRIGHTNESS_CODE, &value);
+        show_err("get brightness", status);
+        ddca_close_display(handle);
+        return (value.sh << 8 | value.sl) / 100.0;
+    }
+};
+
+DdcaSurveillor::DdcaSurveillor()
+{
+    DDCA_Status status;
+    status = ddca_init2(NULL, DDCA_SYSLOG_ERROR, DDCA_INIT_OPTIONS_NONE, NULL);
+    show_err("ddca init", status);
+
+    ddca_enable_dynamic_sleep(true);
+
+    // watch for new valid monitors
+    // when ddcutil implements DDCA_EVENT_CLASS_DPMS, we can handle it
+    status = ddca_register_display_status_callback(on_display_change);
+    show_err("register callback", status);
+    status = ddca_start_watch_displays(DDCA_EVENT_CLASS_DISPLAY_CONNECTION);
+    show_err("start watch displays", status);
+
+    ddca_enable_verify(false);
+    DDCA_Display_Info_List *display_list = NULL;
+    ddca_get_display_info_list2(false, &display_list);
+
+    for (int i = 0; i < display_list->ct; i++)
+    {
+        ref_to_controls[display_list->info[i].dref];
+    }
+}
+
+DdcaSurveillor::~DdcaSurveillor()
+{
+    ddca_stop_watch_displays(false);
+}
+
+void DdcaSurveillor::on_display_change(DDCA_Display_Status_Event event)
+{
+    if (event.event_type == DDCA_EVENT_DISPLAY_CONNECTED)
+    {
+        auto& controls = DdcaSurveillor::get().ref_to_controls[event.dref];
+        for (auto& widget : DdcaSurveillor::get().widgets)
+        {
+            auto control = std::make_shared<WfLightDdcaControl>(widget, event.dref);
+            controls.push_back(control);
+            widget->add_control(control);
+        }
+    } else if (event.event_type == DDCA_EVENT_DISPLAY_DISCONNECTED)
+    {
+        auto it = DdcaSurveillor::get().ref_to_controls.find(event.dref);
+        if (it == DdcaSurveillor::get().ref_to_controls.end())
+        {
+            return;
+        }
+
+        for (auto& control : it->second)
+        {
+            control->get_parent()->rem_control(control.get());
+        }
+
+        DdcaSurveillor::get().ref_to_controls.erase(it);
+    }
+}
+
+void DdcaSurveillor::catch_up_widget(WayfireBacklight *widget)
+{
+    for (auto& [ref, controls] : ref_to_controls)
+    {
+        auto control = std::make_shared<WfLightDdcaControl>(widget, ref);
+        controls.push_back(control);
+        widget->add_control(control);
+    }
+}
+
+void DdcaSurveillor::strip_widget(WayfireBacklight *widget)
+{
+    for (auto& [ref, controls] : ref_to_controls)
+    {
+        controls.erase(std::remove_if(controls.begin(), controls.end(),
+            [widget] (const std::shared_ptr<WfLightControl>& c)
+        {
+            return c->get_parent() == widget;
+        }),
+            controls.end());
+    }
+}
+
+DdcaSurveillor& DdcaSurveillor::get()
+{
+    if (!instance)
+    {
+        instance = std::unique_ptr<DdcaSurveillor>(new DdcaSurveillor());
+    }
+
+    return *instance;
+}
diff --git a/src/panel/widgets/backlight/sysfs.cpp b/src/panel/widgets/backlight/sysfs.cpp
new file mode 100644
index 00000000..2db42c2c
--- /dev/null
+++ b/src/panel/widgets/backlight/sysfs.cpp
@@ -0,0 +1,404 @@
+#include <giomm.h>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <pwd.h>
+#include <grp.h>
+extern "C" {
+#include <sys/inotify.h>
+}
+#include <errno.h>
+
+#include "backlight.hpp"
+
+class WfLightSysfsControl : public WfLightControl
+{
+    // if we exist, it means we can just read/write, as the files and permissions
+    // have already been checked and are being monitored with inotify
+
+  protected:
+    std::string path, connector_name;
+
+    int get_max()
+    {
+        std::ifstream max_file(path + "/max_brightness");
+        if (!max_file.is_open())
+        {
+            std::cerr << "Failed to get max brightness for device at " << path << '\n';
+            return 0;
+        }
+
+        int max;
+        max_file >> max;
+        max_file.close();
+        return max;
+    }
+
+  public:
+    WfLightSysfsControl(WayfireBacklight *parent, std::string _path) : WfLightControl(parent)
+    {
+        path = _path;
+
+        // this resolves to something of the sort :
+        ///sys/devices/pciXXXX:XX/XXXX:XX:XX.X/XXXX:XX:XX.X/drm/cardX-<connector-name>/<name>
+        // what we are intersted in here is the connector name
+        std::string realpath = std::filesystem::canonical(path);
+        // the offset is constant until cardX (60), after which we look for the -.
+        connector_name = realpath.substr(60, realpath.size());
+        connector_name = connector_name.substr(connector_name.find("-") + 1, connector_name.size());
+        // then, the connector is what remains until /
+        connector_name = connector_name.substr(0, connector_name.find("/"));
+
+        scale.set_target_value(get_brightness());
+        label.set_text(get_name());
+    }
+
+    std::string get_connector()
+    {
+        return connector_name;
+    }
+
+    std::string get_name()
+    {
+        return "Integrated display";
+    }
+
+    void set_brightness(double brightness)
+    {
+        std::ofstream b_file(path + "/brightness");
+        if (!b_file.is_open())
+        {
+            std::cerr << "Failed to open brightness for device at " << path << '\n';
+            return;
+        }
+
+        // something of the sort avoids formatting issues with locales
+        b_file << std::to_string((int)(brightness * (double)get_max()));
+        if (b_file.fail())
+        {
+            std::cerr << "Failed to write brightness for device at " << path << '\n';
+            return;
+        }
+
+        parent->cancel_popover_timeout();
+        update_parent_icon();
+    }
+
+    double get_brightness()
+    {
+        std::ifstream b_file(path + "/brightness");
+        if (!b_file.is_open())
+        {
+            std::cerr << "Failed to get brightness for device at " << path << '\n';
+            return 0;
+        }
+
+        int brightness, max;
+        b_file >> brightness;
+        b_file.close();
+        max = get_max();
+        return (((double)brightness + (double)max) / (double)max) - 1;
+    }
+};
+
+// some systems don’t have permissions to write there and use the
+// SetBrightness dbus method of systemd-logind
+class WfLightSysfsDbusSystemdControl : public WfLightSysfsControl
+{
+  private:
+    Glib::RefPtr<Gio::DBus::Connection> connection;
+    std::string session_path, name;
+
+  public:
+    WfLightSysfsDbusSystemdControl(WayfireBacklight *parent, std::string _path) : WfLightSysfsControl(parent,
+            _path)
+    {
+        connection = Gio::DBus::Connection::get_sync(Gio::DBus::BusType::SYSTEM);
+        auto result = connection->call_sync(
+            "/org/freedesktop/login1",
+            "org.freedesktop.login1.Manager",
+            "GetSessionByPID",
+            Glib::VariantContainerBase::create_tuple({
+            Glib::Variant<guint32>::create(static_cast<guint32>(getpid()))
+        }),
+            "org.freedesktop.login1");
+
+        Glib::Variant<Glib::DBusObjectPathString> dbus_path;
+        result.get_child(dbus_path, 0);
+        session_path = dbus_path.get();
+
+        ///sys/class/backlight is constant, so 21
+        name = path.substr(21, path.length());
+    }
+
+    void set_brightness(double brightness) override
+    {
+        auto params = Glib::VariantContainerBase::create_tuple({
+            Glib::Variant<Glib::ustring>::create("backlight"),
+            Glib::Variant<Glib::ustring>::create(name),
+            Glib::Variant<guint32>::create(brightness * (double)get_max())
+        });
+
+        connection->call_sync(
+            session_path, // object path
+            "org.freedesktop.login1.Session", // interface
+            "SetBrightness", // method
+            params,
+            "org.freedesktop.login1" // bus name
+        );
+
+        parent->cancel_popover_timeout();
+        update_parent_icon();
+    }
+};
+
+SysfsSurveillor::SysfsSurveillor()
+{
+    fd = inotify_init();
+    if (fd == -1)
+    {
+        std::cerr << "Light widget: initialisation of inotify on sysfs failed.\n";
+        return;
+    }
+
+    const auto path = "/sys/class/backlight";
+
+    wd_additions = inotify_add_watch(fd, path, IN_CREATE);
+    wd_additions = inotify_add_watch(fd, path, IN_DELETE);
+
+    // look for present integrated backlights
+    for (const auto& entry : std::filesystem::directory_iterator(path))
+    {
+        add_dev(entry);
+    }
+
+    inotify_thread = std::thread(&SysfsSurveillor::handle_inotify_events, this);
+}
+
+SysfsSurveillor::~SysfsSurveillor()
+{
+    // clean up inotify
+    close(fd);
+    fd = -1;
+
+    // remove controls from every widget
+    for (auto& widget : widgets)
+    {
+        strip_widget(widget);
+    }
+}
+
+void SysfsSurveillor::handle_inotify_events()
+{
+    // according to the inotify man page, aligning as such ensures
+    // proper function and avoids performance loss for "some systems"
+    char buf[2048] __attribute__((aligned(__alignof__(struct inotify_event))));
+    const struct inotify_event *event;
+    ssize_t size;
+
+    for (;;)
+    {
+        // read, which will block until the next inotify event
+        size = read(fd, buf, sizeof(buf));
+        if (size == -1)
+        {
+            if (errno != EAGAIN)
+            {
+                std::cerr << "Light widget: error reading inotify event.\n";
+            } else
+            {
+                break;
+            }
+        }
+
+        for (char *ptr = buf; ptr < buf + size; ptr += sizeof(struct inotify_event) + event->len)
+        {
+            event = (const struct inotify_event*)ptr;
+
+            // a registered brightness file was changed
+            if (event->mask & IN_CLOSE_WRITE)
+            {
+                // look for the watch descriptor
+                if (wd_to_path_controls.find(event->wd) != wd_to_path_controls.end())
+                {
+                    // update every control
+                    auto controls = wd_to_path_controls[event->wd].second;
+                    Glib::signal_idle().connect_once([controls] ()
+                    {
+                        for (auto control : controls)
+                        {
+                            control->set_scale_target_value(control->get_brightness());
+                        }
+                    });
+                }
+            }
+
+            // metadata changed, so maybe permissions
+            if (event->mask & IN_ATTRIB)
+            {
+                if (wd_to_path_controls.find(event->wd) != wd_to_path_controls.end())
+                {
+                    // get the path without which file, just the directory
+                    auto path = wd_to_path_controls[event->wd].first;
+
+                    // only recheck if the permissions to brightness or max_brightenss changed
+                    if ((event->name == (path.string() + "/brightness")) ||
+                        (event->name == (path.string() + "/max_brightness")))
+                    {
+                        // if we cannot do what’s needed on the device, remove it
+                        if (!check_perms(path))
+                        {
+                            rem_dev(path);
+                        }
+                    }
+                }
+            }
+
+            // a backlight device appeared
+            if (event->mask & IN_CREATE)
+            {
+                if ((wd_additions == event->wd) && event->len)
+                {
+                    std::string name = event->name;
+                    Glib::signal_idle().connect_once([this, name] ()
+                    {
+                        add_dev(std::filesystem::path("/sys/class/backlight") / name);
+                    });
+                }
+            }
+
+            // a backlight device was removed
+            if (event->mask & IN_DELETE)
+            {
+                if ((wd_removal == event->wd) && event->len)
+                {
+                    std::string name = event->name;
+                    Glib::signal_idle().connect_once([this, name] ()
+                    {
+                        rem_dev(std::filesystem::path("/sys/class/backlight") / name);
+                    });
+                }
+            }
+        }
+    }
+}
+
+bool SysfsSurveillor::check_perms(std::filesystem::path path)
+{
+    // those are the two files we are interested in,
+    // brightness for reading / setting the value (0 to max),
+    // and max_brightness for getting the maximum value for this device.
+    // we need to be able to read max_brightness and write to brightness.
+    const std::filesystem::path max_b_path = path.string() + "/max_brightness";
+    const std::filesystem::path b_path     = path.string() + "/brightness";
+
+    if (access(max_b_path.c_str(), R_OK))
+    {
+        std::cerr << "Cannot read max_brightness for " << path << ", ignoring.\n";
+        return false;
+    }
+
+    if (access(b_path.c_str(), R_OK))
+    {
+        std::cerr << "Cannot read/write brightness for " << path << ", ignoring.\n";
+        return false;
+    }
+
+    return true;
+}
+
+void SysfsSurveillor::add_dev(std::filesystem::path path)
+{
+    if (!check_perms(path))
+    {
+        return;
+    }
+
+    // create a watch descriptor on the brightness file
+    int wd = inotify_add_watch(fd, path.string().c_str(), IN_CLOSE_WRITE | IN_ATTRIB);
+    if (wd == -1)
+    {
+        std::cerr << "Light widget: failed to register inotify watch descriptor.\n";
+        return;
+    }
+
+    wd_to_path_controls.insert({wd, {path, {}}});
+
+    // create a control for each widget, and insert it in the vector we just created
+    for (auto widget : widgets)
+    {
+        std::shared_ptr<WfLightSysfsControl> control;
+        if (access((std::string(path) + "/brightness").c_str(), W_OK))
+        {
+            control = std::make_shared<WfLightSysfsDbusSystemdControl>(widget, path);
+        } else
+        {
+            control = std::make_shared<WfLightSysfsControl>(widget, path);
+        }
+
+        wd_to_path_controls[wd].second.push_back(control);
+        widget->add_control(control);
+    }
+}
+
+void SysfsSurveillor::rem_dev(std::filesystem::path path)
+{
+    // device was removed, we can remove the entire entry (wd path, controls)
+    for (auto it : wd_to_path_controls)
+    {
+        if (it.second.first == path)
+        {
+            auto& controls = it.second.second;
+            for (auto control : controls)
+            {
+                control->get_parent()->rem_control(control.get());
+            }
+
+            wd_to_path_controls.erase(it.first);
+        }
+    }
+}
+
+void SysfsSurveillor::catch_up_widget(WayfireBacklight *widget)
+{
+    // for each managed device, create a control and add it to the widget and keep track of it
+    for (auto& it : wd_to_path_controls)
+    {
+        auto path = it.second.first;
+        std::shared_ptr<WfLightSysfsControl> control;
+        if (access((std::string(path) + "/brightness").c_str(), W_OK))
+        {
+            control = std::make_shared<WfLightSysfsDbusSystemdControl>(widget, path);
+        } else
+        {
+            control = std::make_shared<WfLightSysfsControl>(widget, path);
+        }
+
+        it.second.second.push_back(control);
+        widget->add_control(control);
+    }
+}
+
+void SysfsSurveillor::strip_widget(WayfireBacklight *widget)
+{
+    for (auto& [wd, path_controls] : wd_to_path_controls)
+    {
+        auto& controls = path_controls.second;
+        controls.erase(std::remove_if(controls.begin(), controls.end(),
+            [widget] (const std::shared_ptr<WfLightControl>& c)
+        {
+            return c->get_parent() == widget;
+        }),
+            controls.end());
+    }
+}
+
+SysfsSurveillor& SysfsSurveillor::get()
+{
+    if (!instance)
+    {
+        instance = std::unique_ptr<SysfsSurveillor>(new SysfsSurveillor());
+    }
+
+    return *instance;
+}
diff --git a/src/util/icon-select.hpp b/src/util/icon-select.hpp
index 6473f8ce..e256cf67 100644
--- a/src/util/icon-select.hpp
+++ b/src/util/icon-select.hpp
@@ -19,3 +19,11 @@ const std::map<double, std::vector<std::string>> volume_icons = {
     {1.0, {"audio-volume-high"}},
     {std::numeric_limits<double>::max(), {"audio-volume-high-danger", "dialog-warning"}}
 };
+
+const std::map<double, std::vector<std::string>> brightness_display_icons = {
+    {std::numeric_limits<double>::min(), {"display-brightness-invalid", "emblem-unreadable"}},
+    {0.33, {"display-brightness-low"}},
+    {0.66, {"display-brightness-medium"}},
+    {1.0, {"display-brightness-high"}},
+    {std::numeric_limits<double>::max(), {"display-brightness-invalid", "emblem-unreadable"}},
+};

From f6ecf24d816311016ac29b68ed767a4e5336a9f3 Mon Sep 17 00:00:00 2001
From: Hue <skeptikal.monke@gmail.com>
Date: Thu, 26 Mar 2026 12:01:32 +0100
Subject: [PATCH 2/4] update brightness icons to use symbolics

---
 src/util/icon-select.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/util/icon-select.hpp b/src/util/icon-select.hpp
index e256cf67..107c40d2 100644
--- a/src/util/icon-select.hpp
+++ b/src/util/icon-select.hpp
@@ -22,8 +22,8 @@ const std::map<double, std::vector<std::string>> volume_icons = {
 
 const std::map<double, std::vector<std::string>> brightness_display_icons = {
     {std::numeric_limits<double>::min(), {"display-brightness-invalid", "emblem-unreadable"}},
-    {0.33, {"display-brightness-low"}},
-    {0.66, {"display-brightness-medium"}},
-    {1.0, {"display-brightness-high"}},
+    {0, {"display-brightness-low-symbolic", "display-brightness-low"}},
+    {0.5, {"display-brightness-medium-symbolic", "display-medium-low"}},
+    {1, {"display-brightness-high-symbolic", "display-brightness-high"}},
     {std::numeric_limits<double>::max(), {"display-brightness-invalid", "emblem-unreadable"}},
 };

From ab891313f1376f93d4d20057ee37e7d278506155 Mon Sep 17 00:00:00 2001
From: Hue <skeptikal.monke@gmail.com>
Date: Tue, 31 Mar 2026 13:08:22 +0200
Subject: [PATCH 3/4] hide this/other monitors boxes when empty

---
 src/panel/widgets/backlight/backlight.cpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/panel/widgets/backlight/backlight.cpp b/src/panel/widgets/backlight/backlight.cpp
index ae776a49..b85289ab 100644
--- a/src/panel/widgets/backlight/backlight.cpp
+++ b/src/panel/widgets/backlight/backlight.cpp
@@ -132,12 +132,10 @@ void WayfireBacklight::init(Gtk::Box *container)
     popover->set_autohide(false);
 
     // layout
-    box.append(display_box);
     box.set_orientation(Gtk::Orientation::VERTICAL);
 
     disp_othr_sep.set_orientation(Gtk::Orientation::HORIZONTAL);
     box.append(disp_othr_sep);
-    box.append(other_box);
 
     display_label.set_text("This monitor");
     display_box.append(display_label);
@@ -207,12 +205,18 @@ void WayfireBacklight::add_control(std::shared_ptr<WfLightControl> control)
     {
         if (!ctrl_this_display)
         {
+            box.prepend(display_box);
             ctrl_this_display = std::shared_ptr(control);
             display_box.append(*control);
             update_icon();
         }
     } else
     {
+        if (!(other_box.get_children().size() > 1))
+        {
+            box.append(other_box);
+        }
+
         other_box.append(*control);
     }
 
@@ -224,11 +228,17 @@ void WayfireBacklight::rem_control(WfLightControl *control)
     if (control == ctrl_this_display.get())
     {
         display_box.remove(*control);
+        box.remove(display_box);
         ctrl_this_display = nullptr;
         update_icon();
     } else
     {
         other_box.remove(*control);
+
+        if (!(other_box.get_children().size() > 1))
+        {
+            box.remove(other_box);
+        }
     }
 
     controls.erase(std::remove_if(controls.begin(), controls.end(),

From 0e283098f6d9aa286c3b5dd657246adf1b94be66 Mon Sep 17 00:00:00 2001
From: Hue <skeptikal.monke@gmail.com>
Date: Tue, 31 Mar 2026 13:20:27 +0200
Subject: [PATCH 4/4] add spacing

---
 metadata/panel.xml                        | 5 +++++
 src/panel/widgets/backlight/backlight.cpp | 9 +++++++++
 src/panel/widgets/backlight/backlight.hpp | 1 +
 3 files changed, 15 insertions(+)

diff --git a/metadata/panel.xml b/metadata/panel.xml
index 1fc1baa8..f9d55e0b 100644
--- a/metadata/panel.xml
+++ b/metadata/panel.xml
@@ -422,6 +422,11 @@
 		</_long>
 		<default>false</default>
 	</option>
+	<option name="light_spacing" type="int">
+		<_short>Spacing between controls</_short>
+		<default>8</default>
+		<min>0</min>
+	</option>
 	<option name="light_icon_size" type="int">
 		<_short>Light icon size</_short>
 		<default>0</default>
diff --git a/src/panel/widgets/backlight/backlight.cpp b/src/panel/widgets/backlight/backlight.cpp
index b85289ab..968c7c88 100644
--- a/src/panel/widgets/backlight/backlight.cpp
+++ b/src/panel/widgets/backlight/backlight.cpp
@@ -134,6 +134,15 @@ void WayfireBacklight::init(Gtk::Box *container)
     // layout
     box.set_orientation(Gtk::Orientation::VERTICAL);
 
+    auto set_spacing = [=]()
+    {
+        box.set_spacing(spacing);
+        display_box.set_spacing(spacing);
+        other_box.set_spacing(spacing);
+    };
+    set_spacing();
+    spacing.set_callback(set_spacing);
+
     disp_othr_sep.set_orientation(Gtk::Orientation::HORIZONTAL);
     box.append(disp_othr_sep);
 
diff --git a/src/panel/widgets/backlight/backlight.hpp b/src/panel/widgets/backlight/backlight.hpp
index 04bb01ce..42e54b85 100644
--- a/src/panel/widgets/backlight/backlight.hpp
+++ b/src/panel/widgets/backlight/backlight.hpp
@@ -138,6 +138,7 @@ class WayfireBacklight : public WayfireWidget
     sigc::connection popover_timeout;
 
     WfOption<double> popup_timeout{"panel/light_popup_timeout"};
+    WfOption<int> spacing{"panel/light_spacing"};
 
     bool on_popover_timeout(int timer);