diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index a1b316df..878be36d 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 libdbusmenu-glib-dev alsa-lib-dev yyjson-dev
+      - run: apk --no-cache add git g++ binutils pkgconf meson ninja musl-dev gtkmm4-dev vala gobject-introspection gobject-introspection-dev pulseaudio-dev wireplumber-dev libdbusmenu-glib-dev alsa-lib-dev yyjson-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 f50bcee9..50d6dc66 100644
--- a/meson.build
+++ b/meson.build
@@ -21,6 +21,7 @@ wfconfig = dependency('wf-config', version: '>=0.7.0') #TODO fallback submodule
 epoxy = dependency('epoxy')
 gtklayershell = dependency('gtk4-layer-shell-0', fallback: ['gtk4-layer-shell'])
 libpulse = dependency('libpulse', required: get_option('pulse'))
+wireplumber = dependency('wireplumber-0.5', required: get_option('wireplumber'))
 dbusmenu_gtk = dependency('dbusmenu-glib-0.4')
 libgvc = subproject('gvc', default_options: ['static=true'], required: get_option('pulse'))
 xkbregistry = dependency('xkbregistry')
@@ -35,6 +36,10 @@ if libpulse.found()
 	add_project_arguments('-DHAVE_PULSE=1', language: 'cpp')
 endif
 
+if wireplumber.found()
+	add_project_arguments('-DHAVE_WIREPLUMBER=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 aca93f47..8ecd76c0 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -4,9 +4,15 @@ option(
     value: 'auto',
     description: 'Build pulseaudio volume widget',
 )
+option(
+    'wireplumber',
+    type: 'feature',
+    value: 'auto',
+    description: 'Build wireplumber and mixer widget',
+)
 option(
     'wayland-logout',
     type: 'boolean',
     value: true,
     description: 'Install wayland-logout',
-)
\ No newline at end of file
+)
diff --git a/metadata/panel.xml b/metadata/panel.xml
index bfe391f0..23388b68 100644
--- a/metadata/panel.xml
+++ b/metadata/panel.xml
@@ -249,6 +249,105 @@
 	</option>
 	</group>
 	<group>
+	<_short>Audio mixer (wireplumber)</_short>
+	<option name="wp_quick_target_choice" type="string">
+		<_short>Quick action target</_short>
+		<_long>Which audio control will be the target of the quick actions (scrolling and muting on the widget)</_long>
+		<default>default_sink</default>
+		<desc>
+			<value>default_sink</value>
+			<_name>Default sink</_name>
+		</desc>
+		<desc>
+			<value>default_source</value>
+			<_name>Default source</_name>
+		</desc>
+		<desc>
+			<value>last_change</value>
+			<_name>Last changed volume</_name>
+		</desc>
+	</option>
+	<option name="wp_popup_on_change" type="bool">
+		<_short>Pop up on change</_short>
+		<_long>Whether to show a popup with the new values upon a change to the quick action target</_long>
+		<default>true</default>
+	</option>
+	<option name="wp_display_timeout" type="double">
+		<_short>Display timeout</_short>
+		<default>2.5</default>
+		<min>0</min>
+	</option>
+	<option name="wp_slider_length" type="int">
+		<_short>Slider length</_short>
+		<default>300</default>
+		<min>1</min>
+	</option>
+	<option name="wp_scroll_sensitivity" type="double">
+		<_short>Scroll sensitivity</_short>
+		<default>1</default>
+		<min>0</min>
+	</option>
+	<option name="wp_invert_scroll" type="bool">
+		<_short>Invert scroll</_short>
+		<_long>Inverts which scroll direction raises and lowers volume</_long>
+		<default>false</default>
+	</option>
+	<option name="wp_icons_on_left" type="bool">
+		<_short>Icons on left</_short>
+		<_long>Displays the mute and set default icon on the left</_long>
+		<default>false</default>
+	</option>
+	<option name="wp_left_click_action" type="string">
+		<_short>Left click action</_short>
+		<default>show_mixer</default>
+		<desc>
+			<value>show_mixer</value>
+			<_name>Show full mixer</_name>
+		</desc>
+		<desc>
+			<value>show_quick_target</value>
+			<_name>Show quick action target</_name>
+		</desc>
+	</option>
+	<option name="wp_middle_click_action" type="string">
+		<_short>Middle click action</_short>
+		<default>mute_quick_target</default>
+		<desc>
+			<value>show_mixer</value>
+			<_name>Show full mixer</_name>
+		</desc>
+		<desc>
+			<value>show_quick_target</value>
+			<_name>Show quick action target</_name>
+		</desc>
+		<desc>
+			<value>mute_quick_target</value>
+			<_name>Mute quick action target</_name>
+		</desc>
+	</option>
+	<option name="wp_right_click_action" type="string">
+		<_short>Right click action</_short>
+		<default>show_quick_target</default>
+		<desc>
+			<value>show_mixer</value>
+			<_name>Show full mixer</_name>
+		</desc>
+		<desc>
+			<value>show_quick_target</value>
+			<_name>Show quick action target</_name>
+		</desc>
+		<desc>
+			<value>mute_quick_target</value>
+			<_name>Mute quick action target</_name>
+		</desc>
+	</option>
+	<option name="wp_icon_size" type="int">
+		<_short>Icon size</_short>
+		<default>32</default>
+		<min>1</min>
+	</option>
+	</group>
+	<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 d2c4b058..bff4e6b3 100644
--- a/src/panel/meson.build
+++ b/src/panel/meson.build
@@ -35,8 +35,25 @@ deps = [
 ]
 
 if libpulse.found()
-  widget_sources += 'widgets/volume.cpp'
+  widget_sources += [
+    'widgets/volume.cpp',
+    'widgets/volume-level.cpp',
+  ]
   deps += [libpulse, libgvc]
+else
+  message('Pulse not found, volume widget will not be available.')
+endif
+
+if wireplumber.found()
+  widget_sources += [
+    'widgets/wp-mixer/wp-mixer.cpp',
+    'widgets/wp-mixer/wf-wp-control.cpp',
+    'widgets/wp-mixer/wp-common.cpp',
+    'widgets/volume-level.cpp',
+  ]
+  deps += wireplumber
+else
+  message('Wireplumber not found, mixer widget will not be available.')
 endif
 
 executable(
diff --git a/src/panel/panel.cpp b/src/panel/panel.cpp
index cc7a6df7..dd4acdc3 100644
--- a/src/panel/panel.cpp
+++ b/src/panel/panel.cpp
@@ -26,6 +26,9 @@
 #ifdef HAVE_PULSE
     #include "widgets/volume.hpp"
 #endif
+#ifdef HAVE_WIREPLUMBER
+    #include "widgets/wp-mixer/wp-mixer.hpp"
+#endif
 #include "widgets/window-list/window-list.hpp"
 #include "widgets/notifications/notification-center.hpp"
 #include "widgets/tray/tray.hpp"
@@ -160,12 +163,21 @@ class WayfirePanel::impl
 #ifdef HAVE_PULSE
             return Widget(new WayfireVolume());
 #else
-    #warning "Pulse not found, volume widget will not be available."
             std::cerr << "Built without pulse support, volume widget "
                          " is not available." << std::endl;
 #endif
         }
 
+        if (name == "wp-mixer")
+        {
+#ifdef HAVE_WIREPLUMBER
+            return Widget(new WayfireWpMixer());
+#else
+            std::cerr << "Built without wireplumber support, mixer widget "
+                         " is not available." << std::endl;
+#endif
+        }
+
         if (name == "window-list")
         {
             return Widget(new WayfireWindowList(output));
@@ -363,6 +375,7 @@ void WayfirePanelApp::on_activate()
     new CssFromConfigInt("panel/battery_icon_size", ".battery image{-gtk-icon-size:", "px;}");
     new CssFromConfigInt("panel/network_icon_size", ".network{-gtk-icon-size:", "px;}");
     new CssFromConfigInt("panel/volume_icon_size", ".volume{-gtk-icon-size:", "px;}");
+    new CssFromConfigInt("panel/wp_icon_size", ".wireplumber{-gtk-icon-size:", "px;}");
     new CssFromConfigInt("panel/notifications_icon_size", ".notification-center{-gtk-icon-size:", "px;}");
     new CssFromConfigInt("panel/tray_icon_size", ".tray-button{-gtk-icon-size:", "px;}");
     new CssFromConfigString("panel/background_color", ".wf-panel{background-color:", ";}");
diff --git a/src/panel/widgets/volume-level.cpp b/src/panel/widgets/volume-level.cpp
new file mode 100644
index 00000000..64f92be3
--- /dev/null
+++ b/src/panel/widgets/volume-level.cpp
@@ -0,0 +1,42 @@
+#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
new file mode 100644
index 00000000..6647133c
--- /dev/null
+++ b/src/panel/widgets/volume-level.hpp
@@ -0,0 +1,6 @@
+#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 1400d445..04312d20 100644
--- a/src/panel/widgets/volume.cpp
+++ b/src/panel/widgets/volume.cpp
@@ -2,98 +2,17 @@
 #include <glibmm.h>
 #include "volume.hpp"
 
-WayfireVolumeScale::WayfireVolumeScale()
-{
-    value_changed = this->signal_value_changed().connect([=] ()
-    {
-        this->current_volume.animate(this->get_value(), this->get_value());
-        if (this->user_changed_callback)
-        {
-            this->user_changed_callback();
-        }
-    });
-}
-
-WayfireVolumeScale::~WayfireVolumeScale()
-{
-    value_changed.disconnect();
-}
-
-void WayfireVolumeScale::set_target_value(double value)
-{
-    this->current_volume.animate(value);
-    add_tick_callback(sigc::mem_fun(*this, &WayfireVolumeScale::update_animation));
-}
-
-gboolean WayfireVolumeScale::update_animation(Glib::RefPtr<Gdk::FrameClock> frame_clock)
-{
-    value_changed.block();
-    this->set_value(this->current_volume);
-    value_changed.unblock();
-    // Once we've finished fading, stop this callback
-    return this->current_volume.running() ? G_SOURCE_CONTINUE : G_SOURCE_REMOVE;
-}
-
-double WayfireVolumeScale::get_target_value() const
-{
-    return this->current_volume.end;
-}
-
-void WayfireVolumeScale::set_user_changed_callback(
-    std::function<void()> callback)
-{
-    this->user_changed_callback = callback;
-}
-
-enum VolumeLevel
-{
-    VOLUME_LEVEL_MUTE = 0,
-    VOLUME_LEVEL_LOW,
-    VOLUME_LEVEL_MED,
-    VOLUME_LEVEL_HIGH,
-    VOLUME_LEVEL_OOR, /* Out of range */
-};
-
-static VolumeLevel get_volume_level(pa_volume_t volume, pa_volume_t max)
-{
-    auto third = max / 3;
-    if (volume == 0)
-    {
-        return VOLUME_LEVEL_MUTE;
-    } else if ((volume > 0) && (volume <= third))
-    {
-        return VOLUME_LEVEL_LOW;
-    } else if ((volume > third) && (volume <= (third * 2)))
-    {
-        return VOLUME_LEVEL_MED;
-    } else if ((volume > (third * 2)) && (volume <= max))
-    {
-        return VOLUME_LEVEL_HIGH;
-    }
-
-    return VOLUME_LEVEL_OOR;
-}
+#include "volume-level.hpp"
 
 void WayfireVolume::update_icon()
 {
-    VolumeLevel current =
-        get_volume_level(volume_scale.get_target_value(), max_norm);
-
     if (gvc_stream && gvc_mixer_stream_get_is_muted(gvc_stream))
     {
-        main_image.set_from_icon_name("audio-volume-muted");
+        main_image.set_from_icon_name(volume_icon_for(0)); // mute
         return;
     }
 
-    std::map<VolumeLevel, std::string> icon_name_from_state = {
-        {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, "audio-volume-muted"},
-    };
-
-    main_image.set_from_icon_name(icon_name_from_state.at(current));
+    main_image.set_from_icon_name(volume_icon_for(volume_scale.get_target_value() / (double)max_norm));
 }
 
 bool WayfireVolume::on_popover_timeout(int timer)
@@ -197,8 +116,7 @@ void WayfireVolume::on_default_sink_changed()
     volume_scale.set_increments(max_norm * scroll_sensitivity,
         max_norm * scroll_sensitivity * 2);
 
-    /* Finally, update the displayed volume. However, do not show the
-     * popup */
+    /* Finally, update the displayed volume. However, do not show the popup */
     set_volume(gvc_mixer_stream_get_volume(gvc_stream), VOLUME_FLAG_NO_ACTION);
 }
 
diff --git a/src/panel/widgets/volume.hpp b/src/panel/widgets/volume.hpp
index d83eb00d..c93f919c 100644
--- a/src/panel/widgets/volume.hpp
+++ b/src/panel/widgets/volume.hpp
@@ -2,39 +2,15 @@
 
 #include "../widget.hpp"
 #include <gtkmm/image.h>
-#include <gtkmm/scale.h>
+#include "../../util/animated-scale.hpp"
 #include <pulse/pulseaudio.h>
 #include <gvc-mixer-control.h>
 #include <wayfire/util/duration.hpp>
 
-/**
- * A custom scale which animates transitions when its value is
- * changed programatically.
- */
-class WayfireVolumeScale : public Gtk::Scale
-{
-    wf::animation::simple_animation_t current_volume{wf::create_option(200)};
-    sigc::connection value_changed;
-    std::function<void()> user_changed_callback;
-
-  public:
-    WayfireVolumeScale();
-    ~WayfireVolumeScale();
-
-    /* Gets the current target value */
-    double get_target_value() const;
-    /* Set a target value to animate towards */
-    void set_target_value(double value);
-    /** Set the callback when the user changes the scale value */
-    void set_user_changed_callback(std::function<void()> callback);
-    /** Callback to animate volume control */
-    gboolean update_animation(Glib::RefPtr<Gdk::FrameClock> clock);
-};
-
 class WayfireVolume : public WayfireWidget
 {
     Gtk::Image main_image;
-    WayfireVolumeScale volume_scale;
+    WayfireAnimatedScale volume_scale;
     Gtk::Button button;
     Gtk::Popover popover;
 
@@ -70,9 +46,8 @@ class WayfireVolume : public WayfireWidget
     };
 
     /**
-     * Set the current volume level to volume_level.
-     * This updates both the popover scale and the real pulseaudio volume,
-     * depending on the passed flags.
+     * Set the current volume level to volume_level. This updates both the popover scale and the real
+     * pulseaudio volume, depending on the passed flags.
      *
      * Precondition: volume_level should be between 0 and max_norm
      */
@@ -93,8 +68,7 @@ class WayfireVolume : public WayfireWidget
     void on_default_sink_changed();
 
     /**
-     * Check whether the popover should be auto-hidden, and if yes, start
-     * a timer to hide it
+     * Check whether the popover should be auto-hidden, and if yes, start a timer to hide it
      */
     void check_set_popover_timeout();
 };
diff --git a/src/panel/widgets/wp-mixer/wf-wp-control.cpp b/src/panel/widgets/wp-mixer/wf-wp-control.cpp
new file mode 100644
index 00000000..ef1e6a08
--- /dev/null
+++ b/src/panel/widgets/wp-mixer/wf-wp-control.cpp
@@ -0,0 +1,270 @@
+#include <pipewire/keys.h>
+#include <gtkmm.h>
+
+#include "wf-wp-control.hpp"
+#include "../volume-level.hpp"
+
+WfWpControl::WfWpControl(WpPipewireObject *obj, WayfireWpMixer *parent_widget)
+{
+    object = obj;
+    parent = parent_widget;
+}
+
+WfWpControl::~WfWpControl()
+{
+    mute_conn.disconnect();
+    middle_conn.disconnect();
+    right_conn.disconnect();
+    for (auto signal : signals)
+    {
+        signal.disconnect();
+    }
+}
+
+void WfWpControl::init()
+{
+    guint32 id = wp_proxy_get_bound_id(WP_PROXY(object));
+
+    // build layout
+
+    button.set_child(volume_icon);
+    button.get_style_context()->add_class("wireplumber");
+    button.get_style_context()->add_class("flat");
+
+    scale.set_range(0.0, 1.0);
+    scale.set_size_request(slider_length, 0);
+
+    const gchar *name;
+    // try to find a name to display
+    name = wp_pipewire_object_get_property(object, PW_KEY_NODE_DESCRIPTION);
+    if (!name)
+    {
+        name = wp_pipewire_object_get_property(object, PW_KEY_NODE_NICK);
+    }
+
+    if (!name)
+    {
+        name = wp_pipewire_object_get_property(object, PW_KEY_NODE_NAME);
+    }
+
+    if (!name)
+    {
+        name = "Unnamed";
+    }
+
+    label.set_text(Glib::ustring(name));
+    // this causes the label’s *minimum* size to be 0, causing it to not request any space,
+    // thus having the column’s width be dictated solely by the scale’s size request
+    label.set_max_width_chars(0);
+    label.set_ellipsize(Pango::EllipsizeMode::END);
+
+    set_tooltip_text(name);
+
+    update_icons_pos();
+
+    // setup user interactions
+
+    signals.push_back(mute_conn = button.signal_toggled().connect(
+        [this, id] ()
+    {
+        // if the menu was popped up because of an external change
+        // and is now changed manually, don’t hide
+        parent->cancel_popover_timeout();
+        ignore = true;
+        // disregarding the return value prevents cases where ignore is read at an ncorrect time,
+        // with the only problem of having one update ignored if something goes very wrong
+        WpCommon::get().set_mute(id, button.get_active());
+    }));
+
+    scale.set_user_changed_callback(
+        [this, id] ()
+    {
+        parent->cancel_popover_timeout(); // see above
+        ignore = true;
+        WpCommon::get().set_volume(id, scale.get_target_value());
+    });
+
+    auto scroll_gesture = Gtk::EventControllerScroll::create();
+    signals.push_back(scroll_gesture->signal_scroll().connect([=] (double dx, double dy)
+    {
+        dy = parent->invert_scroll ? dy : dy * -1; // for the same scrolling as volume widget, which we will
+                                                   // agree it is more intuitive for more people
+        double change = 0;
+        const double SCROLL_MULT = 0.2; // corrects the scrolling to have the default scroll sensitivity as 1
+        if (scroll_gesture->get_unit() == Gdk::ScrollUnit::WHEEL)
+        {
+            // +- number of clicks.
+            change = (dy * parent->scroll_sensitivity * SCROLL_MULT) / 10;
+        } else
+        {
+            // Number of pixels expected to have scrolled. usually in 100s
+            change = (dy * parent->scroll_sensitivity * SCROLL_MULT) / 100;
+        }
+
+        WpCommon::get().set_volume(id, scale.get_target_value() + change);
+        return true;
+    }, true));
+    scroll_gesture->set_flags(Gtk::EventControllerScroll::Flags::VERTICAL);
+    add_controller(scroll_gesture);
+
+    middle_click_mute = Gtk::GestureClick::create();
+    right_click_mute  = Gtk::GestureClick::create();
+    middle_click_mute->set_button(2);
+    right_click_mute->set_button(3);
+    add_controller(middle_click_mute);
+    add_controller(right_click_mute);
+
+    update_gestures();
+
+    // initialise the values
+    auto v = WpCommon::get().get_volume_and_mute(id);
+    set_scale_target_value(v.first);
+    set_btn_status_no_callbk(v.second);
+
+    update_icon();
+}
+
+void WfWpControl::set_btn_status_no_callbk(bool state)
+{
+    mute_conn.block(true);
+    button.set_active(state);
+    mute_conn.block(false);
+}
+
+void WfWpControl::set_scale_target_value(double volume)
+{
+    scale.set_target_value(volume);
+}
+
+void WfWpControl::update_icon()
+{
+    if (button.get_active())
+    {
+        volume_icon.set_from_icon_name(volume_icon_for(0)); // mute
+        return;
+    }
+
+    volume_icon.set_from_icon_name(volume_icon_for(get_scale_target_value()));
+}
+
+double WfWpControl::get_scale_target_value()
+{
+    return scale.get_target_value();
+}
+
+// attaches elements to the grid at the appropriate place
+void WfWpControl::update_icons_pos()
+{
+    static WfOption<bool> icons_on_left{"panel/wp_icons_on_left"};
+
+    if (icons_on_left)
+    {
+        attach(label, 1, 0);
+        attach(scale, 1, 1);
+        attach(button, 0, 1);
+    } else
+    {
+        attach(label, 0, 0);
+        attach(scale, 0, 1);
+        attach(button, 1, 1);
+    }
+}
+
+void WfWpControl::update_gestures()
+{
+    // the setting says that it is for quick target, but let’s have all the muting consistent
+    static WfOption<std::string> str_wp_right_click_action{"panel/wp_right_click_action"};
+    static WfOption<std::string> str_wp_middle_click_action{"panel/wp_middle_click_action"};
+
+    auto mute_action =
+        [&] (int count, double x, double y)
+    {
+        button.set_active(!button.get_active());
+    };
+
+    if (str_wp_middle_click_action.value() == "mute_quick_target")
+    {
+        middle_conn = middle_click_mute->signal_pressed().connect(mute_action);
+    }
+
+    if (str_wp_right_click_action.value() == "mute_quick_target")
+    {
+        right_conn = right_click_mute->signal_pressed().connect(mute_action);
+    }
+}
+
+void WfWpControl::handle_config_reload()
+{
+    remove(label);
+    remove(scale);
+    remove(button);
+    middle_conn.disconnect();
+    right_conn.disconnect();
+    update_icons_pos();
+    update_gestures();
+    scale.set_size_request(slider_length);
+}
+
+// used to make a copy to the face of the widget
+std::unique_ptr<WfWpControl> WfWpControl::copy()
+{
+    return std::make_unique<WfWpControl>(object, parent);
+}
+
+WfWpControlDevice::~WfWpControlDevice()
+{
+    def_conn.disconnect();
+}
+
+void WfWpControlDevice::init()
+{
+    default_btn.get_style_context()->add_class("wireplumber");
+    default_btn.get_style_context()->add_class("flat");
+
+    is_def_icon.set_from_icon_name("emblem-default");
+    default_btn.set_child(is_def_icon);
+
+    // we are not using ToggleButton groups because on_default_nodes_changed
+    // will be called anyway to set the status of all devices
+    def_conn = default_btn.signal_clicked().connect(
+        [this] ()
+    {
+        // keep the button down when it is selected to prevent inconsistency of visuals with actual state
+        if (default_btn.get_active() == false)
+        {
+            set_def_status_no_callbk(true);
+            return;
+        }
+
+        WpCommon::get().set_default(object);
+    });
+
+    WfWpControl::init();
+}
+
+void WfWpControlDevice::set_def_status_no_callbk(bool state)
+{
+    def_conn.block(true);
+    default_btn.set_active(state);
+    def_conn.block(false);
+}
+
+void WfWpControlDevice::update_icons_pos()
+{
+    WfWpControl::update_icons_pos();
+    static WfOption<bool> icons_on_left{"panel/wp_icons_on_left"};
+
+    if (icons_on_left)
+    {
+        attach(default_btn, 0, 0);
+    } else
+    {
+        attach(default_btn, 1, 0);
+    }
+}
+
+void WfWpControlDevice::handle_config_reload()
+{
+    remove(default_btn);
+    WfWpControl::handle_config_reload();
+}
diff --git a/src/panel/widgets/wp-mixer/wf-wp-control.hpp b/src/panel/widgets/wp-mixer/wf-wp-control.hpp
new file mode 100644
index 00000000..f3557d78
--- /dev/null
+++ b/src/panel/widgets/wp-mixer/wf-wp-control.hpp
@@ -0,0 +1,69 @@
+#pragma once
+
+#include <gtkmm.h>
+#include <mutex>
+
+#include "wp-mixer.hpp"
+#include "animated-scale.hpp"
+
+class WayfireWpMixer;
+
+class WfWpControl : public Gtk::Grid
+{
+    // Custom grid to facilitate handling
+
+  protected:
+    WayfireAnimatedScale scale;
+    Gtk::Image volume_icon;
+    sigc::connection mute_conn;
+    WayfireWpMixer *parent;
+    std::shared_ptr<Gtk::GestureClick> middle_click_mute, right_click_mute;
+    sigc::connection middle_conn, right_conn;
+    std::vector<sigc::connection> signals;
+    void update_gestures();
+    virtual void update_icons_pos();
+    WfOption<int> slider_length{"panel/wp_slider_length"};
+
+  public:
+    WfWpControl(WpPipewireObject *obj, WayfireWpMixer *parent_widget);
+    ~WfWpControl();
+    virtual void init();
+
+    WpPipewireObject *object;
+    Gtk::Label label;
+    Gtk::ToggleButton button;
+    void set_btn_status_no_callbk(bool state);
+    void set_scale_target_value(double volume);
+    double get_scale_target_value();
+    void update_icon();
+    // used to mark the control as the source of changes and stop useless/counterproductive updates
+    bool ignore = false; // set when volume changes because of it to ignore refresh of ui
+
+    virtual void handle_config_reload();
+
+    std::unique_ptr<WfWpControl> copy();
+};
+
+// idea: would be neat to have a WfWpControlStream class that presents a dropdown to select which sink a
+// stream goes to
+
+// sinks and sources: a control with a button to set itself as default for it’s category
+class WfWpControlDevice : public WfWpControl
+{
+  private:
+
+    sigc::connection def_conn;
+    Gtk::Image is_def_icon;
+    void update_icons_pos();
+
+  public:
+    WfWpControlDevice(WpPipewireObject *obj, WayfireWpMixer *parent_widget) : WfWpControl(obj, parent_widget)
+    {}
+    ~WfWpControlDevice();
+    void init();
+
+    Gtk::ToggleButton default_btn;
+    void set_def_status_no_callbk(bool state);
+
+    void handle_config_reload();
+};
diff --git a/src/panel/widgets/wp-mixer/wp-common.cpp b/src/panel/widgets/wp-mixer/wp-common.cpp
new file mode 100644
index 00000000..49462ee6
--- /dev/null
+++ b/src/panel/widgets/wp-mixer/wp-common.cpp
@@ -0,0 +1,506 @@
+#include <iostream>
+#include <pipewire/keys.h>
+
+#include "wp-common.hpp"
+#include "wp/proxy-interfaces.h"
+
+const gchar *DEFAULT_NODE_MEDIA_CLASSES[] = {
+    "Audio/Sink",
+    "Audio/Source",
+};
+
+WpCommon::WpCommon()
+{
+    // creates the core, object interests and connects signals
+
+    std::cout << "Initialising wireplumber\n";
+    wp_init(WP_INIT_PIPEWIRE);
+    core = wp_core_new(NULL, NULL, NULL);
+    object_manager = wp_object_manager_new();
+
+    // register interests in sinks, sources and streams
+    WpObjectInterest *sink_interest = wp_object_interest_new_type(WP_TYPE_NODE);
+    wp_object_interest_add_constraint(
+        sink_interest,
+        WP_CONSTRAINT_TYPE_PW_PROPERTY,
+        "media.class",
+        WP_CONSTRAINT_VERB_EQUALS,
+        g_variant_new_string("Audio/Sink"));
+
+    wp_object_manager_add_interest_full(object_manager, sink_interest);
+
+    WpObjectInterest *source_interest = wp_object_interest_new_type(WP_TYPE_NODE);
+    wp_object_interest_add_constraint(
+        source_interest,
+        WP_CONSTRAINT_TYPE_PW_PROPERTY,
+        "media.class",
+        WP_CONSTRAINT_VERB_EQUALS,
+        g_variant_new_string("Audio/Source"));
+
+    wp_object_manager_add_interest_full(object_manager, source_interest);
+
+    WpObjectInterest *stream_interest = wp_object_interest_new_type(WP_TYPE_NODE);
+    wp_object_interest_add_constraint(
+        stream_interest,
+        WP_CONSTRAINT_TYPE_PW_PROPERTY,
+        "media.class",
+        WP_CONSTRAINT_VERB_EQUALS,
+        g_variant_new_string("Stream/Output/Audio"));
+
+    wp_object_manager_add_interest_full(object_manager, stream_interest);
+
+    // load plugins
+    wp_core_load_component(
+        core,
+        "libwireplumber-module-mixer-api",
+        "module",
+        NULL,
+        NULL,
+        NULL,
+        (GAsyncReadyCallback)on_mixer_plugin_loaded,
+        NULL);
+
+    wp_core_connect(core);
+}
+
+void WpCommon::on_mixer_plugin_loaded(WpCore *core, GAsyncResult *res, void *data)
+{
+    instance->mixer_api = wp_plugin_find(core, "mixer-api");
+    // as far as i understand, this should set the mixer api to use linear scale
+    // however, it doesn’t and i can’t find what is wrong.
+    // for now, we calculate manually
+    // g_object_set(mixer_api, "scale", 0, NULL); // set to linear
+
+    wp_core_load_component(
+        core,
+        "libwireplumber-module-default-nodes-api",
+        "module",
+        NULL,
+        NULL,
+        NULL,
+        (GAsyncReadyCallback)on_default_nodes_plugin_loaded,
+        NULL);
+}
+
+void WpCommon::on_default_nodes_plugin_loaded(WpCore *core, GAsyncResult *res, void *data)
+{
+    instance->default_nodes_api = wp_plugin_find(core, "default-nodes-api");
+
+    instance->on_all_plugins_loaded();
+}
+
+void WpCommon::on_all_plugins_loaded()
+{
+    // connect signals
+    g_signal_connect(
+        instance->mixer_api,
+        "changed",
+        G_CALLBACK(instance->on_mixer_changed),
+        NULL);
+
+    g_signal_connect(
+        instance->default_nodes_api,
+        "changed",
+        G_CALLBACK(instance->on_default_nodes_changed),
+        NULL);
+
+    g_signal_connect(
+        instance->object_manager,
+        "object_added",
+        G_CALLBACK(instance->on_object_added),
+        NULL);
+
+    g_signal_connect(
+        instance->object_manager,
+        "object-removed",
+        G_CALLBACK(instance->on_object_removed),
+        NULL);
+
+    wp_core_install_object_manager(instance->core, instance->object_manager);
+}
+
+void WpCommon::catch_up_to_current_state(WayfireWpMixer *widget)
+{
+    // catch up to objects already registered by the manager
+    WpIterator *reg_objs = wp_object_manager_new_iterator(object_manager);
+    GValue item = G_VALUE_INIT;
+    while (wp_iterator_next(reg_objs, &item))
+    {
+        add_object_to_widget((WpPipewireObject*)g_value_get_object(&item), widget);
+        g_value_unset(&item);
+    }
+}
+
+void WpCommon::add_object_to_widget(WpPipewireObject *object, WayfireWpMixer *widget)
+{
+    // adds a new control to the appropriate section of a widget
+
+    const std::string_view type{wp_pipewire_object_get_property(object, PW_KEY_MEDIA_CLASS)};
+
+    bool recheck_default = false;
+    WfWpControl *control;
+    Gtk::Box *which_box;
+    if (type == "Audio/Sink")
+    {
+        which_box = &(widget->sinks_box);
+        control   = new WfWpControlDevice(object, widget);
+        recheck_default = true;
+    } else if (type == "Audio/Source")
+    {
+        which_box = &(widget->sources_box);
+        control   = new WfWpControlDevice(object, widget);
+        recheck_default = true;
+    } else if (type == "Stream/Output/Audio")
+    {
+        which_box = &(widget->streams_box);
+        control   = new WfWpControl(object, (WayfireWpMixer*)widget);
+    } else
+    {
+        std::cout << "Could not match pipewire object media class, ignoring\n";
+        return;
+    }
+
+    control->init();
+    widget->objects_to_controls.insert({object, std::unique_ptr<WfWpControl>(control)});
+    which_box->append((Gtk::Widget&)*control);
+
+    // we added new controls, so maybe one of them is a default
+    // also initialises the quick_target for when quick_target choice is a device
+    if (recheck_default)
+    {
+        on_default_nodes_changed(default_nodes_api, NULL);
+    }
+
+    // let’s considier this a change and set this as quick_target
+    if (widget->quick_target_choice == QuickTargetChoice::LAST_CHANGE)
+    {
+        widget->set_quick_target_from(control);
+        // if the full mixer is not shown, change the popover child
+        if ((widget->popover->get_child() !=
+             &(widget->master_box)) && widget->popover->is_visible())
+        {
+            widget->popover->set_child(*widget->quick_target);
+        }
+
+        widget->update_icon();
+    }
+}
+
+void WpCommon::on_object_added(WpObjectManager *manager, gpointer object, gpointer data)
+{
+    // add to all the registered widgets
+    auto *obj = (WpPipewireObject*)object;
+
+    for (auto widget : instance->widgets)
+    {
+        instance->add_object_to_widget(obj, widget);
+    }
+}
+
+void WpCommon::on_mixer_changed(gpointer mixer_api, guint id, gpointer data)
+{
+    // update the visual of the appropriate WfWpControl according to external changes on all widgets
+
+    auto info = instance->get_volume_and_mute(id);
+
+    auto volume = info.first;
+    auto mute   = info.second;
+
+    // for each widget
+    for (auto widget : instance->widgets)
+    {
+        WfWpControl *control;
+
+        // first, find the appropiate control
+        for (auto & it : widget->objects_to_controls)
+        {
+            WpPipewireObject *obj = it.first;
+            control = it.second.get();
+            if (wp_proxy_get_bound_id(WP_PROXY(obj)) == id)
+            {
+                break;
+            }
+
+            // if we are at the end and still no match
+            if (it.first == widget->objects_to_controls.end()->first)
+            {
+                std::cerr << "Wireplumber mixer could not find control for wp object";
+                return;
+            }
+        }
+
+        const auto update_icons = [&] ()
+        {
+            control->update_icon();
+            if (widget->quick_target)
+            {
+                widget->quick_target->update_icon();
+            }
+
+            widget->update_icon();
+        };
+
+        bool change = false; // if something changes below
+
+        // if the quick_target controls the same object as the changed, correct it as well
+        if (
+            widget->quick_target /* not quick-target-less guard */
+            // current control and quick_target are for the same wp obj
+            && (control->object ==
+                widget->quick_target->object))
+        {
+            widget->quick_target->set_btn_status_no_callbk(mute);
+            widget->quick_target->set_scale_target_value(volume);
+            change = true;
+        }
+        // change quick_target if needed
+        else if (widget->quick_target_choice == QuickTargetChoice::LAST_CHANGE)
+        {
+            widget->set_quick_target_from(control);
+            change = true;
+        }
+
+        // if this control is the source of this change, don’t do anything
+        if (control->ignore)
+        {
+            control->ignore = false;
+            update_icons();
+            continue;
+        }
+
+        // correct the values of the control
+        control->set_btn_status_no_callbk(mute);
+        control->set_scale_target_value(volume);
+
+        update_icons();
+
+        // if the mixer is currently being displayed, stop there
+        if ((widget->popover->get_child() ==
+             &(widget->master_box)) && widget->popover->is_visible())
+        {
+            continue;
+        }
+
+        if (widget->quick_target &&
+            (!widget->popover->is_visible() ||
+             (widget->popover->get_child() != (WfWpControl*)&widget->quick_target)))
+        {
+            // put the quick_target in the popover and show
+            widget->popover->set_child(*widget->quick_target);
+            if (widget->popup_on_change && change)
+            {
+                widget->popover->popup();
+            }
+        }
+
+        // in all cases that reach here, (re-)schedule hiding
+        widget->check_set_popover_timeout();
+    }
+}
+
+void WpCommon::on_default_nodes_changed(gpointer default_nodes_api, gpointer data)
+{
+    // silimarly to mixer, update the visuals of the controls on the widgets
+
+    if (!default_nodes_api)
+    {
+        return;
+    }
+
+    std::vector<guint32> defaults;
+    guint32 id = SPA_ID_INVALID;
+
+    // for the appropriate classes
+    for (guint32 i = 0; i < G_N_ELEMENTS(DEFAULT_NODE_MEDIA_CLASSES); i++)
+    {
+        // query the new data
+        g_signal_emit_by_name(default_nodes_api, "get-default-node", DEFAULT_NODE_MEDIA_CLASSES[i], &id);
+        if (id != SPA_ID_INVALID)
+        {
+            defaults.push_back(id);
+        }
+    }
+
+    for (const auto widget : instance->widgets)
+    {
+        for (const auto & entry : widget->objects_to_controls)
+        {
+            auto obj  = WP_PIPEWIRE_OBJECT(entry.first);
+            auto ctrl = static_cast<WfWpControlDevice*>(entry.second.get());
+
+            guint32 bound_id = wp_proxy_get_bound_id(WP_PROXY(obj));
+            if (bound_id == SPA_ID_INVALID)
+            {
+                continue;
+            }
+
+            bool is_default = std::any_of(defaults.begin(), defaults.end(), [bound_id] (guint32 def_id)
+            {
+                return def_id == bound_id;
+            });
+
+            // is it a source or a sink?
+            const std::string_view type{wp_pipewire_object_get_property(obj, PW_KEY_MEDIA_CLASS)};
+
+            if (!is_default)
+            {
+                const std::string_view type{wp_pipewire_object_get_property(obj, PW_KEY_MEDIA_CLASS)};
+                if ((type == "Audio/Sink") || (type == "Audio/Source"))
+                {
+                    ctrl->set_def_status_no_callbk(false);
+                }
+
+                continue;
+            }
+
+            // if we’re here, we’re a default of some kind
+            ctrl->set_def_status_no_callbk(true);
+
+            if ((widget->quick_target_choice == QuickTargetChoice::DEFAULT_SINK) &&
+                (type == "Audio/Sink")
+                ||
+                (widget->quick_target_choice == QuickTargetChoice::DEFAULT_SOURCE) &&
+                (type == "Audio/Source")) // if the settings call for it, refresh the quick_target
+            {
+                widget->set_quick_target_from(ctrl);
+                widget->update_icon();
+            }
+        }
+    }
+}
+
+void WpCommon::on_object_removed(WpObjectManager *manager, gpointer object, gpointer data)
+{
+    for (auto widget : instance->widgets)
+    {
+        auto it = widget->objects_to_controls.find((WpPipewireObject*)object);
+        if (it == widget->objects_to_controls.end())
+        {
+            // shouldn’t happen, but checking to avoid weird situations
+            return;
+        }
+
+        WfWpControl *control = it->second.get();
+        auto *box = (Gtk::Box*)control->get_parent();
+        if (box)
+        {
+            box->remove(*control);
+        }
+
+        // if quick_target points to the removed control we should handle it.
+        if (widget->quick_target && (widget->quick_target->object == it->first))
+        {
+            // reset quick_target to nullptr
+            widget->quick_target = nullptr;
+        }
+
+        widget->objects_to_controls.erase(it);
+    }
+}
+
+void WpCommon::add_widget(WayfireWpMixer *widget)
+{
+    widgets.push_back(widget);
+    catch_up_to_current_state(widget);
+}
+
+void WpCommon::rem_widget(WayfireWpMixer *widget)
+{
+    widgets.erase(std::find(widgets.begin(), widgets.end(), widget));
+}
+
+std::pair<double, bool> WpCommon::get_volume_and_mute(guint32 id)
+{
+    if (!mixer_api)
+    {
+        return {0.0, true};
+    }
+
+    GVariant *v = NULL;
+    g_signal_emit_by_name(mixer_api, "get-volume", id, &v);
+    if (!v)
+    {
+        return {0.0, true};
+    }
+
+    gboolean mute  = TRUE;
+    gdouble volume = 0.0;
+    g_variant_lookup(v, "volume", "d", &volume);
+    g_variant_lookup(v, "mute", "b", &mute);
+    g_clear_pointer(&v, g_variant_unref);
+    return std::make_pair(std::cbrt(volume), mute);
+}
+
+gboolean WpCommon::set_volume(guint32 id, double volume)
+{
+    using Vol = std::map<Glib::ustring, Glib::Variant<double>>;
+    Vol vol;
+    vol["volume"] = Glib::Variant<double>::create(std::pow(volume, 3));
+    auto vol_v   = Glib::Variant<Vol>::create(vol);
+    gboolean res = FALSE; // ignored for now
+    g_signal_emit_by_name(WpCommon::mixer_api, "set-volume", id, vol_v.gobj(), &res);
+    return res;
+}
+
+gboolean WpCommon::set_mute(guint32 id, bool state)
+{
+    using Mute = std::map<Glib::ustring, Glib::Variant<bool>>;
+    Mute mute;
+    mute["mute"] = Glib::Variant<bool>::create(state);
+    auto mute_v  = Glib::Variant<Mute>::create(mute);
+    gboolean res = FALSE; // ignored for now
+    g_signal_emit_by_name(WpCommon::mixer_api, "set-volume", id, mute_v.gobj(), &res);
+    return res;
+}
+
+gboolean WpCommon::set_default(WpPipewireObject *object)
+{
+    auto proxy = WP_PROXY(object);
+    const gchar *media_class = wp_pipewire_object_get_property(
+        WP_PIPEWIRE_OBJECT(proxy),
+        PW_KEY_MEDIA_CLASS);
+    for (guint i = 0; i < G_N_ELEMENTS(DEFAULT_NODE_MEDIA_CLASSES); i++)
+    {
+        // only for the media class our object is in
+        if (media_class == DEFAULT_NODE_MEDIA_CLASSES[i])
+        {
+            continue;
+        }
+
+        const gchar *name = wp_pipewire_object_get_property(
+            WP_PIPEWIRE_OBJECT(proxy),
+            PW_KEY_NODE_NAME);
+        if (!name)
+        {
+            continue;
+        }
+
+        gboolean res = false;
+        g_signal_emit_by_name(WpCommon::default_nodes_api, "set-default-configured-node-name",
+            media_class, name, &res);
+
+        wp_core_sync(core, NULL, NULL, NULL);
+
+        return res;
+    }
+
+    return false;
+}
+
+void WpCommon::re_evaluate_def_nodes()
+{
+    if (default_nodes_api)
+    {
+        on_default_nodes_changed(default_nodes_api, NULL);
+    }
+}
+
+WpCommon& WpCommon::get()
+{
+    if (!instance)
+    {
+        instance = std::unique_ptr<WpCommon>(new WpCommon());
+    }
+
+    return *instance;
+}
diff --git a/src/panel/widgets/wp-mixer/wp-common.hpp b/src/panel/widgets/wp-mixer/wp-common.hpp
new file mode 100644
index 00000000..2df289ba
--- /dev/null
+++ b/src/panel/widgets/wp-mixer/wp-common.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <cstddef>
+#include <memory>
+#include <vector>
+#include <wp/proxy-interfaces.h>
+extern "C" {
+#include <wp/wp.h>
+}
+
+#include "wp-mixer.hpp"
+class WayfireWpMixer;
+
+class WpCommon
+{
+  private:
+    WpCommon();
+
+    static inline std::unique_ptr<WpCommon> instance;
+
+    WpCore *core = nullptr;
+    WpObjectManager *object_manager;
+    WpPlugin *mixer_api = nullptr;
+    WpPlugin *default_nodes_api = nullptr;
+
+    std::vector<WayfireWpMixer*> widgets;
+
+    void catch_up_to_current_state(WayfireWpMixer *widget);
+    static void on_mixer_plugin_loaded(WpCore *core, GAsyncResult *res, gpointer data);
+    static void on_default_nodes_plugin_loaded(WpCore *core, GAsyncResult *res, gpointer data);
+    static void on_all_plugins_loaded();
+    void add_object_to_widget(WpPipewireObject *object, WayfireWpMixer *widget);
+    static void on_object_added(WpObjectManager *manager, gpointer object, gpointer data);
+    static void on_mixer_changed(gpointer mixer_api, guint id, gpointer data);
+    static void on_default_nodes_changed(gpointer default_nodes_api, gpointer data);
+    static void on_object_removed(WpObjectManager *manager, gpointer node, gpointer data);
+
+  public:
+
+    void add_widget(WayfireWpMixer *widget);
+    void rem_widget(WayfireWpMixer *widget);
+
+    void re_evaluate_def_nodes();
+
+    std::pair<double, bool> get_volume_and_mute(guint32 id);
+    gboolean set_volume(guint32 id, double volume);
+    gboolean set_mute(guint32 id, bool state);
+    gboolean set_default(WpPipewireObject *object);
+
+    static WpCommon& get();
+};
diff --git a/src/panel/widgets/wp-mixer/wp-mixer.cpp b/src/panel/widgets/wp-mixer/wp-mixer.cpp
new file mode 100644
index 00000000..404b1f67
--- /dev/null
+++ b/src/panel/widgets/wp-mixer/wp-mixer.cpp
@@ -0,0 +1,353 @@
+#include <gtkmm.h>
+#include <wp/proxy-interfaces.h>
+#include <wp/proxy.h>
+
+#include "wp-mixer.hpp"
+#include "wf-wp-control.hpp"
+#include "../volume-level.hpp"
+
+bool WayfireWpMixer::on_popover_timeout(int timer)
+{
+    popover_timeout.disconnect();
+    popover->popdown();
+    return false;
+}
+
+void WayfireWpMixer::check_set_popover_timeout()
+{
+    popover_timeout.disconnect();
+
+    popover_timeout = Glib::signal_timeout().connect(sigc::bind(sigc::mem_fun(*this,
+        &WayfireWpMixer::on_popover_timeout), 0), timeout * 1000);
+}
+
+void WayfireWpMixer::cancel_popover_timeout()
+{
+    popover_timeout.disconnect();
+}
+
+void WayfireWpMixer::reload_config()
+{
+    // big matching operation
+    static WfOption<std::string> str_quick_target_choice{"panel/wp_quick_target_choice"};
+    static WfOption<std::string> str_wp_left_click_action{"panel/wp_left_click_action"};
+    static WfOption<std::string> str_wp_right_click_action{"panel/wp_right_click_action"};
+    static WfOption<std::string> str_wp_middle_click_action{"panel/wp_middle_click_action"};
+
+    if (str_quick_target_choice.value() == "last_change")
+    {
+        quick_target_choice = QuickTargetChoice::LAST_CHANGE;
+    } else if (str_quick_target_choice.value() == "default_sink")
+    {
+        quick_target_choice = QuickTargetChoice::DEFAULT_SINK;
+        WpCommon::get().re_evaluate_def_nodes();
+    } else if (str_quick_target_choice.value() == "default_source")
+    {
+        quick_target_choice = QuickTargetChoice::DEFAULT_SOURCE;
+        WpCommon::get().re_evaluate_def_nodes();
+    } else // default if no match
+    {
+        quick_target_choice = QuickTargetChoice::LAST_CHANGE;
+    }
+
+    // "actions" that can be bound to different clicks
+
+    auto show_mixer_action = [&] (int c, double x, double y)
+    {
+        // unschedule hiding
+        cancel_popover_timeout();
+
+        if ((popover->get_child() == (Gtk::Widget*)&master_box) && popover->is_visible())
+        {
+            popover->popdown();
+            return;
+        }
+
+        if (!popover->is_visible())
+        {
+            button->set_active(true);
+        }
+
+        if (popover->get_child() != (Gtk::Widget*)&master_box)
+        {
+            popover->set_child(master_box);
+            popover_timeout.disconnect();
+        }
+    };
+
+    auto show_quick_target_action = [&] (int c, double x, double y)
+    {
+        // unschedule hiding
+        cancel_popover_timeout();
+        if (!quick_target)
+        {
+            return; // no quick_target means we have nothing to show
+        }
+
+        if ((popover->get_child() == quick_target.get()) && popover->is_visible())
+        {
+            popover->popdown();
+            return;
+        }
+
+        if (!popover->is_visible())
+        {
+            button->set_active(true);
+        }
+
+        if (popover->get_child() != quick_target.get())
+        {
+            popover->set_child(*quick_target);
+            popover_timeout.disconnect();
+        }
+    };
+
+    auto mute_action = [&] (int c, double x, double y)
+    {
+        if (!quick_target)
+        {
+            return; // no quick_target means we have nothing to change by clicking
+        }
+
+        quick_target->button.set_active(!quick_target->button.get_active());
+    };
+
+    // the left click case is a bit special, since it’s supposed to show the popover.
+    // (this is also why the mute action is not available for the left click)
+    if (str_wp_left_click_action.value() == "show_mixer")
+    {
+        left_conn = left_click_gesture->signal_pressed().connect(
+            [&] (int c, double x, double y)
+        {
+            // unschedule hiding
+            cancel_popover_timeout();
+            if (popover->get_child() != (Gtk::Widget*)&master_box)
+            {
+                popover->set_child(master_box);
+                // popdown so that when the click is processed, the popover is down, and thus pops up
+                // not the prettiest result, as it visibly closes instead of just replacing, but i’m not sure
+                // how to make it better
+                button->set_active(false);
+            }
+        });
+    }
+
+    if (str_wp_left_click_action.value() == "show_quick_target")
+    {
+        left_conn = left_click_gesture->signal_pressed().connect(
+            [&] (int c, double x, double y)
+        {
+            // unschedule hiding
+            cancel_popover_timeout();
+            if (!quick_target)
+            {
+                return;
+            }
+
+            if (popover->get_child() != quick_target.get())
+            {
+                popover->set_child(*quick_target);
+                // same as above
+                button->set_active(false);
+            }
+        });
+    }
+
+    // more simple matching
+
+    if (str_wp_middle_click_action.value() == "show_mixer")
+    {
+        middle_conn = middle_click_gesture->signal_pressed().connect(show_mixer_action);
+    }
+
+    if (str_wp_middle_click_action.value() == "show_quick_target")
+    {
+        middle_conn = middle_click_gesture->signal_pressed().connect(show_quick_target_action);
+    }
+
+    if (str_wp_middle_click_action.value() == "mute_quick_target")
+    {
+        middle_conn = middle_click_gesture->signal_pressed().connect(mute_action);
+    }
+
+    if (str_wp_right_click_action.value() == "show_mixer")
+    {
+        right_conn = right_click_gesture->signal_pressed().connect(show_mixer_action);
+    }
+
+    if (str_wp_right_click_action.value() == "show_quick_target")
+    {
+        right_conn = right_click_gesture->signal_pressed().connect(show_quick_target_action);
+    }
+
+    if (str_wp_right_click_action.value() == "mute_quick_target")
+    {
+        right_conn = right_click_gesture->signal_pressed().connect(mute_action);
+    }
+}
+
+void WayfireWpMixer::handle_config_reload()
+{
+    left_conn.disconnect();
+    middle_conn.disconnect();
+    right_conn.disconnect();
+    reload_config();
+    for (auto & entry : objects_to_controls)
+    {
+        auto & control = entry.second;
+        control->handle_config_reload();
+    }
+}
+
+void WayfireWpMixer::init(Gtk::Box *container)
+{
+    // sets up the "widget part"
+
+    button = std::make_unique<WayfireMenuButton>("panel");
+    button->get_style_context()->add_class("wireplumber");
+    button->get_style_context()->add_class("flat");
+    button->get_children()[0]->get_style_context()->add_class("flat");
+    button->set_child(main_image);
+    button->show();
+
+    popover = button->get_popover();
+    popover->set_child(master_box);
+    popover->set_autohide(false);
+    popover->get_style_context()->add_class("wireplumber-popover");
+
+    // scroll to change volume of the object targetted by the quick_target widget
+    auto scroll_gesture = Gtk::EventControllerScroll::create();
+    scroll_conn = scroll_gesture->signal_scroll().connect([=] (double dx, double dy)
+    {
+        if (!quick_target)
+        {
+            return false; // no quick_target means we have nothing to change by scrolling
+        }
+
+        dy = invert_scroll ? dy : dy * -1; // for the same scrolling as volume widget, which we will agree it
+                                           // is more intuitive for more people
+        double change = 0;
+        const double SCROLL_MULT = 0.2; // corrects the scrolling to have the default scroll sensitivity as 1
+        if (scroll_gesture->get_unit() == Gdk::ScrollUnit::WHEEL)
+        {
+            // +- number of clicks.
+            change = (dy * scroll_sensitivity * SCROLL_MULT) / 10;
+        } else
+        {
+            // Number of pixels expected to have scrolled. usually in 100s
+            change = (dy * scroll_sensitivity * SCROLL_MULT) / 100;
+        }
+
+        guint32 id = wp_proxy_get_bound_id(WP_PROXY(quick_target->object));
+        WpCommon::get().set_volume(id, quick_target->get_scale_target_value() + change);
+        return true;
+    }, true);
+    scroll_gesture->set_flags(Gtk::EventControllerScroll::Flags::VERTICAL);
+    button->add_controller(scroll_gesture);
+
+    // set up gestures
+    left_click_gesture   = Gtk::GestureClick::create();
+    right_click_gesture  = Gtk::GestureClick::create();
+    middle_click_gesture = Gtk::GestureClick::create();
+    left_click_gesture->set_button(1);
+    middle_click_gesture->set_button(2);
+    right_click_gesture->set_button(3);
+    button->add_controller(left_click_gesture);
+    button->add_controller(right_click_gesture);
+    button->add_controller(middle_click_gesture);
+
+    // config options
+    reload_config();
+
+    // boxes hierarchy and labeling
+    master_box.set_orientation(Gtk::Orientation::HORIZONTAL);
+
+    // column orientations
+    out_in_wall.set_orientation(Gtk::Orientation::VERTICAL);
+    in_streams_wall.set_orientation(Gtk::Orientation::VERTICAL);
+
+    // assemble master box (todo: only show boxes that have contents)
+    master_box.append(sinks_box);
+    master_box.append(out_in_wall);
+    master_box.append(sources_box);
+    master_box.append(in_streams_wall);
+    master_box.append(streams_box);
+
+    auto set_categories_common = [&] (Gtk::Box& box)
+    {
+        box.set_orientation(Gtk::Orientation::VERTICAL);
+        box.set_spacing(icon_size / 3);
+        box.set_margin_top(icon_size / 3);
+        box.set_margin_bottom(icon_size / 3);
+    };
+
+    // sinks
+    output_label.set_text("Output devices");
+    sinks_box.append(output_label);
+    out_sep.set_orientation(Gtk::Orientation::HORIZONTAL);
+    sinks_box.append(out_sep);
+    set_categories_common(sinks_box);
+
+    // sources
+    input_label.set_text("Input devices");
+    sources_box.append(input_label);
+    in_sep.set_orientation(Gtk::Orientation::HORIZONTAL);
+    sources_box.append(in_sep);
+    set_categories_common(sources_box);
+
+    // streams
+    streams_label.set_text("Audio streams");
+    streams_box.append(streams_label);
+    streams_sep.set_orientation(Gtk::Orientation::HORIZONTAL);
+    streams_box.append(streams_sep);
+    set_categories_common(streams_box);
+
+    // add to the actual container
+    container->append(*button);
+    button->set_child(main_image);
+
+    // if there is no audio device nor application, the quick target will not be set
+    // and the widget will apear empty. Calling this here to always have the OOR icon.
+    update_icon();
+
+    // get() returns WpCommon and creates it if it wasn’t yet.
+    // add_widget also catches up this widget to every audio channel registered before.
+    WpCommon::get().add_widget(this);
+}
+
+void WayfireWpMixer::update_icon()
+{
+    // depends on quick_target widget
+    if (!quick_target)
+    {
+        main_image.set_from_icon_name(volume_icon_for(-1)); // OOR
+        return;
+    }
+
+    if (quick_target->button.get_active())
+    {
+        main_image.set_from_icon_name(volume_icon_for(0)); // mute
+        return;
+    }
+
+    main_image.set_from_icon_name(volume_icon_for(quick_target->get_scale_target_value()));
+}
+
+void WayfireWpMixer::set_quick_target_from(WfWpControl *from)
+{
+    quick_target = from->copy();
+    quick_target->init();
+    button->set_tooltip_text(quick_target->label.get_text());
+}
+
+WayfireWpMixer::~WayfireWpMixer()
+{
+    WpCommon::get().rem_widget(this);
+    gtk_widget_unparent(GTK_WIDGET(popover->gobj()));
+    popover_timeout.disconnect();
+    volume_changed_signal.disconnect();
+    left_conn.disconnect();
+    middle_conn.disconnect();
+    right_conn.disconnect();
+    scroll_conn.disconnect();
+}
diff --git a/src/panel/widgets/wp-mixer/wp-mixer.hpp b/src/panel/widgets/wp-mixer/wp-mixer.hpp
new file mode 100644
index 00000000..276bf38c
--- /dev/null
+++ b/src/panel/widgets/wp-mixer/wp-mixer.hpp
@@ -0,0 +1,87 @@
+#pragma once
+
+#include <gtkmm.h>
+#include <wp/proxy-interfaces.h>
+extern "C" {
+#include <wp/wp.h>
+}
+#include <map>
+
+#include "widget.hpp"
+#include "wf-popover.hpp"
+#include "wf-wp-control.hpp"
+#include "wp-common.hpp"
+
+enum class QuickTargetChoice // config
+{
+    LAST_CHANGE,
+    DEFAULT_SINK,
+    DEFAULT_SOURCE,
+};
+
+class WfWpControl;
+
+class WayfireWpMixer : public WayfireWidget
+{
+  private:
+    void init(Gtk::Box *container) override;
+
+    Gtk::Image main_image;
+
+    WfOption<double> timeout{"panel/wp_display_timeout"};
+    WfOption<int> icon_size{"panel/wp_icon_size"};
+
+    void on_volume_value_changed();
+    bool on_popover_timeout(int timer);
+
+    // signals and gestures for the configurable actions on click
+    gulong notify_volume_signal   = 0;
+    gulong notify_is_muted_signal = 0;
+    gulong notify_default_sink_changed = 0;
+    sigc::connection popover_timeout, volume_changed_signal, left_conn, middle_conn, right_conn, scroll_conn;
+    std::shared_ptr<Gtk::GestureClick> left_click_gesture, middle_click_gesture, right_click_gesture;
+
+    // widgets for the mixer itself
+    Gtk::Label output_label, input_label, streams_label;
+    Gtk::Separator out_in_wall, in_streams_wall, out_sep, in_sep, streams_sep;
+
+    void reload_config();
+
+  public:
+
+    WfOption<double> scroll_sensitivity{"panel/wp_scroll_sensitivity"};
+    WfOption<bool> invert_scroll{"panel/wp_invert_scroll"};
+    WfOption<bool> popup_on_change{"panel/wp_popup_on_change"};
+
+    std::unique_ptr<WayfireMenuButton> button;
+    Gtk::Popover *popover;
+
+    /*
+     * the "quick_target" is the representation of the audio channel that shows it’s volume
+     * level on the widget icon and is concerned by the quick actions.
+     * configured by panel/wp_quick_target_choice. idea: add pinning?
+     */
+    QuickTargetChoice quick_target_choice;
+    std::unique_ptr<WfWpControl> quick_target;
+    void set_quick_target_from(WfWpControl *from);
+
+    Gtk::Box master_box, sinks_box, sources_box, streams_box;
+    // idea: add a category for stuff that listens to an audio source
+
+    std::map<WpPipewireObject*, std::unique_ptr<WfWpControl>> objects_to_controls;
+
+    /** Update the icon based on volume and muted state of the quick_target widget */
+    void update_icon();
+
+    /**
+     * Check whether the popover should be auto-hidden, and if yes, start a timer to hide it
+     */
+    void check_set_popover_timeout();
+
+    // cancel popover self-hiding. mostly used after user interactions to an externally opened popover
+    void cancel_popover_timeout();
+
+    void handle_config_reload() override;
+
+    virtual ~WayfireWpMixer();
+};
diff --git a/src/util/animated-scale.cpp b/src/util/animated-scale.cpp
new file mode 100644
index 00000000..26fe5361
--- /dev/null
+++ b/src/util/animated-scale.cpp
@@ -0,0 +1,45 @@
+#include <glibmm.h>
+#include "animated-scale.hpp"
+
+WayfireAnimatedScale::WayfireAnimatedScale()
+{
+    value_changed = this->signal_value_changed().connect([=] ()
+    {
+        this->current_volume.animate(this->get_value(), this->get_value());
+        if (this->user_changed_callback)
+        {
+            this->user_changed_callback();
+        }
+    });
+}
+
+WayfireAnimatedScale::~WayfireAnimatedScale()
+{
+    value_changed.disconnect();
+}
+
+void WayfireAnimatedScale::set_target_value(double value)
+{
+    this->current_volume.animate(value);
+    add_tick_callback(sigc::mem_fun(*this, &WayfireAnimatedScale::update_animation));
+}
+
+gboolean WayfireAnimatedScale::update_animation(Glib::RefPtr<Gdk::FrameClock> frame_clock)
+{
+    value_changed.block();
+    this->set_value(this->current_volume);
+    value_changed.unblock();
+    // Once we've finished fading, stop this callback
+    return this->current_volume.running() ? G_SOURCE_CONTINUE : G_SOURCE_REMOVE;
+}
+
+double WayfireAnimatedScale::get_target_value() const
+{
+    return this->current_volume.end;
+}
+
+void WayfireAnimatedScale::set_user_changed_callback(
+    std::function<void()> callback)
+{
+    this->user_changed_callback = callback;
+}
diff --git a/src/util/animated-scale.hpp b/src/util/animated-scale.hpp
new file mode 100644
index 00000000..bdfe242a
--- /dev/null
+++ b/src/util/animated-scale.hpp
@@ -0,0 +1,32 @@
+#ifndef ANIMATED_SCALE_HPP
+#define ANIMATED_SCALE_HPP
+
+#include "wf-popover.hpp"
+#include <gtkmm/image.h>
+#include <gtkmm/scale.h>
+#include <wayfire/util/duration.hpp>
+
+/**
+ * A custom scale which animates transitions when its value is changed programatically.
+ */
+class WayfireAnimatedScale : public Gtk::Scale
+{
+    wf::animation::simple_animation_t current_volume{wf::create_option(200)};
+    sigc::connection value_changed;
+    std::function<void()> user_changed_callback;
+
+  public:
+    WayfireAnimatedScale();
+    ~WayfireAnimatedScale();
+
+    /* Gets the current target value */
+    double get_target_value() const;
+    /* Set a target value to animate towards */
+    void set_target_value(double value);
+    /** Set the callback when the user changes the scale value */
+    void set_user_changed_callback(std::function<void()> callback);
+    /** Callback to animate volume control */
+    gboolean update_animation(Glib::RefPtr<Gdk::FrameClock> clock);
+};
+
+#endif // ANIMATED_SCALE_HPP
diff --git a/src/util/meson.build b/src/util/meson.build
index cdffc3de..5621206e 100644
--- a/src/util/meson.build
+++ b/src/util/meson.build
@@ -7,6 +7,7 @@ util = static_library(
         'wf-popover.cpp',
         'css-config.cpp',
         'wf-ipc.cpp',
+        'animated-scale.cpp',
     ],
     dependencies: [wf_protos, gtklayershell, wayland_client, gtkmm, wfconfig, libinotify, json],
 )
diff --git a/wf-shell.ini.example b/wf-shell.ini.example
index 5ac56363..556e08ae 100644
--- a/wf-shell.ini.example
+++ b/wf-shell.ini.example
@@ -14,7 +14,7 @@ randomize = 0
 [panel]
 # widgets_* is a space-separated list of widgets to be displayed
 # at the corresponding part of the panel
-# Supported widgets are: launchers clock network battery window-list volume menu notifications tray command-output
+# Supported widgets are: launchers clock network battery window-list volume wp-mixer menu notifications tray command-output
 # Special widgets are "spacing" and "separator" widgets, they can be used to add padding everywhere on the panel
 # To use them, just append the amount of pixels you want as a padding
 # to the word "spacing" or "separator" and use it as a plugin
@@ -125,11 +125,61 @@ menu_min_content_height = 500
 menu_logout_command = wayland-logout
 
 
+# Note on PulseAudio (volume widet) and Wireplumber/Pipewire (mixer widget)
+# PulseAudio and Pipewire are audio servers for the desktop.
+# PulseAudio is older and was generally the default of most distributions for years.
+# Pipewire, interacted with by Wireplumber, has rapidly become the default of most major distros
+# since 2020, and has compatibility with PulseAudio with Pipewire-Pulse, usually setup by default.
+# What this ammounts to is that, if you don’t know which one you’re running,
+# the full mixer widget might not work out of the box on older systems,
+# while the volume widget is pretty much guaranteed to.
+
 # Configuration for the volume widget
-# Number of seconds volume popover will display
+# It shows a simple slider to control the volume of the default output using PulseAudio
+# Number of seconds volume popover will display (when volume is changed)
 # after scrolling on the volume icon
 volume_display_timeout = 2.5
 
+# Configuration for the wireplumber mixer widget
+# This shows an almost full-featured mixer for the audio using Pipewire/Wireplumber
+# It allows for individual control of the volume of all apps, microphones and speakers,
+# as well as muting and choosing a default device.
+# Supports scrolling and middle/right clicks with configurable actions (see below)
+
+# Which audio control will be the target of scrolling, muting... on the icon
+# Can be default_sink for default output device, default_source for default input device,
+# or last_change for whichever volume was changed last, including apps
+wp_quick_target_choice = default_sink # or default_source, or last_change
+
+# Pop up a slider when the volume of the quick target changes
+wp_popup_on_change = true
+
+# Number of seconds the popover will display atfer popping up,
+# wether due to scrolling or an external volume change
+wp_display_timeout = 2.5
+
+# Length of the volume sliders
+wp_slider_length = 300
+
+# Multiplier to the volume change when scrolling
+wp_scroll_sensitivity = 1
+
+wp_invert_scroll = false
+
+# Set to true to show icons (mute, set default) on the left
+wp_icons_on_left = false
+
+# Actions to be tied to left, right and middle click on the widget
+# Can be:
+#   - show_mixer: show the whole mixer
+#   - mute_quick_target: mute the target of quick actions
+#   - show_quick_target: show the target of quick actions
+wp_left_click_action = show_mixer # uniquely, cannot be mute
+wp_middle_click_action = mute_quick_target
+wp_right_click_action = show_quick_target
+
+# Size of the icons
+wp_icon_size = 32
 
 # Configuration for the tray widget
 # Amount of smooth scrolling needed to trigger one scroll wheel step
@@ -169,7 +219,7 @@ commands_output_max_chars = 10
 # command_output_period_1 = 1
 
 # Optionally, an icon can be displayed next to the text. Leave empty (first option) for no icon.
-# command_output_icon_1 = 
+# command_output_icon_1 =
 # command_output_icon_1 = text-x-script
 
 # Position and size for the icon, if it is not empty