diff --git a/metadata/dock.xml b/metadata/dock.xml
index 7343d75f..6e26638a 100644
--- a/metadata/dock.xml
+++ b/metadata/dock.xml
@@ -12,9 +12,20 @@
 		<default>true</default>
 	</option>
 	<option name="autohide_duration" type="int">
-		<_short>Autohide duration</_short>
+		<_short>Autohide animation duration</_short>
+		<_long>Time (in milliseconds) the dock takes to expand and retract</_long>
 		<default>300</default>
 	</option>
+	<option name="autohide_show_delay" type="int">
+		<_short>Autohide show delay</_short>
+		<_long>Amount of time (in milliseconds) the cursor needs to be in the zone before showing.</_long>
+		<default>300</default>
+	</option>
+	<option name="autohide_hide_delay" type="int">
+		<_short>Autohide hide delay</_short>
+		<_long>Amount of time (in milliseconds) the cursor needs to be out of the zone before hiding.</_long>
+		<default>500</default>
+	</option>
 	<option name="position" type="string">
 		<_short>Position</_short>
 		<default>bottom</default>
@@ -26,23 +37,50 @@
 			<value>bottom</value>
 			<_name>Bottom</_name>
 		</desc>
+		<desc>
+			<value>left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>right</value>
+			<_name>Right</_name>
+		</desc>
+	</option>
+	<option name="minimal_height" type="int">
+		<_short>Minimal height</_short>
+		<default>100</default>
+	</option>
+	<option name="minimal_width" type="int">
+		<_short>Minimal width</_short>
+		<default>100</default>
 	</option>
 	<option name="max_per_line" type="int">
 		<_short>Max icons per line</_short>
 		<_long>If greater than 0, the dock will have a maximum number of entries per line, after which a new line is created.</_long>
 		<default>0</default>
 	</option>
-	<option name="dock_height" type="int">
-		<_short>Dock height</_short>
-		<default>100</default>
+	<option name="full_span" type="bool">
+		<_short>Anchor to edges</_short>
+		<_long>Wether the dock should extend all the way to the left and right; or top and bottom depending on orientation.</_long>
+		<default>false</default>
 	</option>
 	<option name="icon_height" type="int">
 		<_short>Dock icons height</_short>
 		<default>72</default>
 	</option>
-	<option name="edge_offset" type="int">
-		<_short>Edge offset</_short>
-		<_long>The distance from the cursor to the edge of screen to show the panel when it's hidden.</_long>
+	<option name="edge_margin" type="int">
+		<_short>Edge margin</_short>
+		<_long>Space between the dock the edge</_long>
+		<default>0</default>
+	</option>
+	<option name="edge_hotspot_size" type="int">
+		<_short>Edge hotspot size</_short>
+		<_long>The distance to the edge of screen to place the cursor in to show the dock when it's hidden.</_long>
+		<default>20</default>
+	</option>
+	<option name="adjeacent_edge_hotspot_size" type="int">
+		<_short>Edge hotspot size</_short>
+		<_long>The distance to the edge of screen to place the cursor in to show the dock when it's hidden.</_long>
 		<default>20</default>
 	</option>
 	<option name="show_close" type="bool">
diff --git a/metadata/panel.xml b/metadata/panel.xml
index 78c52229..0adad3b9 100644
--- a/metadata/panel.xml
+++ b/metadata/panel.xml
@@ -10,7 +10,8 @@
 		<default></default>
 	</option>
 	<option name="widgets_left" type="string">
-		<_short>Widgets Left</_short>
+		<_short>Widgets Left/Top</_short>
+ 		<_long>Widgets placed in the left zone of the bar, or top if the bar is vertical.</_long>
 		<default>menu spacing4 launchers window-list</default>
 	</option>
 	<option name="widgets_center" type="string">
@@ -18,19 +19,38 @@
 		<default>none</default>
 	</option>
 	<option name="widgets_right" type="string">
-		<_short>Widgets Right</_short>
+		<_short>Widgets Right/Bottom</_short>
+		<_long>Widgets placed in the right zone of the bar, or bottom if the bar is vertical.</_long>
 		<default>volume network battery clock</default>
 	</option>
 	<option name="minimal_height" type="int">
 		<_short>Minimal Height</_short>
-		<default>32</default>
+		<default>42</default>
+ 		<_long>Minimum height the panel takes.</_long>
+	</option>
+	<option name="minimal_width" type="int">
+		<_short>Minimal Width</_short>
+ 		<_long>Minimum width the panel takes.</_long>
+		<default>42</default>
+	</option>
+	<option name="full_span" type="bool">
+		<_short>Anchor to edges</_short>
+		<_long>Wether the pannel should extend all the way to the left and right; or top and bottom depending on orientation.</_long>
+		<default>true</default>
+	</option>
+	<option name="force_center" type="bool">
+		<_short>Force center by widgets</_short>
+		<_long>If on, the widgets on the left and right of the panel always take the same amount of space and the widgets in center are forced in the middle of the screen.
+This will lead to unused space on the side that has the least space taken up by the widgets.</_long>
+		<default>false</default>
 	</option>
 	<option name="autohide" type="bool">
 		<_short>Autohide</_short>
 		<default>false</default>
 	</option>
 	<option name="autohide_duration" type="int">
-		<_short>Autohide Duration</_short>
+		<_short>Autohide animation duration</_short>
+		<_long>Time (in milliseconds) the panel takes to expand and retract</_long>
 		<default>300</default>
 	</option>
 	<option name="outputs" type="string">
@@ -38,6 +58,16 @@
 		<_long>A comma separated list of output names on which to show panel instances. Set to * wildcard for all outputs.</_long>
 		<default>*</default>
 	</option>
+	<option name="autohide_show_delay" type="int">
+		<_short>Autohide show delay</_short>
+		<_long>Amount of time (in milliseconds) the cursor needs to be in the zone before showing.</_long>
+		<default>300</default>
+	</option>
+	<option name="autohide_hide_delay" type="int">
+		<_short>Autohide hide delay</_short>
+		<_long>Amount of time (in milliseconds) the cursor needs to be out of the zone before hiding.</_long>
+		<default>500</default>
+	</option>
 	<option name="position" type="string">
 		<_short>Panel Position</_short>
 		<default>top</default>
@@ -49,10 +79,28 @@
 			<value>bottom</value>
 			<_name>Bottom</_name>
 		</desc>
+		<desc>
+			<value>left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>right</value>
+			<_name>Right</_name>
+		</desc>
 	</option>
-	<option name="edge_offset" type="int">
-		<_short>Edge offset</_short>
-		<_long>The distance from the cursor to the edge of screen to show the panel when it's hidden.</_long>
+	<option name="edge_margin" type="int">
+		<_short>Edge margin</_short>
+		<_long>Space between the panel the edge</_long>
+		<default>0</default>
+	</option>
+	<option name="edge_hotspot_size" type="int">
+		<_short>Edge hotspot size</_short>
+		<_long>The distance to the edge of screen to place the cursor in to show the panel when it's hidden.</_long>
+		<default>20</default>
+	</option>
+	<option name="adjeacent_edge_hotspot_size" type="int">
+		<_short>Edge hotspot size</_short>
+		<_long>The distance to the edge of screen to place the cursor in to show the panel when it's hidden.</_long>
 		<default>20</default>
 	</option>
 	<option name="layer" type="string">
@@ -89,7 +137,7 @@
 	</option>
 	<option name="launchers_size" type="int">
 		<_short>Launchers Icon Size</_short>
-		<default>42</default>
+		<default>0</default>
 		<min>0</min>
 	</option>
 	</group>
@@ -196,7 +244,7 @@
 	</option>
 	<option name="menu_icon_size" type="int">
 		<_short>Menu Icon Size</_short>
-		<default>42</default>
+		<default>0</default>
 		<min>0</min>
 	</option>
 	<option name="menu_min_category_width" type="int">
@@ -522,8 +570,8 @@ Set to -1 to only run it by clicking the button.
 		</desc>
 		<default>row</default>
 	</option>
-	<option name="workspace_switcher_target_height" type="double">
-		<_short>Target height for workspace switcher widget in pixels</_short>
+	<option name="workspace_switcher_target_size" type="double">
+		<_short>Target size for workspace switcher widget in pixels</_short>
 		<default>0</default>
 	</option>
 	<option name="workspace_switcher_render_views" type="bool">
diff --git a/src/dock/dock.cpp b/src/dock/dock.cpp
index 54d23899..8d4ceb8d 100644
--- a/src/dock/dock.cpp
+++ b/src/dock/dock.cpp
@@ -1,17 +1,12 @@
-#include <gtkmm/window.h>
-#include <gdkmm/frameclock.h>
-#include <glibmm/main.h>
+#include <gtkmm.h>
+#include <glibmm.h>
 #include <gdk/wayland/gdkwayland.h>
-
-#include <gtk-utils.hpp>
-#include <wf-shell-app.hpp>
 #include <gtk4-layer-shell.h>
-#include <wf-autohide-window.hpp>
 
 #include "dock.hpp"
+#include "wf-shell-app.hpp"
+#include "wf-autohide-window.hpp"
 #include "../util/gtk-utils.hpp"
-#include <css-config.hpp>
-
 
 class WfDock::impl
 {
@@ -21,8 +16,12 @@ class WfDock::impl
     Gtk::FlowBox box;
 
     WfOption<std::string> css_path{"dock/css_path"};
-    WfOption<int> dock_height{"dock/dock_height"};
     WfOption<int> entries_per_line{"dock/max_per_line"};
+    WfOption<std::string> position{"dock/position"};
+
+    // needed as a workaround to shrink down when removing items
+    WfOption<int> height{"dock/minimal_height"};
+    WfOption<int> width{"dock/minimal_width"};
 
   public:
     impl(WayfireOutput *output)
@@ -72,6 +71,31 @@ class WfDock::impl
         };
         entries_per_line.set_callback(update_entries_per_line);
         update_entries_per_line();
+
+        auto update_position = [=] ()
+        {
+            if (position.value() == "bottom")
+            {
+                // this is not great, but we lack better options without doing a
+                // layout with boxes in boxes (ugly) or some sort of custom layout manager
+                box.set_orientation(Gtk::Orientation::HORIZONTAL);
+                box.set_direction(Gtk::TextDirection::LTR);
+            } else if (position.value() == "left")
+            {
+                box.set_orientation(Gtk::Orientation::VERTICAL);
+                box.set_direction(Gtk::TextDirection::LTR);
+            } else if (position.value() == "right")
+            {
+                box.set_orientation(Gtk::Orientation::VERTICAL);
+                box.set_direction(Gtk::TextDirection::RTL);
+            } else // top
+            {
+                box.set_orientation(Gtk::Orientation::HORIZONTAL);
+                box.set_direction(Gtk::TextDirection::LTR);
+            }
+        };
+        position.set_callback(update_position);
+        update_position();
     }
 
     void add_child(Gtk::Widget& widget)
@@ -82,7 +106,7 @@ class WfDock::impl
     void rem_child(Gtk::Widget& widget)
     {
         box.remove(widget);
-        window->set_default_size(-1, dock_height);
+        window->set_default_size(width, height);
     }
 
     wl_surface *get_wl_surface()
diff --git a/src/dock/dock.hpp b/src/dock/dock.hpp
index 3ae4b1f7..59062da9 100644
--- a/src/dock/dock.hpp
+++ b/src/dock/dock.hpp
@@ -34,8 +34,7 @@ class WfDockApp : public WayfireShellApp
 
     static WfDockApp& get();
 
-    /* Starts the program. get() is valid afterward the first (and the only)
-     * call to run() */
+    /* Starts the program. get() is valid afterward the first (and the only) call to run() */
     static void create(int argc, char **argv);
     virtual ~WfDockApp();
     std::string get_application_name() override;
diff --git a/src/panel/panel.cpp b/src/panel/panel.cpp
index 04fd2fc6..33831aa0 100644
--- a/src/panel/panel.cpp
+++ b/src/panel/panel.cpp
@@ -5,15 +5,18 @@
 #include <gtkmm/application.h>
 #include <gdk/wayland/gdkwayland.h>
 #include <gtk4-layer-shell.h>
+#include <gtkmm/sizegroup.h>
+#include <gtkmm/enums.h>
 
 #include <iostream>
 #include <memory>
 #include <sstream>
 
-#include <map>
 #include <css-config.hpp>
+
 #include "panel.hpp"
 
+#include "widget.hpp"
 #include "widgets/battery.hpp"
 #include "widgets/command-output.hpp"
 #include "widgets/language.hpp"
@@ -45,6 +48,7 @@ class WayfirePanel::impl
 
     Gtk::CenterBox content_box;
     Gtk::Box left_box, center_box, right_box;
+    std::shared_ptr<Gtk::SizeGroup> sides_size_group;
 
     using Widget = std::unique_ptr<WayfireWidget>;
     using WidgetContainer = std::vector<Widget>;
@@ -52,46 +56,94 @@ class WayfirePanel::impl
 
     WayfireOutput *output;
 
+    WfOption<std::string> panel_position{"panel/position"};
+    WfOption<bool> force_center{"panel/force_center"};
+
     WfOption<std::string> panel_layer{"panel/layer"};
     std::function<void()> set_panel_layer = [=] ()
     {
-        if ((std::string)panel_layer == "overlay")
+        if (panel_layer.value() == "overlay")
         {
             gtk_layer_set_layer(window->gobj(), GTK_LAYER_SHELL_LAYER_OVERLAY);
         }
 
-        if ((std::string)panel_layer == "top")
+        if (panel_layer.value() == "top")
         {
             gtk_layer_set_layer(window->gobj(), GTK_LAYER_SHELL_LAYER_TOP);
         }
 
-        if ((std::string)panel_layer == "bottom")
+        if (panel_layer.value() == "bottom")
         {
             gtk_layer_set_layer(window->gobj(), GTK_LAYER_SHELL_LAYER_BOTTOM);
         }
 
-        if ((std::string)panel_layer == "background")
+        if (panel_layer.value() == "background")
         {
             gtk_layer_set_layer(window->gobj(), GTK_LAYER_SHELL_LAYER_BACKGROUND);
         }
     };
 
-    WfOption<int> minimal_panel_height{"panel/minimal_height"};
+    void set_boxes_orientation(Gtk::Orientation orientation)
+    {
+        content_box.set_orientation(orientation);
+        left_box.set_orientation(orientation);
+        center_box.set_orientation(orientation);
+        right_box.set_orientation(orientation);
+    }
+
+    void update_orientation()
+    {
+        bool is_horizontal = !(panel_position.value() == "left" or panel_position.value() ==
+            "right"); // checking like this also works with the fallback being the top
+
+        set_boxes_orientation(is_horizontal ? Gtk::Orientation::HORIZONTAL : Gtk::Orientation::VERTICAL);
+
+        if (force_center)
+        {
+            left_box.set_halign(Gtk::Align::CENTER);
+            right_box.set_halign(Gtk::Align::CENTER);
+            left_box.set_valign(Gtk::Align::CENTER);
+            right_box.set_valign(Gtk::Align::CENTER);
+
+            if (is_horizontal)
+            {
+                sides_size_group->set_mode(Gtk::SizeGroup::Mode::HORIZONTAL);
+            } else
+            {
+                sides_size_group->set_mode(Gtk::SizeGroup::Mode::VERTICAL);
+            }
+        } else
+        {
+            sides_size_group->set_mode(Gtk::SizeGroup::Mode::NONE);
+
+            if (is_horizontal)
+            {
+                left_box.set_halign(Gtk::Align::START);
+                right_box.set_halign(Gtk::Align::END);
+                left_box.set_valign(Gtk::Align::CENTER);
+                right_box.set_valign(Gtk::Align::CENTER);
+            } else
+            {
+                left_box.set_valign(Gtk::Align::START);
+                right_box.set_valign(Gtk::Align::END);
+                left_box.set_halign(Gtk::Align::CENTER);
+                right_box.set_halign(Gtk::Align::CENTER);
+            }
+        }
+    }
 
     void create_window()
     {
         window = std::make_unique<WayfireAutohidingWindow>(output, "panel");
 
-        window->set_default_size(0, minimal_panel_height);
         window->add_css_class("wf-panel");
         panel_layer.set_callback(set_panel_layer);
         set_panel_layer(); // initial setting
-        gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_LEFT, true);
-        gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, true);
-        gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_LEFT, 0);
-        gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, 0);
+
+        update_orientation();
 
         window->present();
+
         init_layout();
     }
 
@@ -100,6 +152,7 @@ class WayfirePanel::impl
         left_box.add_css_class("left");
         right_box.add_css_class("right");
         center_box.add_css_class("center");
+
         content_box.set_start_widget(left_box);
         if (!center_box.get_children().empty())
         {
@@ -109,10 +162,12 @@ class WayfirePanel::impl
         content_box.set_end_widget(right_box);
 
         content_box.set_hexpand(true);
+        content_box.set_vexpand(true);
 
-        left_box.set_halign(Gtk::Align::START);
         center_box.set_halign(Gtk::Align::CENTER);
-        right_box.set_halign(Gtk::Align::END);
+
+        sides_size_group->add_widget(left_box);
+        sides_size_group->add_widget(right_box);
 
         window->set_child(content_box);
     }
@@ -302,13 +357,10 @@ class WayfirePanel::impl
         }
     }
 
-    WfOption<std::string> left_widgets_opt{"panel/widgets_left"};
-    WfOption<std::string> right_widgets_opt{"panel/widgets_right"};
-    WfOption<std::string> center_widgets_opt{"panel/widgets_center"};
-
   public:
     impl(WayfireOutput *output) : output(output)
     {
+        sides_size_group = Gtk::SizeGroup::create(Gtk::SizeGroup::Mode::NONE);
         create_window();
     }
 
@@ -324,6 +376,8 @@ class WayfirePanel::impl
 
     void handle_config_reload()
     {
+        update_orientation();
+
         for (auto& w : left_widgets)
         {
             w->handle_config_reload();
@@ -346,19 +400,23 @@ class WayfirePanel::impl
         this->panel_app = panel_app;
     }
 
+    WfOption<std::string> left_widgets_opt{"panel/widgets_left"};
+    WfOption<std::string> right_widgets_opt{"panel/widgets_right"};
+    WfOption<std::string> center_widgets_opt{"panel/widgets_center"};
+
     void init_widgets()
     {
         left_widgets_opt.set_callback([=] ()
         {
-            reload_widgets((std::string)left_widgets_opt, left_widgets, left_box);
+            reload_widgets(left_widgets_opt.value(), left_widgets, left_box);
         });
         right_widgets_opt.set_callback([=] ()
         {
-            reload_widgets((std::string)right_widgets_opt, right_widgets, right_box);
+            reload_widgets(right_widgets_opt.value(), right_widgets, right_box);
         });
         center_widgets_opt.set_callback([=] ()
         {
-            reload_widgets((std::string)center_widgets_opt, center_widgets, center_box);
+            reload_widgets(center_widgets_opt.value(), center_widgets, center_box);
             if (center_box.get_children().empty())
             {
                 content_box.unset_center_widget();
diff --git a/src/panel/widget.hpp b/src/panel/widget.hpp
index 7452a901..fc8bd46f 100644
--- a/src/panel/widget.hpp
+++ b/src/panel/widget.hpp
@@ -7,8 +7,10 @@
 #define DEFAULT_PANEL_HEIGHT "48"
 #define DEFAULT_ICON_SIZE 32
 
-#define PANEL_POSITION_BOTTOM "bottom"
 #define PANEL_POSITION_TOP "top"
+#define PANEL_POSITION_BOTTOM "bottom"
+#define PANEL_POSITION_LEFT "left"
+#define PANEL_POSITION_RIGHT "right"
 
 class wayfire_config;
 class WayfireWidget
diff --git a/src/panel/widgets/battery.cpp b/src/panel/widgets/battery.cpp
index 350a93cb..9f05e25d 100644
--- a/src/panel/widgets/battery.cpp
+++ b/src/panel/widgets/battery.cpp
@@ -225,6 +225,24 @@ bool WayfireBatteryInfo::setup_dbus()
     return false;
 }
 
+void WayfireBatteryInfo::update_layout()
+{
+    WfOption<std::string> panel_position{"panel/position"};
+
+    if (panel_position.value() == PANEL_POSITION_LEFT or panel_position.value() == PANEL_POSITION_RIGHT)
+    {
+        button_box.set_orientation(Gtk::Orientation::VERTICAL);
+    } else
+    {
+        button_box.set_orientation(Gtk::Orientation::HORIZONTAL);
+    }
+}
+
+void WayfireBatteryInfo::handle_config_reload()
+{
+    update_layout();
+}
+
 // TODO: simplify config loading
 
 void WayfireBatteryInfo::init(Gtk::Box *container)
@@ -251,6 +269,8 @@ void WayfireBatteryInfo::init(Gtk::Box *container)
     button.set_child(button_box);
     button.property_scale_factor().signal_changed()
         .connect(sigc::mem_fun(*this, &WayfireBatteryInfo::update_icon));
+
+    update_layout();
 }
 
 WayfireBatteryInfo::~WayfireBatteryInfo()
diff --git a/src/panel/widgets/battery.hpp b/src/panel/widgets/battery.hpp
index bf0d883d..d7342719 100644
--- a/src/panel/widgets/battery.hpp
+++ b/src/panel/widgets/battery.hpp
@@ -44,6 +44,9 @@ class WayfireBatteryInfo : public WayfireWidget
     void update_details();
     void update_state();
 
+    void update_layout();
+    void handle_config_reload();
+
     void on_properties_changed(
         const Gio::DBus::Proxy::MapChangedProperties& properties,
         const std::vector<Glib::ustring>& invalidated);
diff --git a/src/panel/widgets/launchers.cpp b/src/panel/widgets/launchers.cpp
index d1d82566..567bbfc7 100644
--- a/src/panel/widgets/launchers.cpp
+++ b/src/panel/widgets/launchers.cpp
@@ -45,6 +45,9 @@ bool WfLauncherButton::initialize(std::string name, std::string icon, std::strin
         return false;
     }
 
+    m_icon.set_halign(Gtk::Align::CENTER);
+    m_icon.set_valign(Gtk::Align::CENTER);
+
     button.set_child(m_icon);
     button.add_css_class("widget-icon");
     button.add_css_class("flat");
@@ -151,17 +154,34 @@ void WayfireLaunchers::init(Gtk::Box *container)
 {
     box.add_css_class("widget-icon");
     box.add_css_class("launchers");
+
     container->append(box);
+
+    box.set_halign(Gtk::Align::CENTER);
+    box.set_valign(Gtk::Align::CENTER);
+
     handle_config_reload();
 }
 
 void WayfireLaunchers::update_layout()
 {
     box.set_spacing(spacing);
+
+    WfOption<std::string> panel_position{"panel/position"};
+
+    if (panel_position.value() == PANEL_POSITION_LEFT or panel_position.value() == PANEL_POSITION_RIGHT)
+    {
+        box.set_orientation(Gtk::Orientation::VERTICAL);
+    } else
+    {
+        box.set_orientation(Gtk::Orientation::HORIZONTAL);
+    }
 }
 
 void WayfireLaunchers::handle_config_reload()
 {
+    update_layout();
+
     for (auto child : box.get_children())
     {
         box.remove(*child);
diff --git a/src/panel/widgets/launchers.hpp b/src/panel/widgets/launchers.hpp
index 7f7f8b66..4a5a5d0d 100644
--- a/src/panel/widgets/launchers.hpp
+++ b/src/panel/widgets/launchers.hpp
@@ -36,6 +36,7 @@ class WayfireLaunchers : public WayfireWidget
 
   public:
     virtual void init(Gtk::Box *container);
+
     void update_layout();
     virtual void handle_config_reload();
     virtual ~WayfireLaunchers()
diff --git a/src/panel/widgets/network.cpp b/src/panel/widgets/network.cpp
index 5b9bb181..dfe8a288 100644
--- a/src/panel/widgets/network.cpp
+++ b/src/panel/widgets/network.cpp
@@ -398,9 +398,9 @@ bool WayfireNetworkInfo::setup_dbus()
 
 void WayfireNetworkInfo::on_click()
 {
-    if ((std::string)click_command_opt != "default")
+    if (click_command_opt.value() != "default")
     {
-        Glib::spawn_command_line_async((std::string)click_command_opt);
+        Glib::spawn_command_line_async(click_command_opt.value());
     } else
     {
         info->spawn_control_center(nm_proxy);
@@ -440,8 +440,23 @@ void WayfireNetworkInfo::init(Gtk::Box *container)
     handle_config_reload();
 }
 
+void WayfireNetworkInfo::update_layout()
+{
+    WfOption<std::string> panel_position{"panel/position"};
+
+    if (panel_position.value() == PANEL_POSITION_LEFT or panel_position.value() == PANEL_POSITION_RIGHT)
+    {
+        button_content.set_orientation(Gtk::Orientation::VERTICAL);
+    } else
+    {
+        button_content.set_orientation(Gtk::Orientation::HORIZONTAL);
+    }
+}
+
 void WayfireNetworkInfo::handle_config_reload()
 {
+    update_layout();
+
     if (status_opt.value() == NETWORK_STATUS_ICON)
     {
         if (status.get_parent())
diff --git a/src/panel/widgets/network.hpp b/src/panel/widgets/network.hpp
index e6ab1d90..868b9f33 100644
--- a/src/panel/widgets/network.hpp
+++ b/src/panel/widgets/network.hpp
@@ -81,6 +81,8 @@ class WayfireNetworkInfo : public WayfireWidget
     void update_status();
 
     void init(Gtk::Box *container);
+
+    void update_layout();
     void handle_config_reload();
     virtual ~WayfireNetworkInfo();
 };
diff --git a/src/panel/widgets/separator.cpp b/src/panel/widgets/separator.cpp
index 08c4eac8..f5b88295 100644
--- a/src/panel/widgets/separator.cpp
+++ b/src/panel/widgets/separator.cpp
@@ -11,4 +11,24 @@ void WayfireSeparator::init(Gtk::Box *container)
 {
     separator.add_css_class("separator");
     container->append(separator);
+
+    update_layout();
+}
+
+void WayfireSeparator::update_layout()
+{
+    WfOption<std::string> panel_position{"panel/position"};
+
+    if (panel_position.value() == PANEL_POSITION_LEFT or panel_position.value() == PANEL_POSITION_RIGHT)
+    {
+        separator.set_orientation(Gtk::Orientation::VERTICAL);
+    } else
+    {
+        separator.set_orientation(Gtk::Orientation::HORIZONTAL);
+    }
+}
+
+void WayfireSeparator::handle_config_reload()
+{
+    update_layout();
 }
diff --git a/src/panel/widgets/separator.hpp b/src/panel/widgets/separator.hpp
index bb70d3da..f21c8f94 100644
--- a/src/panel/widgets/separator.hpp
+++ b/src/panel/widgets/separator.hpp
@@ -11,6 +11,10 @@ class WayfireSeparator : public WayfireWidget
     WayfireSeparator(int pixels);
 
     virtual void init(Gtk::Box *container);
+
+    void update_layout();
+    void handle_config_reload();
+
     virtual ~WayfireSeparator()
     {}
 };
diff --git a/src/panel/widgets/tray/tray.cpp b/src/panel/widgets/tray/tray.cpp
index 0e7062e4..9ea0c419 100644
--- a/src/panel/widgets/tray/tray.cpp
+++ b/src/panel/widgets/tray/tray.cpp
@@ -36,6 +36,16 @@ void WayfireStatusNotifier::remove_item(const Glib::ustring & service)
 void WayfireStatusNotifier::update_layout()
 {
     icons_box.set_spacing(spacing);
+    
+    WfOption<std::string> panel_position{"panel/position"};
+
+    if ((panel_position.value() == PANEL_POSITION_LEFT) || (panel_position.value() == PANEL_POSITION_RIGHT))
+    {
+        icons_box.set_orientation(Gtk::Orientation::VERTICAL);
+    } else
+    {
+        icons_box.set_orientation(Gtk::Orientation::HORIZONTAL);
+    }
 }
 
 void WayfireStatusNotifier::handle_config_reload()
diff --git a/src/panel/widgets/volume.hpp b/src/panel/widgets/volume.hpp
index dc5a6d18..ffc09f04 100644
--- a/src/panel/widgets/volume.hpp
+++ b/src/panel/widgets/volume.hpp
@@ -1,10 +1,9 @@
 #pragma once
 
 #include "../widget.hpp"
-#include "wf-popover.hpp"
-#include <gtkmm/button.h>
 #include <gtkmm/image.h>
 #include "../../util/animated-scale.hpp"
+
 #include <pulse/pulseaudio.h>
 #include <gvc-mixer-control.h>
 #include <wayfire/util/duration.hpp>
diff --git a/src/panel/widgets/workspace-switcher.cpp b/src/panel/widgets/workspace-switcher.cpp
index f91dca61..0071061f 100644
--- a/src/panel/widgets/workspace-switcher.cpp
+++ b/src/panel/widgets/workspace-switcher.cpp
@@ -33,7 +33,7 @@ void WayfireWorkspaceSwitcher::init(Gtk::Box *container)
     ipc_client->subscribe(this, {"output-layout-changed"});
     ipc_client->subscribe(this, {"wset-workspace-changed"});
 
-    workspace_switcher_target_height_opt.set_callback([=] () {set_height();});
+    workspace_switcher_target_size_opt.set_callback([=] () {set_size();});
 
     auto mode_cb = ([=] ()
     {
@@ -71,20 +71,27 @@ void WayfireWorkspaceSwitcher::init(Gtk::Box *container)
     mode_cb();
 }
 
-void WayfireWorkspaceSwitcher::set_height()
+void WayfireWorkspaceSwitcher::set_size()
 {
-    double val = workspace_switcher_target_height_opt.value();
+    double val = workspace_switcher_target_size_opt.value();
     if (val == 0.0)
     {
         val = (double)WfOption<int>{"panel/minimal_height"}.value();
     }
 
-    if (workspace_switcher_mode.value() == "grid")
+    if (workspace_switcher_mode.value() == "row")
+    {
+        WfOption<std::string> panel_position{"panel/position"};
+        if (panel_position.value() == PANEL_POSITION_LEFT or panel_position.value() == PANEL_POSITION_RIGHT)
+        {
+            val = val / grid_width;
+        }
+    } else if (workspace_switcher_mode.value() == "grid")
     {
         val = val / grid_height;
     }
 
-    workspace_switcher_target_height = val;
+    workspace_switcher_target_size = val;
 }
 
 void WayfireWorkspaceSwitcher::get_wsets()
@@ -106,7 +113,7 @@ void WayfireWorkspaceSwitcher::get_wsets()
             grid_process_workspaces(data);
         }
 
-        set_height();
+        set_size();
     });
 }
 
@@ -142,8 +149,9 @@ std::pair<int, int> WayfireWorkspaceSwitcher::get_workspace(WayfireWorkspaceBox
     WayfireWorkspaceWindow *w)
 {
     std::pair<int, int> workspace;
-    double scaled_output_width  = ws->get_scaled_width();
-    double scaled_output_height = workspace_switcher_target_height;
+    auto size = ws->get_scaled_size();
+    double scaled_output_width  = size.first;
+    double scaled_output_height = size.second;
     workspace.first  = std::floor((w->x + (w->w / 2)) / scaled_output_width) + this->current_ws_x;
     workspace.second = std::floor((w->y + (w->h / 2)) / scaled_output_height) + this->current_ws_y;
     return workspace;
@@ -152,8 +160,9 @@ std::pair<int, int> WayfireWorkspaceSwitcher::get_workspace(WayfireWorkspaceBox
 std::pair<int, int> WayfireWorkspaceSwitcher::grid_get_workspace(WayfireWorkspaceWindow *w)
 {
     std::pair<int, int> workspace;
-    double scaled_output_width  = this->get_scaled_width();
-    double scaled_output_height = workspace_switcher_target_height;
+    auto size = this->get_scaled_size();
+    double scaled_output_width  = size.first;
+    double scaled_output_height = size.second;
     workspace.first  = std::floor((w->x + (w->w / 2)) / scaled_output_width) + this->current_ws_x;
     workspace.second = std::floor((w->y + (w->h / 2)) / scaled_output_height) + this->current_ws_y;
     return workspace;
@@ -177,8 +186,9 @@ bool WayfireWorkspaceSwitcher::on_grid_get_child_position(Gtk::Widget *widget, G
 {
     if (auto w = static_cast<WayfireWorkspaceWindow*>(widget))
     {
-        allocation.set_x(w->x + this->current_ws_x * this->get_scaled_width());
-        allocation.set_y(w->y + this->current_ws_y * this->workspace_switcher_target_height);
+        auto size = this->get_scaled_size();
+        allocation.set_x(w->x + this->current_ws_x * size.first);
+        allocation.set_y(w->y + this->current_ws_y * size.second);
         allocation.set_width(w->w);
         allocation.set_height(w->h);
         return true;
@@ -251,16 +261,28 @@ void WayfireWorkspaceBox::on_workspace_clicked(int count, double x, double y)
     }
 }
 
-double WayfireWorkspaceSwitcher::get_scaled_width()
+std::pair<double, double> WayfireWorkspaceSwitcher::get_scaled_size()
 {
-    return this->workspace_switcher_target_height *
-           (this->output_width / float(this->output_height));
+    WfOption<std::string> panel_position{"panel/position"};
+
+    if (panel_position.value() == PANEL_POSITION_LEFT or panel_position.value() == PANEL_POSITION_RIGHT)
+    {
+        return {
+            workspace_switcher_target_size,
+            (workspace_switcher_target_size * this->output_height / float(this->output_width))
+        };
+    } else
+    {
+        return {
+            (workspace_switcher_target_size * this->output_width / float(this->output_height)),
+            workspace_switcher_target_size
+        };
+    }
 }
 
-int WayfireWorkspaceBox::get_scaled_width()
+std::pair<int, int> WayfireWorkspaceBox::get_scaled_size()
 {
-    return this->switcher->workspace_switcher_target_height *
-           (this->output_width / float(this->output_height));
+    return this->switcher->get_scaled_size();
 }
 
 bool WayfireWorkspaceBox::on_workspace_scrolled(double x, double y)
@@ -347,7 +369,8 @@ void WayfireWorkspaceSwitcher::render_workspace(wf::json_t workspace, int j, int
         false);
     ws->set_hexpand(false);
     ws->set_vexpand(false);
-    ws->set_size_request(ws->get_scaled_width(), workspace_switcher_target_height);
+    auto size = get_scaled_size();
+    ws->set_size_request(size.first, size.second);
     ws->add_controller(click_gesture);
     ws->add_controller(scroll_controller);
     box.append(*ws);
@@ -464,8 +487,9 @@ void WayfireWorkspaceSwitcher::grid_process_workspaces(wf::json_t workspace_data
                         auto ws = Gtk::make_managed<WayfireWorkspaceBox>(this);
                         ws->output_id = output_data["id"].as_int();
                         ws->set_can_target(false);
-                        auto ws_width  = this->get_scaled_width() / this->grid_width;
-                        auto ws_height = this->workspace_switcher_target_height / this->grid_height;
+                        auto size     = this->get_scaled_size();
+                        auto ws_width = size.first / this->grid_width;
+                        auto ws_height = size.second / this->grid_height;
                         ws->set_size_request(ws_width, ws_height);
                         ws->add_css_class("workspace");
                         if ((workspace_data[i]["workspace"]["x"].as_int() == k) &&
@@ -485,8 +509,7 @@ void WayfireWorkspaceSwitcher::grid_process_workspaces(wf::json_t workspace_data
 
                         ws = Gtk::make_managed<WayfireWorkspaceBox>(this);
                         ws->output_id = output_data["id"].as_int();
-                        ws->set_size_request(
-                            this->get_scaled_width(), this->workspace_switcher_target_height);
+                        ws->set_size_request(size.first, size.second);
                         ws->add_css_class("workspace");
                         if ((workspace_data[i]["workspace"]["x"].as_int() == k) &&
                             (workspace_data[i]["workspace"]["y"].as_int() == j))
@@ -579,8 +602,9 @@ void WayfireWorkspaceSwitcher::add_view(wf::json_t view_data)
             }
         }
 
-        double width  = ws->get_scaled_width();
-        double height = workspace_switcher_target_height;
+        auto size     = ws->get_scaled_size();
+        double width  = size.first;
+        double height = size.second;
 
         v->x = x * (width / float(ws->output_width));
         v->y = y * (height / float(ws->output_height));
@@ -648,8 +672,9 @@ void WayfireWorkspaceSwitcher::grid_add_view(wf::json_t view_data)
             return;
         }
 
-        double width  = this->get_scaled_width();
-        double height = workspace_switcher_target_height;
+        auto size     = this->get_scaled_size();
+        double width  = size.first;
+        double height = size.second;
 
         v->x = x * (width / float(this->output_width));
         v->y = y * (height / float(this->output_height));
diff --git a/src/panel/widgets/workspace-switcher.hpp b/src/panel/widgets/workspace-switcher.hpp
index be5ed99d..617857f2 100644
--- a/src/panel/widgets/workspace-switcher.hpp
+++ b/src/panel/widgets/workspace-switcher.hpp
@@ -24,7 +24,7 @@ class WayfireWorkspaceWindow : public Gtk::Widget
 class WayfireWorkspaceSwitcher : public WayfireWidget, public IIPCSubscriber
 {
     std::string output_name;
-    void set_height();
+    void set_size();
     void on_event(wf::json_t data) override;
     void switcher_on_event(wf::json_t data);
     void grid_on_event(wf::json_t data);
@@ -50,7 +50,7 @@ class WayfireWorkspaceSwitcher : public WayfireWidget, public IIPCSubscriber
     Gtk::Box switcher_box;
     Gtk::Grid switch_grid;
     Gtk::Overlay overlay;
-    double get_scaled_width();
+    std::pair<double, double> get_scaled_size();
     std::unique_ptr<WayfireMenuButton> button;
     int output_width, output_height;
     void init(Gtk::Box *container) override;
@@ -64,8 +64,8 @@ class WayfireWorkspaceSwitcher : public WayfireWidget, public IIPCSubscriber
     int current_ws_x, current_ws_y;
     std::vector<WayfireWorkspaceWindow*> windows;
     WfOption<std::string> workspace_switcher_mode{"panel/workspace_switcher_mode"};
-    WfOption<double> workspace_switcher_target_height_opt{"panel/workspace_switcher_target_height"};
-    double workspace_switcher_target_height;
+    WfOption<double> workspace_switcher_target_size_opt{"panel/workspace_switcher_target_size"};
+    double workspace_switcher_target_size;
     WfOption<bool> workspace_switcher_render_views{"panel/workspace_switcher_render_views"};
 };
 
@@ -76,7 +76,7 @@ class WayfireWorkspaceBox : public Gtk::Overlay
   public:
     int x_index, y_index;
     int output_id, output_width, output_height;
-    int get_scaled_width();
+    std::pair<int, int> get_scaled_size();
     WayfireWorkspaceBox(WayfireWorkspaceSwitcher *switcher)
     {
         this->switcher = switcher;
diff --git a/src/util/icon-select.cpp b/src/util/icon-select.cpp
index 678354a6..5308ec37 100644
--- a/src/util/icon-select.cpp
+++ b/src/util/icon-select.cpp
@@ -1,12 +1,28 @@
+#include <gdkmm/display.h>
+#include <gtkmm/icontheme.h>
+
 #include "icon-select.hpp"
 
-std::string icon_from_range(std::map<double, std::string> icons, double value)
+std::string icon_from_range(std::map<double, std::vector<std::string>> icons, double value)
 {
+
     for (auto pair : icons)
     {
         if (value <= pair.first)
         {
-            return pair.second;
+            auto theme = Gtk::IconTheme::get_for_display(Gdk::Display::get_default());
+            if (!theme)
+            { // let’s stick to standard icons in this case
+                return *pair.second.end();
+            }
+
+            for (auto name : pair.second)
+            {
+                if (theme->has_icon(name))
+                {
+                    return name;
+                }
+            }
         }
     }
 
diff --git a/src/util/icon-select.hpp b/src/util/icon-select.hpp
index 88f46f91..6473f8ce 100644
--- a/src/util/icon-select.hpp
+++ b/src/util/icon-select.hpp
@@ -1,17 +1,21 @@
 #include <map>
+#include <vector>
 #include <string>
 #include <limits>
 
-std::string icon_from_range(std::map<double, std::string> icons, double value);
+std::string icon_from_range(std::map<double, std::vector<std::string>> icons, double value);
 
 // the number in the first term is the maximal value at which this icon will be shown
 // selection values of the tables are expected to be ordered from least to greatest
+// the vector of icons is the different possibilites of icons to show,
+// with the prefered one as the first. This is to be able to use non-standard icons
+// if they are present in the current theme, and fall back to a standard one if not.
 
-const std::map<double, std::string> volume_icons = {
-    {std::numeric_limits<double>::min(), "emblem-unreadable"},
-    {0.0, "audio-volume-muted"},
-    {0.33, "audio-volume-low"},
-    {0.66, "audio-volume-medium"},
-    {1.0, "audio-volume-high"},
-    {std::numeric_limits<double>::max(), "dialog-warning"}
+const std::map<double, std::vector<std::string>> volume_icons = {
+    {std::numeric_limits<double>::min(), {"emblem-unreadable"}},
+    {0.0, {"audio-volume-muted"}},
+    {0.33, {"audio-volume-low"}},
+    {0.66, {"audio-volume-medium"}},
+    {1.0, {"audio-volume-high"}},
+    {std::numeric_limits<double>::max(), {"audio-volume-high-danger", "dialog-warning"}}
 };
diff --git a/src/util/wf-autohide-window.cpp b/src/util/wf-autohide-window.cpp
index 541ae4ad..1dfa20cf 100644
--- a/src/util/wf-autohide-window.cpp
+++ b/src/util/wf-autohide-window.cpp
@@ -10,15 +10,19 @@
 #include <iostream>
 #include <assert.h>
 
-#define AUTOHIDE_SHOW_DELAY 300
-#define AUTOHIDE_HIDE_DELAY 500
-
 WayfireAutohidingWindow::WayfireAutohidingWindow(WayfireOutput *output,
     const std::string& section) :
     position{section + "/position"},
-    y_position{WfOption<int>{section + "/autohide_duration"}},
-    edge_offset{section + "/edge_offset"},
-    autohide_opt{section + "/autohide"}
+    full_span{section + "/full_span"},
+    autohide_animation{WfOption<int>{section + "/autohide_duration"}},
+    autohide_opt{section + "/autohide"},
+    autohide_show_delay{section + "/autohide_show_delay"},
+    autohide_hide_delay{section + "/autohide_hide_delay"},
+    edge_margin{section + "/edge_margin"},
+    edge_hotspot_size{section + "/edge_hotspot_size"},
+    adjeacent_edge_hotspot_size{section + "/adjeacent_edge_hotspot_size"},
+    minimal_height{section + "/minimal_height"},
+    minimal_width{section + "/minimal_width"}
 {
     this->output = output;
     this->set_decorated(false);
@@ -27,11 +31,19 @@ WayfireAutohidingWindow::WayfireAutohidingWindow(WayfireOutput *output,
     gtk_layer_set_monitor(this->gobj(), output->monitor->gobj());
     gtk_layer_set_namespace(this->gobj(), "panel");
 
+
     this->position.set_callback([=] () { this->update_position(); });
+    this->full_span.set_callback([=] () { this->update_position(); });
+    edge_margin.set_callback([=] () { update_position(); });
     this->update_position();
 
+    const auto set_size = [=] () { this->set_default_size(minimal_width, minimal_height); };
+    this->minimal_height.set_callback(set_size);
+    this->minimal_width.set_callback(set_size);
+    set_size();
+
     auto pointer_gesture = Gtk::EventControllerMotion::create();
-    pointer_gesture->signal_enter().connect([=] (double x, double y)
+    signals.push_back(pointer_gesture->signal_enter().connect([=] (double x, double y)
     {
         if (this->pending_hide.connected())
         {
@@ -39,25 +51,35 @@ WayfireAutohidingWindow::WayfireAutohidingWindow(WayfireOutput *output,
         }
 
         this->input_inside_panel = true;
-        y_position.animate(0);
+        autohide_animation.animate(0);
         start_draw_timer();
-    });
-    pointer_gesture->signal_leave().connect([=]
+    }));
+    signals.push_back(pointer_gesture->signal_leave().connect([=]
     {
         this->input_inside_panel = false;
         if (this->should_autohide())
         {
-            this->schedule_hide(AUTOHIDE_HIDE_DELAY);
+            this->schedule_hide(autohide_hide_delay);
         }
-    });
+    }));
     this->add_controller(pointer_gesture);
 
     this->setup_autohide();
 
-    this->edge_offset.set_callback([=] () { this->setup_hotspot(); });
+    this->edge_hotspot_size.set_callback([=] () { this->setup_hotspot(); });
 
     this->autohide_opt.set_callback([=] { setup_autohide(); });
 
+    auto display  = Gdk::Display::get_default();
+    auto monitors = display->get_monitors();
+    signals.push_back(monitors->signal_items_changed().connect([=] (auto, auto, auto)
+    {
+        reinit_ext_hotspots();
+    }));
+
+    // wait for idle, so once everything is initialised. Else, things depend on loading order.
+    Glib::signal_idle().connect_once([=] () { this->reinit_ext_hotspots(); });
+
     if (!output->output)
     {
         std::cerr << "WARNING: Compositor does not support zwf_shell_manager_v2 " << \
@@ -90,6 +112,16 @@ WayfireAutohidingWindow::~WayfireAutohidingWindow()
     {
         zwf_hotspot_v2_destroy(this->panel_hotspot);
     }
+
+    for (auto adjeacent_edge_hotspot : adjeacent_edges_hotspots)
+    {
+        zwf_hotspot_v2_destroy(adjeacent_edge_hotspot);
+    }
+
+    for (auto handler : signals)
+    {
+        handler.disconnect();
+    }
 }
 
 wl_surface*WayfireAutohidingWindow::get_wl_surface() const
@@ -111,6 +143,16 @@ static std::string check_position(std::string position)
         return WF_WINDOW_POSITION_BOTTOM;
     }
 
+    if (position == WF_WINDOW_POSITION_LEFT)
+    {
+        return WF_WINDOW_POSITION_LEFT;
+    }
+
+    if (position == WF_WINDOW_POSITION_RIGHT)
+    {
+        return WF_WINDOW_POSITION_RIGHT;
+    }
+
     std::cerr << "Bad position in config file, defaulting to top" << std::endl;
     return WF_WINDOW_POSITION_TOP;
 }
@@ -128,6 +170,16 @@ static GtkLayerShellEdge get_anchor_edge(std::string position)
         return GTK_LAYER_SHELL_EDGE_BOTTOM;
     }
 
+    if (position == WF_WINDOW_POSITION_LEFT)
+    {
+        return GTK_LAYER_SHELL_EDGE_LEFT;
+    }
+
+    if (position == WF_WINDOW_POSITION_RIGHT)
+    {
+        return GTK_LAYER_SHELL_EDGE_RIGHT;
+    }
+
     assert(false); // not reached because check_position()
 }
 
@@ -141,7 +193,7 @@ void WayfireAutohidingWindow::m_show_uncertain()
         {
             schedule_hide(0);
             return false;
-        }, AUTOHIDE_HIDE_DELAY);
+        }, autohide_hide_delay);
     }
 }
 
@@ -150,18 +202,43 @@ void WayfireAutohidingWindow::update_position()
     /* Reset old anchors */
     gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_TOP, false);
     gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, false);
+    gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_LEFT, false);
+    gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, false);
 
     /* Set new anchor */
-    GtkLayerShellEdge anchor = get_anchor_edge(position);
-    gtk_layer_set_anchor(this->gobj(), anchor, true);
+    GtkLayerShellEdge edge = get_anchor_edge(position);
+    gtk_layer_set_anchor(this->gobj(), edge, true);
+    gtk_layer_set_margin(this->gobj(), edge, edge_margin);
+
+    if (full_span)
+    {
+        if ((edge == GTK_LAYER_SHELL_EDGE_TOP) || (edge == GTK_LAYER_SHELL_EDGE_BOTTOM))
+        {
+            gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_LEFT, true);
+            gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, true);
+        } else if ((edge == GTK_LAYER_SHELL_EDGE_LEFT) || (edge == GTK_LAYER_SHELL_EDGE_RIGHT))
+        {
+            gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_TOP, true);
+            gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, true);
+        }
+    }
 
     if (!output->output)
     {
         return;
     }
 
+    // need different measurements depending on position
+    if ((edge == GTK_LAYER_SHELL_EDGE_LEFT) || (edge == GTK_LAYER_SHELL_EDGE_RIGHT))
+    {
+        get_allocated_height_or_width = &Gtk::Widget::get_allocated_width;
+    } else
+    {
+        get_allocated_height_or_width = &Gtk::Widget::get_allocated_height;
+    }
+
     /* When the position changes, show an animation from the new edge. */
-    y_position.animate(-this->get_allocated_height(), 0);
+    autohide_animation.animate(-(this->*get_allocated_height_or_width)(), 0);
     start_draw_timer();
     m_show_uncertain();
     setup_hotspot();
@@ -190,6 +267,100 @@ static zwf_hotspot_v2_listener hotspot_listener = {
     .leave = handle_hotspot_leave,
 };
 
+void WayfireAutohidingWindow::reinit_ext_hotspots()
+{
+    for (auto adjeacent_edge_hotspot : adjeacent_edges_hotspots)
+    {
+        zwf_hotspot_v2_destroy(adjeacent_edge_hotspot);
+    }
+
+    uint32_t adjeacent_edge;
+    auto position = check_position(this->position);
+    if (position == WF_WINDOW_POSITION_TOP)
+    {
+        adjeacent_edge = ZWF_OUTPUT_V2_HOTSPOT_EDGE_BOTTOM;
+    } else if (position == WF_WINDOW_POSITION_BOTTOM)
+    {
+        adjeacent_edge = ZWF_OUTPUT_V2_HOTSPOT_EDGE_TOP;
+    } else if (position == WF_WINDOW_POSITION_LEFT)
+    {
+        adjeacent_edge = ZWF_OUTPUT_V2_HOTSPOT_EDGE_RIGHT;
+    } else if (position == WF_WINDOW_POSITION_RIGHT)
+    {
+        adjeacent_edge = ZWF_OUTPUT_V2_HOTSPOT_EDGE_LEFT;
+    }
+
+    Gdk::Rectangle geom_this;
+    this->output->monitor->get_geometry(geom_this);
+    auto pos = check_position(this->position);
+
+    std::map<WayfireOutput*, zwf_output_v2_hotspot_edge> wo_edg;
+
+    for (auto& wo : *WayfireShellApp::get().get_wayfire_outputs())
+    {
+        if (wo.get() == this->output)
+        {
+            continue;
+        }
+
+        if (!wo->output)
+        {
+            continue;
+        }
+
+        Gdk::Rectangle other_geo;
+        wo->monitor->get_geometry(other_geo);
+
+        if (pos == WF_WINDOW_POSITION_TOP)
+        {
+            if (other_geo.get_y() + other_geo.get_height() == geom_this.get_y())
+            {
+                wo_edg[wo.get()] = ZWF_OUTPUT_V2_HOTSPOT_EDGE_BOTTOM;
+            }
+        } else if (pos == WF_WINDOW_POSITION_BOTTOM)
+        {
+            if (other_geo.get_y() == geom_this.get_y() + geom_this.get_height())
+            {
+                wo_edg[wo.get()] = ZWF_OUTPUT_V2_HOTSPOT_EDGE_TOP;
+            }
+        } else if (pos == WF_WINDOW_POSITION_LEFT)
+        {
+            if (other_geo.get_x() + other_geo.get_width() == geom_this.get_x())
+            {
+                wo_edg[wo.get()] = ZWF_OUTPUT_V2_HOTSPOT_EDGE_RIGHT;
+            }
+        } else if (pos == WF_WINDOW_POSITION_RIGHT)
+        {
+            if (other_geo.get_x() == geom_this.get_x() + geom_this.get_width())
+            {
+                wo_edg[wo.get()] = ZWF_OUTPUT_V2_HOTSPOT_EDGE_LEFT;
+            }
+        }
+    }
+
+    for (auto pair : wo_edg)
+    {
+        adjeacent_edges_hotspots.push_back(zwf_output_v2_create_hotspot(pair.first->output,
+            adjeacent_edge, adjeacent_edge_hotspot_size, autohide_show_delay));
+    }
+
+    adjeacent_edge_callbacks->on_enter = [=] ()
+    {
+        schedule_show(0);
+    };
+
+    adjeacent_edge_callbacks->on_leave = [=] ()
+    {
+        m_do_hide();
+    };
+
+    for (auto ad_ed_ht : adjeacent_edges_hotspots)
+    {
+        zwf_hotspot_v2_add_listener(ad_ed_ht, &hotspot_listener,
+            adjeacent_edge_callbacks.get());
+    }
+}
+
 /**
  * An autohide window needs 2 hotspots.
  * One of them is used to trigger autohide and is generally a tiny strip on the
@@ -197,19 +368,13 @@ static zwf_hotspot_v2_listener hotspot_listener = {
  *
  * The other hotspot covers the whole window. It is used primarily to know when
  * the input leaves the window, in which case we need to hide the window again.
+ *
+ * A last one is optional and is placed as a mirror of the first one on an
+ * adjeacent monitor, and serves to have more room to pop out the window
  */
 
 void WayfireAutohidingWindow::setup_hotspot()
 {
-    /* No need to recreate hotspots if the height didn't change */
-    if ((this->get_allocated_height() == last_hotspot_height) && (edge_offset == last_edge_offset))
-    {
-        return;
-    }
-
-    this->last_hotspot_height = get_allocated_height();
-    this->last_edge_offset    = edge_offset;
-
     if (this->edge_hotspot)
     {
         zwf_hotspot_v2_destroy(edge_hotspot);
@@ -220,18 +385,32 @@ void WayfireAutohidingWindow::setup_hotspot()
         zwf_hotspot_v2_destroy(panel_hotspot);
     }
 
+    uint32_t edge;
     auto position = check_position(this->position);
-    uint32_t edge = (position == WF_WINDOW_POSITION_TOP) ?
-        ZWF_OUTPUT_V2_HOTSPOT_EDGE_TOP : ZWF_OUTPUT_V2_HOTSPOT_EDGE_BOTTOM;
+    if (position == WF_WINDOW_POSITION_TOP)
+    {
+        edge = ZWF_OUTPUT_V2_HOTSPOT_EDGE_TOP;
+    } else if (position == WF_WINDOW_POSITION_BOTTOM)
+    {
+        edge = ZWF_OUTPUT_V2_HOTSPOT_EDGE_BOTTOM;
+    } else if (position == WF_WINDOW_POSITION_LEFT)
+    {
+        edge = ZWF_OUTPUT_V2_HOTSPOT_EDGE_LEFT;
+    } else if (position == WF_WINDOW_POSITION_RIGHT)
+    {
+        edge = ZWF_OUTPUT_V2_HOTSPOT_EDGE_RIGHT;
+    }
 
     this->edge_hotspot = zwf_output_v2_create_hotspot(output->output,
-        edge, edge_offset, AUTOHIDE_SHOW_DELAY);
+        edge, edge_hotspot_size, autohide_show_delay);
 
     this->panel_hotspot = zwf_output_v2_create_hotspot(output->output,
-        edge, this->get_allocated_height(), 0); // immediate
+        edge, (this->*get_allocated_height_or_width)(), 0); // immediate
 
     this->edge_callbacks =
         std::make_unique<WayfireAutohidingWindowHotspotCallbacks>();
+    this->adjeacent_edge_callbacks =
+        std::make_unique<WayfireAutohidingWindowHotspotCallbacks>();
     this->panel_callbacks =
         std::make_unique<WayfireAutohidingWindowHotspotCallbacks>();
 
@@ -261,12 +440,13 @@ void WayfireAutohidingWindow::setup_hotspot()
         this->input_inside_panel = false;
         if (this->should_autohide())
         {
-            this->schedule_hide(AUTOHIDE_HIDE_DELAY);
+            this->schedule_hide(autohide_hide_delay);
         }
     };
 
     zwf_hotspot_v2_add_listener(edge_hotspot, &hotspot_listener,
         edge_callbacks.get());
+
     zwf_hotspot_v2_add_listener(panel_hotspot, &hotspot_listener,
         panel_callbacks.get());
 }
@@ -330,7 +510,7 @@ bool WayfireAutohidingWindow::should_autohide() const
 
 bool WayfireAutohidingWindow::m_do_hide()
 {
-    y_position.animate(-get_allocated_height());
+    autohide_animation.animate(-((this->*get_allocated_height_or_width)() + edge_margin));
     start_draw_timer();
     update_margin();
     return false; // disconnect
@@ -346,7 +526,7 @@ gboolean WayfireAutohidingWindow::update_animation(Glib::RefPtr<Gdk::FrameClock>
     update_margin();
     // this->queue_draw();
     // Once we've finished fading, stop this callback
-    return y_position.running() ? G_SOURCE_CONTINUE : G_SOURCE_REMOVE;
+    return autohide_animation.running() ? G_SOURCE_CONTINUE : G_SOURCE_REMOVE;
 }
 
 void WayfireAutohidingWindow::schedule_hide(int delay)
@@ -367,7 +547,7 @@ void WayfireAutohidingWindow::schedule_hide(int delay)
 
 bool WayfireAutohidingWindow::m_do_show()
 {
-    y_position.animate(0);
+    autohide_animation.animate(0);
     start_draw_timer();
     update_margin();
     return false; // disconnect
@@ -391,10 +571,10 @@ void WayfireAutohidingWindow::schedule_show(int delay)
 
 bool WayfireAutohidingWindow::update_margin()
 {
-    if (y_position.running())
+    if (autohide_animation.running())
     {
         gtk_layer_set_margin(this->gobj(),
-            get_anchor_edge(position), y_position);
+            get_anchor_edge(position), edge_margin + autohide_animation);
         // queue_draw does not work when the panel is hidden
         // so calling wl_surface_commit to make WM show the panel back
         if (get_surface())
@@ -461,7 +641,7 @@ void WayfireAutohidingWindow::unset_active_popover(WayfireMenuButton& button)
 
     if (should_autohide())
     {
-        schedule_hide(AUTOHIDE_HIDE_DELAY);
+        schedule_hide(autohide_hide_delay);
     }
 }
 
diff --git a/src/util/wf-autohide-window.hpp b/src/util/wf-autohide-window.hpp
index 2324c6d0..26feabaa 100644
--- a/src/util/wf-autohide-window.hpp
+++ b/src/util/wf-autohide-window.hpp
@@ -3,15 +3,19 @@
 
 #include <gtkmm/window.h>
 #include <gdk/wayland/gdkwayland.h>
-#include "wf-popover.hpp"
-#include <wf-option-wrap.hpp>
+#include <sigc++/connection.h>
 #include <wayfire/util/duration.hpp>
 
+#include "wf-option-wrap.hpp"
+#include "wf-popover.hpp"
+
 struct WayfireOutput;
 struct zwf_hotspot_v2;
 
 #define WF_WINDOW_POSITION_TOP    "top"
 #define WF_WINDOW_POSITION_BOTTOM "bottom"
+#define WF_WINDOW_POSITION_LEFT   "left"
+#define WF_WINDOW_POSITION_RIGHT  "right"
 
 struct WayfireAutohidingWindowHotspotCallbacks;
 /**
@@ -23,13 +27,16 @@ class WayfireAutohidingWindow : public Gtk::Window
 {
   public:
     /**
-     * WayfireAutohidingWindow's behavior can be modified with several config
-     * file options:
-     *
+     * WayfireAutohidingWindow's behavior can be modified with several config file options:
      * 1. section/position
-     * 2. section/autohide_duration
-     * 3. section/edge_offset
-     * 4. section/autohide
+     * 2. section/full_span
+     * 3. section/autohide_duration
+     * 4. section/edge_offset
+     * 5. section/minimal_height
+     * 6. section/minimal_width
+     * 7. section/autohide
+     * 8. section/autohide_show_delay
+     * 9. section/autohide_hide_delay
      */
     WayfireAutohidingWindow(WayfireOutput *output, const std::string& section);
     WayfireAutohidingWindow(WayfireAutohidingWindow&&) = delete;
@@ -47,8 +54,7 @@ class WayfireAutohidingWindow : public Gtk::Window
     /* Returns true if the window should autohide */
     bool should_autohide() const;
 
-    /* Hide or show the panel after delay milliseconds, if nothing happens
-     * in the meantime */
+    /* Hide or show the panel after delay milliseconds, if nothing happens in the meantime */
     void schedule_hide(int delay);
     void schedule_show(int delay);
 
@@ -60,8 +66,8 @@ class WayfireAutohidingWindow : public Gtk::Window
 
     /**
      * Set the currently active popover button.
-     * The lastly activated popover, if any, will be closed, in order to
-     * show this new one.
+     * The lastly activated popover, if any, will be closed,
+     * in order to show this new one.
      *
      * In addition, if the window has an active popover, it will grab the
      * keyboard input and deactivate the popover when the focus is lost.
@@ -79,16 +85,27 @@ class WayfireAutohidingWindow : public Gtk::Window
   private:
     WayfireOutput *output;
 
+    std::vector<sigc::connection> signals;
+
     WfOption<std::string> position;
+    WfOption<bool> full_span;
     void update_position();
 
-    wf::animation::simple_animation_t y_position;
+    int (Gtk::Widget::*get_allocated_height_or_width)() const;
     bool update_margin();
 
-    WfOption<int> edge_offset;
-    int last_edge_offset = -1;
-
+    wf::animation::simple_animation_t autohide_animation;
     WfOption<bool> autohide_opt;
+    WfOption<int> autohide_show_delay;
+    WfOption<int> autohide_hide_delay;
+
+    WfOption<int> edge_margin;
+    WfOption<int> edge_hotspot_size, adjeacent_edge_hotspot_size;
+    int last_edge_hotspot_size = 0, last_adjeacent_edge_hotspot_size = 0;
+
+    WfOption<int> minimal_height;
+    WfOption<int> minimal_width;
+
     bool last_autohide_value = autohide_opt;
     void setup_autohide();
     void update_autohide();
@@ -109,12 +126,12 @@ class WayfireAutohidingWindow : public Gtk::Window
     /** Show the window but hide if no pointer input */
     void m_show_uncertain();
 
-    int32_t last_hotspot_height = -1;
-    bool input_inside_panel     = false;
-    zwf_hotspot_v2 *edge_hotspot  = NULL;
-    zwf_hotspot_v2 *panel_hotspot = NULL;
-    std::unique_ptr<WayfireAutohidingWindowHotspotCallbacks> edge_callbacks;
-    std::unique_ptr<WayfireAutohidingWindowHotspotCallbacks> panel_callbacks;
+    bool input_inside_panel = false;
+    zwf_hotspot_v2 *edge_hotspot = NULL, *panel_hotspot = NULL;
+    std::vector<zwf_hotspot_v2*> adjeacent_edges_hotspots;
+    std::unique_ptr<WayfireAutohidingWindowHotspotCallbacks> edge_callbacks, adjeacent_edge_callbacks,
+        panel_callbacks;
+    void reinit_ext_hotspots();
     void setup_hotspot();
 
     sigc::connection popover_hide;
diff --git a/src/util/wf-popover.cpp b/src/util/wf-popover.cpp
index 0a38af47..4c0b2ced 100644
--- a/src/util/wf-popover.cpp
+++ b/src/util/wf-popover.cpp
@@ -1,4 +1,5 @@
 #include "wf-popover.hpp"
+#include "gtkmm/enums.h"
 #include "wf-autohide-window.hpp"
 
 WayfireMenuButton::WayfireMenuButton(const std::string& section) :
@@ -9,8 +10,19 @@ WayfireMenuButton::WayfireMenuButton(const std::string& section) :
 
     auto cb = [=] ()
     {
-        // set_direction((std::string)panel_position == "top" ?
-        // Gtk::Arrow::DOWN : Gtk::Arrow::UP);
+        if (panel_position.value() == "top")
+        {
+            set_direction(Gtk::ArrowType::DOWN);
+        } else if (panel_position.value() == "bottom")
+        {
+            set_direction(Gtk::ArrowType::UP);
+        } else if (panel_position.value() == "left")
+        {
+            set_direction(Gtk::ArrowType::RIGHT);
+        } else if (panel_position.value() == "right")
+        {
+            set_direction(Gtk::ArrowType::LEFT);
+        }
 
         this->unset_popover();
         // m_popover.set_constrain_to(Gtk::POPOVER_CONSTRAINT_NONE);
diff --git a/src/util/wf-shell-app.hpp b/src/util/wf-shell-app.hpp
index 09314b66..a07b6d45 100644
--- a/src/util/wf-shell-app.hpp
+++ b/src/util/wf-shell-app.hpp
@@ -40,8 +40,7 @@ class WayfireShellApp
     std::vector<Glib::RefPtr<Gtk::CssProvider>> css_rules;
 
   protected:
-    /** This should be initialized by the subclass in each program which uses
-     * wf-shell-app */
+    /** This should be initialized by the subclass in each program which uses wf-shell-app */
     bool alternative_monitors = false; /* Used to skip monitor management in lockscreen */
     static std::unique_ptr<WayfireShellApp> instance;
     std::optional<std::string> cmdline_config;
diff --git a/wf-shell.ini.example b/wf-shell.ini.example
index a86e709d..5d9a233d 100644
--- a/wf-shell.ini.example
+++ b/wf-shell.ini.example
@@ -30,9 +30,16 @@ minimal_height = 24
 # automatically hide when pointer isn't over the panel
 autohide = false
 
-# time in milliseconds to wait before hiding
+# time in milliseconds the showing/hiding animation takes
 autohide_duration = 300
 
+# time in milliseconds to wait before showing
+autohide_show_delay= 300
+
+# time in milliseconds to wait before hiding
+autohide_hide_delay = 500
+
+
 # layer can be top, bottom, overlay or background
 layer = top