diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 9d1f28a99..8efbedf8b 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 69aaf8f26..93f5bc56d 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')
@@ -51,6 +53,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 745694fa0..1b028271b 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 9da3261b9..133adad9b 100644
--- a/metadata/panel.xml
+++ b/metadata/panel.xml
@@ -371,6 +371,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 495b3a362..6e0a3792c 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 = [
@@ -38,7 +40,6 @@ deps = [
 if libpulse.found()
   widget_sources += [
     'widgets/volume.cpp',
-    'widgets/volume-level.cpp',
   ]
   deps += [libpulse, libgvc]
 else
@@ -50,7 +51,6 @@ if wireplumber.found()
     'widgets/wp-mixer/wp-mixer.cpp',
     'widgets/wp-mixer/wf-wp-control.cpp',
     'widgets/wp-mixer/wp-common.cpp',
-    'widgets/volume-level.cpp',
   ]
   deps += [pipewire, wireplumber]
 else
@@ -65,6 +65,13 @@ else
   message('Weather disabled, weather widgets and owf service not included.')
 endif
 
+if ddcutil.found()
+  widget_sources += 'widgets/backlight/ddcutil.cpp'
+  deps += ddcutil
+else
+  message('Libddcutil not found, light widget will not support external monitors.')
+endif
+
 executable(
   'wf-panel',
   ['panel.cpp'] + widget_sources,
diff --git a/src/panel/panel.cpp b/src/panel/panel.cpp
index bf6948bc6..da6a6509e 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));
@@ -539,7 +549,8 @@ void WayfirePanelApp::on_activate()
         {"panel/volume_icon_size", ".volume"},
         {"panel/wp_icon_size", ".wireplumber"},
         {"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 000000000..bc3cf76a3
--- /dev/null
+++ b/src/panel/widgets/backlight/backlight.cpp
@@ -0,0 +1,263 @@
+#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 "icons.hpp"
+
+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;
+        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;
+
+        ctrl_this_display->set_brightness(ctrl_this_display->get_scale_target_value() + change);
+        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_for(brightness_display_icons, -1));
+        return;
+    }
+
+    icon.set_from_icon_name(icon_for(brightness_display_icons, 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 000000000..04bb01ce1
--- /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 000000000..5ddbef66e
--- /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 000000000..3860bd2b6
--- /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(path.c_str(), W_OK))
+        {
+            control = std::make_shared<WfLightSysfsControl>(widget, path);
+        } else
+        {
+            control = std::make_shared<WfLightSysfsDbusSystemdControl>(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(path.c_str(), W_OK))
+        {
+            control = std::make_shared<WfLightSysfsControl>(widget, path);
+        } else
+        {
+            control = std::make_shared<WfLightSysfsDbusSystemdControl>(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/panel/widgets/volume-level.cpp b/src/panel/widgets/volume-level.cpp
deleted file mode 100644
index 64f92be30..000000000
--- a/src/panel/widgets/volume-level.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <map>
-
-#include "volume-level.hpp"
-
-enum VolumeLevel
-{
-    VOLUME_LEVEL_MUTE = 0,
-    VOLUME_LEVEL_LOW,
-    VOLUME_LEVEL_MED,
-    VOLUME_LEVEL_HIGH,
-    VOLUME_LEVEL_OOR, /* Out of range */
-};
-
-const std::map<VolumeLevel, std::string> volume_icons = {
-    {VOLUME_LEVEL_MUTE, "audio-volume-muted"},
-    {VOLUME_LEVEL_LOW, "audio-volume-low"},
-    {VOLUME_LEVEL_MED, "audio-volume-medium"},
-    {VOLUME_LEVEL_HIGH, "audio-volume-high"},
-    {VOLUME_LEVEL_OOR, "emblem-unreadable"},
-};
-
-// volume is expected to be from 0 to 1
-std::string volume_icon_for(double volume)
-{
-    double max = 1.0;
-    auto third = max / 3;
-    if (volume == 0)
-    {
-        return volume_icons.at(VOLUME_LEVEL_MUTE);
-    } else if ((volume > 0) && (volume <= third))
-    {
-        return volume_icons.at(VOLUME_LEVEL_LOW);
-    } else if ((volume > third) && (volume <= (third * 2)))
-    {
-        return volume_icons.at(VOLUME_LEVEL_MED);
-    } else if ((volume > (third * 2)) && (volume <= max))
-    {
-        return volume_icons.at(VOLUME_LEVEL_HIGH);
-    }
-
-    return volume_icons.at(VOLUME_LEVEL_OOR);
-}
diff --git a/src/panel/widgets/volume-level.hpp b/src/panel/widgets/volume-level.hpp
deleted file mode 100644
index 6647133c6..000000000
--- a/src/panel/widgets/volume-level.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-
-#include <string>
-
-// helper in common for volume and wireplumber widgets icons handling
-std::string volume_icon_for(double volume);
diff --git a/src/panel/widgets/volume.cpp b/src/panel/widgets/volume.cpp
index 601968bf4..1ab915733 100644
--- a/src/panel/widgets/volume.cpp
+++ b/src/panel/widgets/volume.cpp
@@ -2,17 +2,17 @@
 #include <glibmm.h>
 #include "volume.hpp"
 
-#include "volume-level.hpp"
+#include "icons.hpp"
 
 void WayfireVolume::update_icon()
 {
     if (gvc_stream && gvc_mixer_stream_get_is_muted(gvc_stream))
     {
-        main_image.set_from_icon_name(volume_icon_for(0)); // mute
+        main_image.set_from_icon_name(icon_for(volume_icons, 0.0)); // mute
         return;
     }
 
-    main_image.set_from_icon_name(volume_icon_for(volume_scale.get_target_value() / (double)max_norm));
+    main_image.set_from_icon_name(icon_for(volume_icons, volume_scale.get_target_value() / (double)max_norm));
 }
 
 bool WayfireVolume::on_popover_timeout(int timer)
diff --git a/src/panel/widgets/wp-mixer/wf-wp-control.cpp b/src/panel/widgets/wp-mixer/wf-wp-control.cpp
index b2450c964..d9f031b55 100644
--- a/src/panel/widgets/wp-mixer/wf-wp-control.cpp
+++ b/src/panel/widgets/wp-mixer/wf-wp-control.cpp
@@ -2,7 +2,7 @@
 #include <gtkmm.h>
 
 #include "wf-wp-control.hpp"
-#include "../volume-level.hpp"
+#include "icons.hpp"
 
 WfWpControl::WfWpControl(WpPipewireObject *obj, WayfireWpMixer *parent_widget)
 {
@@ -143,12 +143,12 @@ void WfWpControl::update_icon()
     if (button.get_active())
     {
         add_css_class("muted");
-        volume_icon.set_from_icon_name(volume_icon_for(0)); // mute
+        volume_icon.set_from_icon_name(icon_for(volume_icons, 0)); // mute
         return;
     }
 
     remove_css_class("muted");
-    volume_icon.set_from_icon_name(volume_icon_for(get_scale_target_value()));
+    volume_icon.set_from_icon_name(icon_for(volume_icons, get_scale_target_value()));
 }
 
 double WfWpControl::get_scale_target_value()
diff --git a/src/panel/widgets/wp-mixer/wp-mixer.cpp b/src/panel/widgets/wp-mixer/wp-mixer.cpp
index 0e051c689..cf07d0d46 100644
--- a/src/panel/widgets/wp-mixer/wp-mixer.cpp
+++ b/src/panel/widgets/wp-mixer/wp-mixer.cpp
@@ -3,8 +3,8 @@
 #include <wp/proxy.h>
 
 #include "wp-mixer.hpp"
+#include "icons.hpp"
 #include "wf-wp-control.hpp"
-#include "../volume-level.hpp"
 
 bool WayfireWpMixer::on_popover_timeout(int timer)
 {
@@ -331,17 +331,17 @@ void WayfireWpMixer::update_icon()
     // depends on quick_target widget
     if (!quick_target)
     {
-        main_image.set_from_icon_name(volume_icon_for(-1)); // OOR
+        main_image.set_from_icon_name(icon_for(volume_icons, -1)); // OOR
         return;
     }
 
     if (quick_target->button.get_active())
     {
-        main_image.set_from_icon_name(volume_icon_for(0)); // mute
+        main_image.set_from_icon_name(icon_for(volume_icons, 0)); // mute
         return;
     }
 
-    main_image.set_from_icon_name(volume_icon_for(quick_target->get_scale_target_value()));
+    main_image.set_from_icon_name(icon_for(volume_icons, quick_target->get_scale_target_value()));
 }
 
 void WayfireWpMixer::set_quick_target_from(WfWpControl *from)
diff --git a/src/util/icons.cpp b/src/util/icons.cpp
new file mode 100644
index 000000000..3c16b4b02
--- /dev/null
+++ b/src/util/icons.cpp
@@ -0,0 +1,19 @@
+#include "icons.hpp"
+
+std::string icon_for(std::map<double, std::string> icons, double value)
+{
+    if ((value > ICONS_VMAX) || (value < ICONS_VMIN))
+    {
+        return icons.begin()->second;
+    }
+
+    for (auto pair : icons)
+    {
+        if (value <= pair.first)
+        {
+            return pair.second;
+        }
+    }
+
+    return "";
+}
diff --git a/src/util/icons.hpp b/src/util/icons.hpp
new file mode 100644
index 000000000..9785a1519
--- /dev/null
+++ b/src/util/icons.hpp
@@ -0,0 +1,29 @@
+#include <map>
+#include <string>
+
+#define ICONS_VMIN 0.0
+#define ICONS_VMAX 1.0
+
+std::string icon_for(std::map<double, std::string> icons, double value);
+
+/*
+ *  format for the icon tables :
+ *   the number in the first term is the maximal value at which this icon will be shown icons are expected to
+ * be ordered by the value at which they are desired a value not between MIN and MAX will result in the first
+ * value being returned
+ */
+
+const std::map<double, std::string> volume_icons = {
+    {-1, "emblem-unreadable"},
+    {0, "audio-volume-muted"},
+    {ICONS_VMAX / 3, "audio-volume-low"},
+    {(ICONS_VMAX / 3) * 2, "audio-volume-medium"},
+    {ICONS_VMAX, "audio-volume-high"},
+};
+
+const std::map<double, std::string> brightness_display_icons = {
+    {-1, "emblem-unreadable"},
+    {ICONS_VMAX / 3, "display-brightness-low"},
+    {(ICONS_VMAX / 3) * 2, "display-brightness-medium"},
+    {ICONS_VMAX, "display-brightness-high"},
+};
diff --git a/src/util/meson.build b/src/util/meson.build
index f50eb58f7..a3991072d 100644
--- a/src/util/meson.build
+++ b/src/util/meson.build
@@ -1,7 +1,9 @@
 util = static_library(
     'util',
     [
+        'animated-scale.cpp',
         'gtk-utils.cpp',
+        'icons.cpp',
         'wf-shell-app.cpp',
         'wf-autohide-window.cpp',
         'wf-popover.cpp',