diff --git a/meson.build b/meson.build
index d026d85d..0aedd442 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')
 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'))
 
@@ -33,6 +34,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..57e8c14e 100644
--- a/metadata/panel.xml
+++ b/metadata/panel.xml
@@ -249,6 +249,94 @@
 	</option>
 	</group>
 	<group>
+	<_short>Wireplumber mixer</_short>
+	<option name="wp_popup_on_change" type="bool">
+		<_short>Pop up on change</_short>
+		<_long>
+			Wether 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>
+	</option>
+	<option name="wp_scroll_sensitivity" type="double">
+		<_short>Scroll sensitivity</_short>
+		<default>1</default>
+	</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_face_choice" type="string">
+		<_short>Quick action target</_short>
+		<_long>
+			Which audio control will be the target of the "Quick action" (choice for the click action)
+		</_long>
+		<default>last_change</default>
+		<desc>
+			<value>last_change</value>
+			<_name>Last changed volume</_name>
+		</desc>
+		<desc>
+			<value>default_sink</value>
+			<_name>Default sink</_name>
+		</desc>
+		<desc>
+			<value>default_source</value>
+			<_name>Default source</_name>
+		</desc>
+	</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_face</value>
+			<_name>Show quick action target</_name>
+		</desc>
+	</option>
+	<option name="wp_middle_click_action" type="string">
+		<_short>Middle click action</_short>
+		<default>mute_face</default>
+		<desc>
+			<value>show_mixer</value>
+			<_name>Show full mixer</_name>
+		</desc>
+		<desc>
+			<value>show_face</value>
+			<_name>Show quick action target</_name>
+		</desc>
+		<desc>
+			<value>mute_face</value>
+			<_name>Mute quick action target</_name>
+		</desc>
+	</option>
+	<option name="wp_right_click_action" type="string">
+		<_short>Right click action</_short>
+		<default>show_face</default>
+		<desc>
+			<value>show_mixer</value>
+			<_name>Show full mixer</_name>
+		</desc>
+		<desc>
+			<value>show_face</value>
+			<_name>Show quick action target</_name>
+		</desc>
+		<desc>
+			<value>mute_face</value>
+			<_name>Mute quick action target</_name>
+		</desc>
+	</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 f086c614..9078c5d5 100644
--- a/src/panel/meson.build
+++ b/src/panel/meson.build
@@ -36,9 +36,14 @@ if libpulse.found()
   deps += [libpulse, libgvc]
 endif
 
+if wireplumber.found()
+  widget_sources += 'widgets/wireplumber.cpp'
+  deps += wireplumber
+endif
+
 executable(
   'wf-panel',
   ['panel.cpp'] + widget_sources,
   dependencies: deps,
   install: true,
-)
\ No newline at end of file
+)
diff --git a/src/panel/panel.cpp b/src/panel/panel.cpp
index d684d17c..86b06359 100644
--- a/src/panel/panel.cpp
+++ b/src/panel/panel.cpp
@@ -24,6 +24,9 @@
 #ifdef HAVE_PULSE
     #include "widgets/volume.hpp"
 #endif
+#ifdef HAVE_WIREPLUMBER
+    #include "widgets/wireplumber.hpp"
+#endif
 #include "widgets/window-list/window-list.hpp"
 #include "widgets/notifications/notification-center.hpp"
 #include "widgets/tray/tray.hpp"
@@ -164,6 +167,17 @@ class WayfirePanel::impl
 #endif
         }
 
+        if (name == "wireplumber")
+        {
+#ifdef HAVE_WIREPLUMBER
+            return Widget(new WayfireWireplumber());
+#else
+    #warning "Wireplumber not found, mixer widget will not be available."
+            std::cerr << "Built without wireplumber support, mixer widget "
+                         " is not available." << std::endl;
+#endif
+        }
+
         if (name == "window-list")
         {
             return Widget(new WayfireWindowList(output));
diff --git a/src/panel/widgets/volume-level.hpp b/src/panel/widgets/volume-level.hpp
new file mode 100644
index 00000000..58af1f14
--- /dev/null
+++ b/src/panel/widgets/volume-level.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+#include <map>
+
+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> 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"},
+};
diff --git a/src/panel/widgets/volume.cpp b/src/panel/widgets/volume.cpp
index d6bd8034..15b90a4f 100644
--- a/src/panel/widgets/volume.cpp
+++ b/src/panel/widgets/volume.cpp
@@ -1,56 +1,8 @@
 #include <gtkmm.h>
-#include <iostream>
 #include <glibmm.h>
 #include "volume.hpp"
-#include "launchers.hpp"
-#include "gtk-utils.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();
-        }
-    });
-}
-
-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 */
-};
+#include "volume-level.hpp"
 
 static VolumeLevel get_volume_level(pa_volume_t volume, pa_volume_t max)
 {
@@ -83,14 +35,6 @@ void WayfireVolume::update_icon()
         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));
 }
 
@@ -195,8 +139,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 39d3dd25..65730742 100644
--- a/src/panel/widgets/volume.hpp
+++ b/src/panel/widgets/volume.hpp
@@ -2,40 +2,15 @@
 #define WIDGETS_VOLUME_HPP
 
 #include "../widget.hpp"
-#include "wf-popover.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();
-
-    /* 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;
 
@@ -71,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
      */
@@ -94,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/wireplumber.cpp b/src/panel/widgets/wireplumber.cpp
new file mode 100644
index 00000000..fe6e255b
--- /dev/null
+++ b/src/panel/widgets/wireplumber.cpp
@@ -0,0 +1,980 @@
+#include <gtkmm.h>
+#include <iostream>
+#include <wp/proxy-interfaces.h>
+#include <wp/proxy.h>
+
+#include <pipewire/keys.h>
+#include <string_view>
+
+#include "volume-level.hpp"
+#include "wireplumber.hpp"
+
+namespace WpCommon
+{
+    WpCore *core = nullptr;
+    WpObjectManager *object_manager;
+    WpPlugin *mixer_api;
+    WpPlugin *default_nodes_api;
+
+    std::vector<WayfireWireplumber*> widgets;
+
+    void init_wp();
+    void catch_up_to_current_state(WayfireWireplumber *widget);
+    void on_mixer_plugin_loaded(WpCore *core, GAsyncResult *res, gpointer data);
+    void on_default_nodes_plugin_loaded(WpCore *core, GAsyncResult *res, gpointer data);
+    void on_all_plugins_loaded();
+    void on_om_installed(WpObjectManager *manager, gpointer data);
+    void add_object_to_widget(WpPipewireObject* object, WayfireWireplumber* widget);
+    void on_object_added(WpObjectManager *manager, gpointer object, gpointer data);
+    void on_mixer_changed(gpointer mixer_api, guint id, gpointer data);
+    void on_default_nodes_changed(gpointer default_nodes_api, gpointer data);
+    void on_object_removed(WpObjectManager *manager, gpointer node, gpointer data);
+}
+
+enum class FaceChoice
+{
+    LAST_CHANGE,
+    DEFAULT_SINK,
+    DEFAULT_SOURCE,
+};
+
+static const gchar *DEFAULT_NODE_MEDIA_CLASSES[] = {
+    "Audio/Sink",
+    "Audio/Source",
+};
+
+static VolumeLevel volume_icon_for(double volume)
+{
+    double max = 1.0;
+    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;
+}
+
+WfWpControl::WfWpControl(WpPipewireObject *obj, WayfireWireplumber *parent_widget)
+{
+    object = obj;
+    parent = parent_widget;
+
+    guint32 id = wp_proxy_get_bound_id(WP_PROXY(object));
+
+    scale.set_range(0.0, 1.0);
+    scale.set_target_value(0.5);
+    scale.set_size_request(300, 0);
+
+    const gchar *name;
+
+    // try to find a name to display
+    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 = wp_pipewire_object_get_property(object, PW_KEY_NODE_DESCRIPTION);
+    }
+
+    if (!name)
+    {
+        name = "Unnamed";
+    }
+
+    label.set_text(Glib::ustring(name));
+
+    button.set_child(volume_icon);
+
+    attach(label, 0, 0, 2, 1);
+    attach(button, 1, 1, 1, 1);
+    attach(scale, 0, 1, 1, 1);
+
+    mute_conn = button.signal_toggled().connect(
+        [this, id] ()
+    {
+        GVariantBuilder gvb = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE_VARDICT);
+        g_variant_builder_add(&gvb, "{sv}", "mute", g_variant_new_boolean(button.get_active()));
+        GVariant *v = g_variant_builder_end(&gvb);
+        gboolean res FALSE;
+        g_signal_emit_by_name(WpCommon::mixer_api, "set-volume", id, v, &res);
+    });
+
+    scale.set_user_changed_callback(
+        [this, id] ()
+    {
+        GVariantBuilder gvb = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE_VARDICT);
+        g_variant_builder_add(&gvb, "{sv}", "volume",
+            g_variant_new_double(std::pow(scale.get_target_value(), 3))); // see on_mixer_plugin_loaded
+        GVariant *v = g_variant_builder_end(&gvb);
+        gboolean res FALSE;
+        g_signal_emit_by_name(WpCommon::mixer_api, "set-volume", id, v, &res);
+    });
+
+    auto scroll_gesture = Gtk::EventControllerScroll::create();
+    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;
+        }
+
+        guint32 id = wp_proxy_get_bound_id(WP_PROXY(object));
+        GVariantBuilder gvb = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE_VARDICT);
+        g_variant_builder_add(&gvb, "{sv}", "volume",
+            g_variant_new_double(std::pow(get_scale_target_value() + change, 3))); // see
+                                                                                   // on_mixer_plugin_loaded
+        GVariant *v = g_variant_builder_end(&gvb);
+        gboolean res FALSE;
+        g_signal_emit_by_name(WpCommon::mixer_api, "set-volume", id, v, &res);
+        return true;
+    }, true);
+    scroll_gesture->set_flags(Gtk::EventControllerScroll::Flags::VERTICAL);
+    add_controller(scroll_gesture);
+
+    update_gestures();
+
+    // initialise the values
+    GVariant *v = NULL;
+    g_signal_emit_by_name(WpCommon::mixer_api, "get-volume", id, &v);
+    if (!v)
+    {
+        return;
+    }
+
+    gboolean mute  = FALSE;
+    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);
+    set_btn_status_no_callbk(mute);
+    set_scale_target_value(std::cbrt(volume)); // see on_mixer_plugin_loaded
+
+    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()
+{
+    VolumeLevel current = volume_icon_for(get_scale_target_value());
+
+    if (button.get_active())
+    {
+        volume_icon.set_from_icon_name("audio-volume-muted");
+        return;
+    }
+
+    volume_icon.set_from_icon_name(icon_name_from_state.at(current));
+}
+
+double WfWpControl::get_scale_target_value()
+{
+    return scale.get_target_value();
+}
+
+void WfWpControl::update_gestures()
+{
+    WfOption<std::string> str_wp_right_click_action{"panel/wp_right_click_action"};
+    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 (!gestures_initialised)
+    {
+        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);
+    } else
+    {
+        middle_conn.disconnect();
+        right_conn.disconnect();
+    }
+
+    if (str_wp_middle_click_action.value() == "mute_face")
+    {
+        middle_conn = middle_click_mute->signal_pressed().connect(mute_action);
+    }
+
+    if (str_wp_right_click_action.value() == "mute_face")
+    {
+        right_conn = right_click_mute->signal_pressed().connect(mute_action);
+    }
+}
+
+void WfWpControl::handle_config_reload()
+{
+    update_gestures();
+}
+
+std::unique_ptr<WfWpControl> WfWpControl::copy()
+{
+    return std::make_unique<WfWpControl>(object, parent);
+}
+
+WfWpControlDevice::WfWpControlDevice(WpPipewireObject *obj,
+    WayfireWireplumber *parent_widget) : WfWpControl(obj, parent_widget)
+{
+    // for devices (sinks and sources), we determine if they are the default
+
+    attach(default_btn, 1, 0, 1, 1);
+
+    WpProxy *proxy = WP_PROXY(object);
+
+    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, proxy] ()
+    {
+        // keep the button down when it is selected to prevent inconsistency of visuals with actual status
+        if (default_btn.get_active() == false)
+        {
+            set_def_status_no_callbk(true);
+            return;
+        }
+
+        const std::string_view 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++)
+        {
+            if (media_class == DEFAULT_NODE_MEDIA_CLASSES[i])
+            {
+                continue;
+            }
+
+            gboolean res = FALSE;
+            const gchar *name = wp_pipewire_object_get_property(
+                WP_PIPEWIRE_OBJECT(proxy),
+                PW_KEY_NODE_NAME);
+            if (!name)
+            {
+                continue;
+            }
+
+            g_signal_emit_by_name(WpCommon::default_nodes_api, "set-default-configured-node-name",
+                DEFAULT_NODE_MEDIA_CLASSES[i], name, &res);
+            if (!res)
+            {
+                continue;
+            }
+
+            wp_core_sync(WpCommon::core, NULL, NULL, NULL);
+        }
+    });
+}
+
+void WfWpControlDevice::set_def_status_no_callbk(bool state)
+{
+    def_conn.block(true);
+    default_btn.set_active(state);
+    def_conn.block(false);
+}
+
+std::unique_ptr<WfWpControlDevice> WfWpControlDevice::copy()
+{
+    return std::make_unique<WfWpControlDevice>(object, parent);
+}
+
+bool WayfireWireplumber::on_popover_timeout(int timer)
+{
+    popover_timeout.disconnect();
+    popover->popdown();
+    return false;
+}
+
+void WayfireWireplumber::check_set_popover_timeout()
+{
+    popover_timeout.disconnect();
+
+    popover_timeout = Glib::signal_timeout().connect(sigc::bind(sigc::mem_fun(*this,
+        &WayfireWireplumber::on_popover_timeout), 0), timeout * 1000);
+}
+
+void WayfireWireplumber::reload_config()
+{
+    WfOption<std::string> str_face_choice{"panel/wp_face_choice"};
+    WfOption<std::string> str_wp_left_click_action{"panel/wp_left_click_action"};
+    WfOption<std::string> str_wp_right_click_action{"panel/wp_right_click_action"};
+    WfOption<std::string> str_wp_middle_click_action{"panel/wp_middle_click_action"};
+
+    if (str_face_choice.value() == "last_change")
+    {
+        face_choice = FaceChoice::LAST_CHANGE;
+    } else if (str_face_choice.value() == "default_sink")
+    {
+        face_choice = FaceChoice::DEFAULT_SINK;
+        face = nullptr;
+        WpCommon::on_default_nodes_changed(WpCommon::default_nodes_api, NULL);
+    } else if (str_face_choice.value() == "default_source")
+    {
+        face_choice = FaceChoice::DEFAULT_SOURCE;
+        face = nullptr;
+        WpCommon::on_default_nodes_changed(WpCommon::default_nodes_api, NULL);
+    } else // default if no match
+    {
+        face_choice = FaceChoice::LAST_CHANGE;
+    }
+
+    // run only the first time around
+    if (!gestures_initialised)
+    {
+        gestures_initialised = true;
+        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);
+    } else
+    {
+        left_conn.disconnect();
+        middle_conn.disconnect();
+        right_conn.disconnect();
+    }
+
+    auto show_mixer_action = [&] (int c, double x, double y)
+    {
+        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_face_action = [&] (int c, double x, double y)
+    {
+        if (!face)
+        {
+            return; // no face means we have nothing to show
+        }
+
+        if ((popover->get_child() == face.get()) && popover->is_visible())
+        {
+            popover->popdown();
+            return;
+        }
+
+        if (!popover->is_visible())
+        {
+            button->set_active(true);
+        }
+
+        if (popover->get_child() != face.get())
+        {
+            popover->set_child(*face);
+            popover_timeout.disconnect();
+        }
+    };
+
+    auto mute_action = [&] (int c, double x, double y)
+    {
+        if (!face)
+        {
+            return; // no face means we have nothing to change by clicking
+        }
+
+        face->button.set_active(!face->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)
+    // this is not the prettiest, but the alternative is way worse
+    if (str_wp_left_click_action.value() == "show_mixer")
+    {
+        left_conn = left_click_gesture->signal_pressed().connect(
+            [&] (int c, double x, double y)
+        {
+            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_face")
+    {
+        left_conn = left_click_gesture->signal_pressed().connect(
+            [&] (int c, double x, double y)
+        {
+            if (!face)
+            {
+                return;
+            }
+
+            if (popover->get_child() != face.get())
+            {
+                popover->set_child(*face);
+                // 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_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_face")
+    {
+        middle_conn = middle_click_gesture->signal_pressed().connect(show_face_action);
+    }
+
+    if (str_wp_middle_click_action.value() == "mute_face")
+    {
+        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_face")
+    {
+        right_conn = right_click_gesture->signal_pressed().connect(show_face_action);
+    }
+
+    if (str_wp_right_click_action.value() == "mute_face")
+    {
+        right_conn = right_click_gesture->signal_pressed().connect(mute_action);
+    }
+}
+
+void WayfireWireplumber::handle_config_reload()
+{
+    reload_config();
+    for (auto &entry : objects_to_controls)
+    {
+        auto &control = entry.second;
+        control->handle_config_reload();
+    }
+}
+
+void WayfireWireplumber::init(Gtk::Box *container)
+{
+    // sets up the "widget part"
+
+    button = std::make_unique<WayfireMenuButton>("panel");
+    button->get_style_context()->add_class("volume");
+    button->get_style_context()->add_class("flat");
+    button->set_child(main_image);
+    button->show();
+    button->get_popover()->set_child(master_box);
+    popover = button->get_popover();
+    popover->set_autohide(false);
+
+    // scroll to change volume
+    auto scroll_gesture = Gtk::EventControllerScroll::create();
+    scroll_gesture->signal_scroll().connect([=] (double dx, double dy)
+    {
+        if (!face)
+        {
+            return false; // no face 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(face->object));
+        GVariantBuilder gvb = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE_VARDICT);
+        g_variant_builder_add(&gvb, "{sv}", "volume",
+            g_variant_new_double(std::pow(face->get_scale_target_value() + change, 3))); // see
+                                                                                         // on_mixer_plugin_loaded
+        GVariant *v = g_variant_builder_end(&gvb);
+        gboolean res FALSE;
+        g_signal_emit_by_name(WpCommon::mixer_api, "set-volume", id, v, &res);
+        return true;
+    }, true);
+    scroll_gesture->set_flags(Gtk::EventControllerScroll::Flags::VERTICAL);
+    button->add_controller(scroll_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);
+    sinks_box.set_orientation(Gtk::Orientation::VERTICAL);
+    sources_box.set_orientation(Gtk::Orientation::VERTICAL);
+    streams_box.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);
+
+    // sinks
+    sinks_box.append(output);
+    out_sep.set_orientation(Gtk::Orientation::HORIZONTAL);
+    sinks_box.append(out_sep);
+
+    // sources
+    sources_box.append(input);
+    in_sep.set_orientation(Gtk::Orientation::HORIZONTAL);
+    sources_box.append(in_sep);
+
+    // streams
+    streams_box.append(streams);
+    streams_sep.set_orientation(Gtk::Orientation::HORIZONTAL);
+    streams_box.append(streams_sep);
+
+    /* Setup popover */
+    popover->set_child(master_box);
+    popover->get_style_context()->add_class("volume-popover");
+    popover->add_controller(scroll_gesture);
+
+    /* Setup layout */
+    container->append(*button);
+    button->set_child(main_image);
+
+    /*
+     * If the core is already set, we are another widget, wether on another monitor or on the same wf-panel.
+     * We re-use the core, manager and all other objects
+     */
+
+    WpCommon::widgets.push_back(this);
+
+    if (WpCommon::core != nullptr)
+    {
+        WpCommon::catch_up_to_current_state(this);
+        return;
+    }
+
+    WpCommon::init_wp();
+}
+
+void WayfireWireplumber::update_icon()
+{
+    VolumeLevel current = volume_icon_for(face->get_scale_target_value());
+
+    if (!face || face->button.get_active())
+    {
+        main_image.set_from_icon_name("audio-volume-muted");
+        return;
+    }
+
+    main_image.set_from_icon_name(icon_name_from_state.at(current));
+}
+
+void WpCommon::init_wp()
+{
+    // 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);
+
+    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::catch_up_to_current_state(WayfireWireplumber *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::on_mixer_plugin_loaded(WpCore *core, GAsyncResult *res, void *data)
+{
+    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)
+{
+    default_nodes_api = wp_plugin_find(core, "default-nodes-api");
+
+    on_all_plugins_loaded();
+}
+
+void WpCommon::on_all_plugins_loaded()
+{
+    g_signal_connect(
+        mixer_api,
+        "changed",
+        G_CALLBACK(WpCommon::on_mixer_changed),
+        NULL);
+
+    g_signal_connect(
+        default_nodes_api,
+        "changed",
+        G_CALLBACK(WpCommon::on_default_nodes_changed),
+        NULL);
+
+    g_signal_connect(
+        object_manager,
+        "object_added",
+        G_CALLBACK(on_object_added),
+        NULL);
+
+    g_signal_connect(
+        object_manager,
+        "object-removed",
+        G_CALLBACK(on_object_removed),
+        NULL);
+
+    wp_core_install_object_manager(core, object_manager);
+}
+
+void WpCommon::add_object_to_widget(WpPipewireObject* object, WayfireWireplumber* widget){
+    // adds a new widget to the appropriate section
+
+    const std::string_view type {wp_pipewire_object_get_property(object, PW_KEY_MEDIA_CLASS)};
+
+    WfWpControl *control;
+    Gtk::Box *which_box;
+    if (type == "Audio/Sink")
+    {
+        which_box = &(widget->sinks_box);
+
+        control   = new WfWpControlDevice(object, widget);
+    } else if (type == "Audio/Source")
+    {
+        which_box = &(widget->sources_box);
+        control   = new WfWpControlDevice(object, widget);
+    } else if (type == "Stream/Output/Audio")
+    {
+        which_box = &(widget->streams_box);
+        control   = new WfWpControl(object, (WayfireWireplumber*)widget);
+    } else
+    {
+        std::cout << "Could not match pipewire object media class, ignoring\n";
+        return;
+    }
+
+    widget->objects_to_controls.insert({object, std::unique_ptr<WfWpControl>(control)});
+    which_box->append((Gtk::Widget&)*control);
+    // try to not be faceless
+    if (!widget->face)
+    {
+        widget->face = control->copy();
+    }
+}
+
+void WpCommon::on_object_added(WpObjectManager *manager, gpointer object, gpointer data)
+{
+    auto *obj = (WpPipewireObject*)object;
+
+    for (auto widget : widgets)
+    {
+        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
+
+    GVariant *v = NULL;
+    // query the new data
+    g_signal_emit_by_name(WpCommon::mixer_api, "get-volume", id, &v);
+    if (!v)
+    {
+        return;
+    }
+
+    gboolean mute  = FALSE;
+    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);
+
+    for (auto widget : widgets)
+    {
+        WfWpControl *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;
+            }
+        }
+
+        control->set_btn_status_no_callbk(mute);
+        control->set_scale_target_value(std::cbrt(volume)); // see on_mixer_plugin_loaded
+        control->update_icon();
+
+        // correct the face
+        // ensure the control in the popover is the one that was updated
+        if (
+            control->object
+            !=
+            ((WfWpControl*)(widget->popover->get_child()))->object)
+        {
+            // in the other two cases, the face choice, if existant, is already in the face
+            if (widget->face_choice == FaceChoice::LAST_CHANGE)
+            {
+                widget->face = control->copy();
+            }
+        } else
+        {
+            // update the face’s values; note the WfWpControl constructor already syncs the values
+            widget->face->set_btn_status_no_callbk(mute);
+            widget->face->set_scale_target_value(std::cbrt(volume)); // see on_mixer_plugin_loaded
+        }
+
+        widget->update_icon();
+
+        // if we have the full mixer in the popover
+        if ((Gtk::Widget*)&(widget->master_box)
+            ==
+            (Gtk::Widget*)widget->popover->get_child())
+        {
+            // if shown, stop there
+            if (widget->popover->is_visible())
+            {
+                return;
+            }
+
+            // if hidden, replace by the face
+            widget->popover->set_child(*widget->face);
+        }
+
+        // if it was hidden, show it
+        if (widget->popup_on_change && !widget->popover->is_visible())
+        {
+            widget->button->set_active(true);
+        }
+
+        // in all cases, (re-)schedule hiding
+        widget->check_set_popover_timeout();
+    }
+}
+
+void WpCommon::on_default_nodes_changed(gpointer default_nodes_api, gpointer data)
+{
+    std::vector<guint32> defaults;
+    guint32 id = SPA_ID_INVALID;
+
+    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 (auto widget : 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;
+            });
+            if (is_default)
+            {
+                ctrl->set_def_status_no_callbk(true);
+                continue;
+            }
+
+            // if the control is not for a sink or source (non WfWpControlDevice), don’t try to set status
+            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);
+            }
+
+            if ( // if the settings call for it, refresh the face
+                (
+                    (widget->face_choice == FaceChoice::DEFAULT_SINK) &&
+                     (type == "Audio/Sink")
+                    ||
+                    (widget->face_choice == FaceChoice::DEFAULT_SOURCE) &&
+                     (type == "Audio/Source")
+                )
+                &&
+                (widget->face->object == ctrl->object))
+            {
+                widget->face = ctrl->copy();
+            }
+        }
+    }
+}
+
+void WpCommon::on_object_removed(WpObjectManager *manager, gpointer object, gpointer data)
+{
+    for (auto widget : 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 face points to the removed control we should handle it.
+        if (widget->face && widget->face->object == it->first)
+        {
+            // reset face to nullptr
+            widget->face = nullptr;
+        }
+
+        widget->objects_to_controls.erase(it);
+    }
+}
+
+WayfireWireplumber::~WayfireWireplumber()
+{
+    WpCommon::widgets.erase(std::find(WpCommon::widgets.begin(), WpCommon::widgets.end(), this));
+    gtk_widget_unparent(GTK_WIDGET(popover->gobj()));
+    popover_timeout.disconnect();
+}
diff --git a/src/panel/widgets/wireplumber.hpp b/src/panel/widgets/wireplumber.hpp
new file mode 100644
index 00000000..855745b2
--- /dev/null
+++ b/src/panel/widgets/wireplumber.hpp
@@ -0,0 +1,136 @@
+#ifndef WIDGETS_PIPEWIRE_HPP
+#define WIDGETS_PIPEWIRE_HPP
+
+#include "../widget.hpp"
+#include "gtkmm/gestureclick.h"
+#include "gtkmm/togglebutton.h"
+#include "wf-popover.hpp"
+#include "wp/proxy-interfaces.h"
+#include "animated-scale.hpp"
+#include <gtkmm/image.h>
+#include <gtkmm/scale.h>
+extern "C" {
+#include <wp/wp.h>
+}
+#include <wayfire/util/duration.hpp>
+#include <map>
+
+enum class FaceChoice;
+
+class WayfireWireplumber;
+
+class WfWpControl : public Gtk::Grid
+{
+    // Custom grid to facilitate handling
+
+  protected:
+    WayfireAnimatedScale scale;
+    Gtk::Label label;
+    Gtk::Image volume_icon;
+    sigc::connection mute_conn;
+    WayfireWireplumber *parent;
+    std::shared_ptr<Gtk::GestureClick> middle_click_mute, right_click_mute;
+    sigc::connection middle_conn, right_conn;
+    bool gestures_initialised = false;
+    void update_gestures();
+
+  public:
+    WfWpControl(WpPipewireObject *obj, WayfireWireplumber *parent_widget);
+    WpPipewireObject *object;
+    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();
+
+    void handle_config_reload();
+
+    std::unique_ptr<WfWpControl> copy();
+};
+
+// todo: add a WfWpControlStream class that presents a dropdown to select which sink a stream goes to
+
+// sinks and sources
+class WfWpControlDevice : public WfWpControl
+{
+  private:
+    sigc::connection def_conn;
+    Gtk::Image is_def_icon;
+
+  public:
+    WfWpControlDevice(WpPipewireObject *obj, WayfireWireplumber *parent_widget);
+    Gtk::ToggleButton default_btn;
+    void set_def_status_no_callbk(bool state);
+    std::unique_ptr<WfWpControlDevice> copy();
+};
+
+class wayfire_config;
+class WayfireWireplumber : public WayfireWidget
+{
+  private:
+    void init(Gtk::Box *container) override;
+
+    Gtk::Image main_image;
+
+    WfOption<double> timeout{"panel/wp_display_timeout"};
+
+    void on_volume_value_changed();
+    bool on_popover_timeout(int timer);
+
+    // signals 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;
+    sigc::connection volume_changed_signal;
+
+    bool gestures_initialised = false;
+    std::shared_ptr<Gtk::GestureClick> left_click_gesture, middle_click_gesture, right_click_gesture;
+    sigc::connection left_conn, middle_conn, right_conn;
+
+    // mixer display widgets
+    Gtk::Label output, input, streams;
+    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"};
+
+    FaceChoice face_choice;
+
+    std::unique_ptr<WayfireMenuButton> button;
+    Gtk::Popover *popover;
+
+    /*
+     *   the "face" 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_face_choice. idea: add pinning?
+     */
+    std::unique_ptr<WfWpControl> face;
+
+    Gtk::Box master_box, sinks_box, sources_box, streams_box;
+    // possible: 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 face widget */
+    void update_icon();
+
+    /** Called when the volume changed from outside of the widget */
+    void on_volume_changed_external();
+
+    /**
+     * Check whether the popover should be auto-hidden, and if yes, start a timer to hide it
+     */
+    void check_set_popover_timeout();
+
+    void handle_config_reload() override;
+
+    virtual ~WayfireWireplumber();
+};
+
+#endif // WIDGETS_PIPEWIRE_HPP
diff --git a/src/util/animated-scale.cpp b/src/util/animated-scale.cpp
new file mode 100644
index 00000000..5af30d97
--- /dev/null
+++ b/src/util/animated-scale.cpp
@@ -0,0 +1,40 @@
+#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();
+        }
+    });
+}
+
+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..28a071de
--- /dev/null
+++ b/src/util/animated-scale.hpp
@@ -0,0 +1,31 @@
+#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();
+
+    /* 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 552635be..13ade7cc 100644
--- a/src/util/meson.build
+++ b/src/util/meson.build
@@ -6,6 +6,7 @@ util = static_library(
         'wf-autohide-window.cpp',
         'wf-popover.cpp',
         'css-config.cpp',
+		'animated-scale.cpp'
     ],
     dependencies: [wf_protos, wayland_client, gtkmm, wfconfig, libinotify, gtklayershell],
 )