diff --git a/meson_options.txt b/meson_options.txt
index aca93f47..0d46b825 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -9,4 +9,4 @@ option(
     type: 'boolean',
     value: true,
     description: 'Install wayland-logout',
-)
\ No newline at end of file
+)
diff --git a/metadata/dock.xml b/metadata/dock.xml
index 3451c111..4ae4dafc 100644
--- a/metadata/dock.xml
+++ b/metadata/dock.xml
@@ -12,9 +12,26 @@
 		<default>true</default>
 	</option>
 	<option name="autohide_duration" type="int">
-		<_short>Autohide duration</_short>
+		<_short>Animation duration</_short>
+		<_long>
+			Time (in milliseconds) the panel 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,11 +43,49 @@
 			<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="orientation" type="string">
+		<_short>Icons orientation</_short>
+		<default>match</default>
+		<desc>
+			<value>match</value>
+			<_name>Match dock position</_name>
+		</desc>
+		<desc>
+			<value>horizontal</value>
+			<_name>Normal</_name>
+		</desc>
+		<desc>
+			<value>left</value>
+			<_name>Orient components to the left</_name>
+		</desc>
+		<desc>
+			<value>right</value>
+			<_name>Orient components to the right</_name>
+		</desc>
+	</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>
+	<option name="dock_width" type="int">
+		<_short>Dock width</_short>
+		<default>100</default>
+	</option>
+
 	<option name="icon_height" type="int">
 		<_short>Dock icons height</_short>
 		<default>72</default>
diff --git a/metadata/panel.xml b/metadata/panel.xml
index bfe391f0..c62be035 100644
--- a/metadata/panel.xml
+++ b/metadata/panel.xml
@@ -10,7 +10,10 @@
 		<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,21 +21,65 @@
 		<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>
+ 		<_long>
+ 			Minimum height the panel takes.
+ 		</_long>
 		<default>24</default>
 	</option>
+	<option name="minimal_width" type="int">
+		<_short>Minimal Width</_short>
+ 		<_long>
+ 			Minimum width the panel takes.
+ 		</_long>
+		<default>24</default>
+	</option>
+	<option name="span_full_edge" type="bool">
+		<_short>Span whole side</_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 centering by elements</_short>
+		<_long>
+			If on, the panel elements are centered around the middle of it, and thus the edge it runs along. 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>Animation duration</_short>
+		<_long>
+			Time (in milliseconds) the panel 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>Panel Position</_short>
 		<default>top</default>
@@ -44,6 +91,34 @@
 			<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="orientation" type="string">
+		<_short>Elements orientation</_short>
+		<default>match</default>
+		<desc>
+			<value>match</value>
+			<_name>Match panel position</_name>
+		</desc>
+		<desc>
+			<value>horizontal</value>
+			<_name>Normal</_name>
+		</desc>
+		<desc>
+			<value>left</value>
+			<_name>Orient components to the left</_name>
+		</desc>
+		<desc>
+			<value>right</value>
+			<_name>Orient components to the right</_name>
+		</desc>
 	</option>
 	<option name="edge_offset" type="int">
 		<_short>Edge offset</_short>
diff --git a/src/dock/dock-app.cpp b/src/dock/dock-app.cpp
index dc6e6d9b..1154afd3 100644
--- a/src/dock/dock-app.cpp
+++ b/src/dock/dock-app.cpp
@@ -5,7 +5,6 @@
 #include <gdk/wayland/gdkwayland.h>
 #include <css-config.hpp>
 
-
 namespace
 {
 extern zwlr_foreign_toplevel_manager_v1_listener toplevel_manager_v1_impl;
@@ -44,14 +43,21 @@ class WfDockApp::impl
     zwlr_foreign_toplevel_manager_v1 *toplevel_manager = NULL;
 };
 
+void WfDockApp::on_config_reload()
+{
+    for (auto& d : priv->docks)
+    {
+        d.second->handle_config_reload();
+    }
+}
+
 void WfDockApp::on_activate()
 {
     WayfireShellApp::on_activate();
     new CssFromConfigInt("dock/icon_height", ".toplevel-icon {-gtk-icon-size:", "px;}");
     IconProvider::load_custom_icons();
 
-    /* At this point, wayland connection has been initialized,
-     * and hopefully outputs have been created */
+    /* At this point, wayland connection has been initialized, and hopefully outputs have been created */
     auto gdk_display = gdk_display_get_default();
     auto display     = gdk_wayland_display_get_wl_display(gdk_display);
 
@@ -83,9 +89,8 @@ void WfDockApp::handle_new_output(WayfireOutput *output)
 
 void WfDockApp::handle_output_removed(WayfireOutput *output)
 {
-    /* Send an artificial output leave.
-     * This is useful because in this way the toplevel can safely destroy
-     * its icons created on that particular output */
+    /* Send an artificial output leave. This is useful because in this way the toplevel can safely destroy its
+     * icons created on that particular output */
     for (auto& toplvl : priv->toplevels)
     {
         toplvl.second->handle_output_leave(output->wo);
diff --git a/src/dock/dock.cpp b/src/dock/dock.cpp
index ba461c21..fbc13129 100644
--- a/src/dock/dock.cpp
+++ b/src/dock/dock.cpp
@@ -20,10 +20,24 @@ class WfDock::impl
     wl_surface *_wl_surface;
     Gtk::Box out_box;
     Gtk::Box box;
+    // flowbox doesn’t really cut it unfortunately. can’t center the inner widgets and can’t complete the
+    // down/right row first
+    // listbox neither, since it can’t even be oriented
 
     WfOption<std::string> css_path{"dock/css_path"};
+    WfOption<int> dock_width{"dock/dock_width"};
     WfOption<int> dock_height{"dock/dock_height"};
 
+    WfOption<std::string> position{"dock/position"};
+    WfOption<int> entries_per_line{"dock/max_per_line"};
+
+    WfOption<std::string> rotation{"dock/orientation"};
+
+    void (Gtk::Box::*ap_or_pre_pend)(Gtk::Widget&); // pointer to Gtk::Box::prepend or Gtk::Box::append,
+                                                    // updated by update_layout
+    Gtk::Widget*(Gtk::Widget::*first_or_last_child)(); // same, for get_first_child and get_last_child
+    bool reverse_iteration;
+
   public:
     impl(WayfireOutput *output)
     {
@@ -31,14 +45,16 @@ class WfDock::impl
         window = std::unique_ptr<WayfireAutohidingWindow>(
             new WayfireAutohidingWindow(output, "dock"));
         gtk_layer_set_layer(window->gobj(), GTK_LAYER_SHELL_LAYER_TOP);
-        gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_LEFT, true);
-        gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, true);
+        out_box.get_style_context()->add_class("out-box");
+
+        gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_TOP, 0);
+        gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, 0);
         gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_LEFT, 0);
         gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, 0);
-        out_box.append(box);
-        out_box.get_style_context()->add_class("out-box");
-        box.get_style_context()->add_class("box");
+
         window->set_child(out_box);
+        window->set_default_size(dock_width, dock_height);
+        update_layout();
 
         window->get_style_context()->add_class("wf-dock");
 
@@ -55,8 +71,23 @@ class WfDock::impl
         }
 
         window->present();
+        new CssFromConfigInt("dock/icon_height", ".toplevel-icon {-gtk-icon-size:", "px;}");
         _wl_surface = gdk_wayland_surface_get_wl_surface(
             window->get_surface()->gobj());
+    }
+
+    void prepare_new_layer(Gtk::Box& box)
+    {
+        box.get_style_context()->add_class("box");
+        box.set_homogeneous(true);
+
+        if ((std::string)position == "left" or (std::string)position == "right")
+        {
+            box.set_orientation(Gtk::Orientation::VERTICAL);
+        } else
+        {
+            box.set_orientation(Gtk::Orientation::HORIZONTAL);
+        }
 
         box.add_tick_callback([=] (Glib::RefPtr<Gdk::FrameClock> fc)
         {
@@ -65,14 +96,133 @@ class WfDock::impl
         });
     }
 
+    void update_layout()
+    {
+        Gtk::Orientation orientation;
+
+        // this sequence of checking gives a fallback to a horizontal layout if the value is invalid.
+        // goes with the WfAutohideWindow fallback to go at the top.
+        if ((std::string)position == "left" or (std::string)position == "right")
+        {
+            orientation = Gtk::Orientation::VERTICAL;
+            out_box.set_orientation(Gtk::Orientation::HORIZONTAL);
+        } else
+        {
+            orientation = Gtk::Orientation::HORIZONTAL;
+            out_box.set_orientation(Gtk::Orientation::VERTICAL);
+        }
+
+        if ((std::string)position == "bottom" or (std::string)position == "right")
+        {
+            ap_or_pre_pend = &Gtk::Box::prepend;
+            first_or_last_child = &Gtk::Widget::get_first_child;
+            reverse_iteration   = true;
+        } else
+        {
+            ap_or_pre_pend = &Gtk::Box::append;
+            first_or_last_child = &Gtk::Widget::get_last_child;
+            reverse_iteration   = false;
+        }
+
+        std::string widget_rotation = "horizontal";
+        if (((std::string)rotation == ROTATION_LEFT) || ((std::string)rotation == "match") &&
+            ((std::string)position == "right"))
+        {
+            widget_rotation = ROTATION_LEFT;
+        } else if (((std::string)rotation == ROTATION_RIGHT) || ((std::string)rotation == "match") &&
+                   ((std::string)position == "left"))
+        {
+            widget_rotation = ROTATION_RIGHT;
+        }
+
+        for (auto layer : out_box.get_children())
+        {
+            ((Gtk::Box*)layer)->set_orientation(orientation);
+
+            for (auto child : layer->get_children())
+            {
+                apply_rotation(*child, widget_rotation);
+            }
+        }
+    }
+
     void add_child(Gtk::Widget& widget)
     {
-        box.append(widget);
+        // create a box if the last one is full or there is none
+        if (((int)(out_box.get_children().size()) == 0) ||
+            ((int)((out_box.*first_or_last_child)()->get_children().size()) == entries_per_line))
+        {
+            Gtk::Box new_box;
+            prepare_new_layer(new_box);
+            (out_box.*ap_or_pre_pend)(new_box);
+        }
+
+        Gtk::Box& last_child = *(Gtk::Box*)(out_box.*first_or_last_child)();
+
+        widget.set_halign(Gtk::Align::CENTER);
+        widget.set_valign(Gtk::Align::CENTER);
+        widget.get_style_context()->add_class("re-orient");
+
+        last_child.append(widget);
     }
 
     void rem_child(Gtk::Widget& widget)
     {
-        this->box.remove(widget);
+        Gtk::Box *prev_row = nullptr;
+        bool found = false;
+
+        auto check_row = [&] (Gtk::Widget *row)
+        {
+            if (!found)
+            {
+                for (Gtk::Widget *item : row->get_children())
+                {
+                    if (&widget == item)
+                    {
+                        found = true;
+                        ((Gtk::Box*)row)->remove(*item);
+                        break;
+                    }
+                }
+
+                if (!found)
+                {
+                    return;
+                }
+            }
+
+            // move the first widget of every next line and append it to the previous line
+            if (prev_row != nullptr)
+            {
+                Gtk::Widget *to_move = ((Gtk::Box*)row)->get_last_child();
+                prev_row->append(*to_move);
+                ((Gtk::Box*)row)->remove(*to_move);
+            }
+
+            prev_row = ((Gtk::Box*)row);
+        };
+
+        auto children = out_box.get_children();
+
+        if (reverse_iteration)
+        {
+            for (auto it = children.rbegin(); it != children.rend(); ++it)
+            {
+                check_row(*it);
+            }
+        } else
+        {
+            for (auto it = children.begin(); it != children.end(); ++it)
+            {
+                check_row(*it);
+            }
+        }
+
+        // if we emptied a row, delete it
+        if ((out_box.*first_or_last_child)()->get_children().size() == 0)
+        {
+            out_box.remove(*(out_box.*first_or_last_child)());
+        }
     }
 
     wl_surface *get_wl_surface()
@@ -80,12 +230,12 @@ class WfDock::impl
         return this->_wl_surface;
     }
 
-    /* Sets the central section as clickable and transparent edges as click-through
-     *  Gets called regularly to ensure css size changes all register */
+    /* Sets the central section as clickable and transparent edges as click-through Gets called regularly to
+     * ensure css size changes all register */
     void set_clickable_region()
     {
         auto surface = window->get_surface();
-        auto widget_bounds = box.compute_bounds(*window);
+        auto widget_bounds = out_box.compute_bounds(*window);
 
         auto rect = Cairo::RectangleInt{
             (int)widget_bounds->get_x(),
@@ -105,6 +255,11 @@ WfDock::WfDock(WayfireOutput *output) :
 {}
 WfDock::~WfDock() = default;
 
+void WfDock::handle_config_reload()
+{
+    pimpl->update_layout();
+}
+
 void WfDock::add_child(Gtk::Widget& w)
 {
     return pimpl->add_child(w);
diff --git a/src/dock/dock.hpp b/src/dock/dock.hpp
index 012c8e80..619b9ae6 100644
--- a/src/dock/dock.hpp
+++ b/src/dock/dock.hpp
@@ -14,6 +14,7 @@ class WfDock
     WfDock(WayfireOutput *output);
     ~WfDock();
 
+    void handle_config_reload();
     void add_child(Gtk::Widget& widget);
     void rem_child(Gtk::Widget& widget);
 
@@ -34,11 +35,11 @@ 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();
 
+    void on_config_reload() override;
     void on_activate() override;
     void handle_new_output(WayfireOutput *output) override;
     void handle_output_removed(WayfireOutput *output) override;
diff --git a/src/dock/toplevel-icon.cpp b/src/dock/toplevel-icon.cpp
index 9572bc0e..866f522d 100644
--- a/src/dock/toplevel-icon.cpp
+++ b/src/dock/toplevel-icon.cpp
@@ -263,8 +263,8 @@ bool set_custom_icon(Gtk::Image& image, std::string app_id, int size, int scale)
 
 /* Gio::DesktopAppInfo
  *
- * Usually knowing the app_id, we can get a desktop app info from Gio
- * The filename is either the app_id + ".desktop" or lower_app_id + ".desktop" */
+ * Usually knowing the app_id, we can get a desktop app info from Gio The filename is either the app_id +
+ * ".desktop" or lower_app_id + ".desktop" */
 Icon get_from_desktop_app_info(std::string app_id)
 {
     Glib::RefPtr<Gio::DesktopAppInfo> app_info;
@@ -319,8 +319,8 @@ void set_image_from_icon(Gtk::Image& image,
 
     bool found_icon = false;
 
-    /* Wayfire sends a list of app-id's in space separated format, other compositors
-     * send a single app-id, but in any case this works fine */
+    /* Wayfire sends a list of app-id's in space separated format, other compositors send a single app-id, but
+     * in any case this works fine */
     auto display = image.get_display();
     while (stream >> app_id)
     {
diff --git a/src/dock/toplevel-icon.hpp b/src/dock/toplevel-icon.hpp
index 7c589b05..7addb00f 100644
--- a/src/dock/toplevel-icon.hpp
+++ b/src/dock/toplevel-icon.hpp
@@ -22,8 +22,8 @@ class WfToplevelIcon
 
 namespace IconProvider
 {
-/* Loads custom app_id -> icon file mappings from the section
-* They have the format icon_mapping_<app_id> = <icon file> */
+/* Loads custom app_id -> icon file mappings from the section They have the format icon_mapping_<app_id> =
+ * <icon file> */
 void load_custom_icons();
 }
 
diff --git a/src/dock/toplevel.cpp b/src/dock/toplevel.cpp
index a8bb94cd..12ec021e 100644
--- a/src/dock/toplevel.cpp
+++ b/src/dock/toplevel.cpp
@@ -35,11 +35,10 @@ class WfToplevel::impl
         /* This catches two edge cases:
          * 1. The dock on the given output simply was closed by the user
          *
-         * 2. The wl_output has been bound multiple times - this happens because
-         * gtk will bind each output once, and then we bind it second time. So
-         * the compositor will actually send the output_enter/leave at least
-         * twice, and the one time when we get it with the output resource bound
-         * by gtk, we need to ignore the request */
+         * 2. The wl_output has been bound multiple times - this happens because gtk will bind each output
+         * once, and then we bind it second time. So the compositor will actually send the output_enter/leave
+         * at least twice, and the one time when we get it with the output resource bound by gtk, we need to
+         * ignore the request */
         if (!dock)
         {
             return;
@@ -137,8 +136,7 @@ static void handle_toplevel_output_leave(void *data, toplevel_t, wl_output *outp
     impl->handle_output_leave(output);
 }
 
-/* wl_array_for_each isn't supported in C++, so we have to manually
- * get the data from wl_array, see:
+/* wl_array_for_each isn't supported in C++, so we have to manually get the data from wl_array, see:
  *
  * https://gitlab.freedesktop.org/wayland/wayland/issues/34 */
 template<class T>
diff --git a/src/dock/toplevel.hpp b/src/dock/toplevel.hpp
index 64202dbd..ad616fb2 100644
--- a/src/dock/toplevel.hpp
+++ b/src/dock/toplevel.hpp
@@ -11,8 +11,8 @@ enum WfToplevelState
     WF_TOPLEVEL_STATE_MINIMIZED = (1 << 2),
 };
 
-/* Represents a single opened toplevel window.
- * It displays the window icon on all outputs' docks that it is visible on */
+/* Represents a single opened toplevel window. It displays the window icon on all outputs' docks that it is
+ * visible on */
 class WfToplevel
 {
   public:
diff --git a/src/panel/meson.build b/src/panel/meson.build
index f086c614..d95c2093 100644
--- a/src/panel/meson.build
+++ b/src/panel/meson.build
@@ -41,4 +41,4 @@ executable(
   ['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..a434dc6c 100644
--- a/src/panel/panel.cpp
+++ b/src/panel/panel.cpp
@@ -9,10 +9,12 @@
 #include <iostream>
 #include <sstream>
 
-#include <map>
 #include <css-config.hpp>
+
 #include "panel.hpp"
 
+#include "gtkmm/sizegroup.h"
+#include "widget.hpp"
 #include "widgets/battery.hpp"
 #include "widgets/command-output.hpp"
 #include "widgets/menu.hpp"
@@ -36,6 +38,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>;
@@ -68,23 +71,107 @@ class WayfirePanel::impl
     };
 
     WfOption<int> minimal_panel_height{"panel/minimal_height"};
+    WfOption<int> minimal_panel_width{"panel/minimal_width"};
+    WfOption<bool> full_edge{"panel/span_full_edge"};
+    WfOption<bool> force_center{"panel/force_center"};
+
+    WfOption<std::string> panel_position{"panel/position"};
+    WfOption<std::string> panel_orientation{"panel/orientation"};
+
+    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 = !((std::string)panel_position == "left" or (std::string)panel_position ==
+            "right"); // not the most pretty, but if the value is top, down or something invalid, it works the
+                      // same
+
+        if (is_horizontal)
+        {
+            // if the panel is supposed to expand trough the whole edge, set anchors to stretch it
+            gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_LEFT, full_edge);
+            gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, full_edge);
+
+            gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_LEFT, 0);
+            gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, 0);
+
+            set_boxes_orientation(Gtk::Orientation::HORIZONTAL);
+
+            if (force_center)
+            {
+                sides_size_group->set_mode(Gtk::SizeGroup::Mode::HORIZONTAL);
+                left_box.set_halign(Gtk::Align::END);
+                right_box.set_halign(Gtk::Align::START);
+                left_box.set_valign(Gtk::Align::CENTER);
+                right_box.set_valign(Gtk::Align::CENTER);
+            } else
+            {
+                sides_size_group->set_mode(Gtk::SizeGroup::Mode::NONE);
+                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);
+            }
+        } else
+        {
+            gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_TOP, full_edge);
+            gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, full_edge);
+
+            gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_TOP, 0);
+            gtk_layer_set_margin(window->gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, 0);
+
+            set_boxes_orientation(Gtk::Orientation::VERTICAL);
+            sides_size_group->set_mode(Gtk::SizeGroup::Mode::VERTICAL);
+
+            if (force_center)
+            {
+                sides_size_group->set_mode(Gtk::SizeGroup::Mode::VERTICAL);
+                left_box.set_valign(Gtk::Align::END);
+                right_box.set_valign(Gtk::Align::START);
+                left_box.set_halign(Gtk::Align::CENTER);
+                right_box.set_halign(Gtk::Align::CENTER);
+            } else
+            {
+                sides_size_group->set_mode(Gtk::SizeGroup::Mode::NONE);
+                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);
+            }
+        }
+    }
 
     void create_window()
     {
         window = std::make_unique<WayfireAutohidingWindow>(output, "panel");
 
-        window->set_default_size(0, minimal_panel_height);
+        window->set_default_size(minimal_panel_width, minimal_panel_height); // addition of minimal panel
+                                                                             // width for the panel on the
+                                                                             // left or right instead of
+                                                                             // reusing m. p. height allows
+                                                                             // for the inclusion of
+                                                                             // non-stretched bar (like the
+                                                                             // gnome dock, or the kde setting
+                                                                             // to let the bar contract)
         window->get_style_context()->add_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_widgets();
         init_layout();
+
+        // window->signal_close_request().connect(
+        // sigc::mem_fun(*this, &WayfirePanel::impl::on_delete));
     }
 
     void init_layout()
@@ -92,6 +179,7 @@ class WayfirePanel::impl
         left_box.get_style_context()->add_class("left");
         right_box.get_style_context()->add_class("right");
         center_box.get_style_context()->add_class("center");
+
         content_box.set_start_widget(left_box);
         if (!center_box.get_children().empty())
         {
@@ -101,10 +189,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);
     }
@@ -284,6 +374,26 @@ class WayfirePanel::impl
   public:
     impl(WayfireOutput *output) : output(output)
     {
+        sides_size_group = Gtk::SizeGroup::create(Gtk::SizeGroup::Mode::NONE);
+
+        // Intentionally leaking feels bad.
+        new CssFromConfigInt("panel/launchers_size", ".menu-button,.launcher{-gtk-icon-size:", "px;}");
+        new CssFromConfigInt("panel/launchers_spacing", ".launcher{padding: 0px ", "px;}");
+        new CssFromConfigInt("panel/battery_icon_size", ".battery image{-gtk-icon-size:", "px;}");
+        new CssFromConfigInt("panel/network_icon_size", ".network{-gtk-icon-size:", "px;}");
+        new CssFromConfigInt("panel/volume_icon_size", ".volume{-gtk-icon-size:", "px;}");
+        new CssFromConfigInt("panel/notifications_icon_size", ".notification-center{-gtk-icon-size:", "px;}");
+        new CssFromConfigInt("panel/tray_icon_size", ".tray-button{-gtk-icon-size:", "px;}");
+        new CssFromConfigString("panel/background_color", ".wf-panel{background-color:", ";}");
+        new CssFromConfigBool("panel/battery_icon_invert", ".battery image{filter:invert(100%);}", "");
+        new CssFromConfigBool("panel/network_icon_invert_color", ".network-icon{filter:invert(100%);}", "");
+
+        // People will probably need to update sizes to have a measure
+        // 16px, 1.1rem, 1em .
+        // So on
+        new CssFromConfigFont("panel/battery_font", ".battery {", "}");
+        new CssFromConfigFont("panel/clock_font", ".clock {", "}");
+
         create_window();
     }
 
@@ -299,6 +409,8 @@ class WayfirePanel::impl
 
     void handle_config_reload()
     {
+        update_orientation();
+
         for (auto& w : left_widgets)
         {
             w->handle_config_reload();
diff --git a/src/panel/panel.hpp b/src/panel/panel.hpp
index cae9903e..2e503095 100644
--- a/src/panel/panel.hpp
+++ b/src/panel/panel.hpp
@@ -28,8 +28,7 @@ class WayfirePanelApp : public WayfireShellApp
     WayfirePanel *panel_for_wl_output(wl_output *output);
     static WayfirePanelApp& get();
 
-    /* Starts the program. get() is valid afterward the first (and the only)
-     * call to create() */
+    /* Starts the program. get() is valid afterward the first (and the only) call to create() */
     static void create(int argc, char **argv);
     ~WayfirePanelApp();
 
diff --git a/src/panel/widget.hpp b/src/panel/widget.hpp
index 6f85c344..97e34a45 100644
--- a/src/panel/widget.hpp
+++ b/src/panel/widget.hpp
@@ -8,8 +8,14 @@
 #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"
+
+#define PANEL_ORIENTATION_HORIZONTAL "horizontal"
+#define PANEL_ORIENTATION_LEFT "left"
+#define PANEL_ORIENTATION_RIGHT "right"
 
 class wayfire_config;
 class WayfireWidget
@@ -18,8 +24,10 @@ class WayfireWidget
     std::string widget_name; // for WayfirePanel use, widgets shouldn't change it
 
     virtual void init(Gtk::Box *container) = 0;
+
     virtual void handle_config_reload()
     {}
+
     virtual ~WayfireWidget()
     {}
 };
diff --git a/src/panel/widgets/battery.cpp b/src/panel/widgets/battery.cpp
index 090e1f23..2688fe4a 100644
--- a/src/panel/widgets/battery.cpp
+++ b/src/panel/widgets/battery.cpp
@@ -1,7 +1,6 @@
 #include "battery.hpp"
 #include <gtk-utils.hpp>
 #include <iostream>
-#include <algorithm>
 
 #define UPOWER_NAME "org.freedesktop.UPower"
 #define DISPLAY_DEVICE "/org/freedesktop/UPower/devices/DisplayDevice"
@@ -206,6 +205,24 @@ bool WayfireBatteryInfo::setup_dbus()
     return false;
 }
 
+void WayfireBatteryInfo::update_layout()
+{
+    std::string panel_position = WfOption<std::string>{"panel/position"};
+
+    if (panel_position == PANEL_POSITION_LEFT or panel_position == 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)
@@ -231,4 +248,6 @@ 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();
 }
diff --git a/src/panel/widgets/battery.hpp b/src/panel/widgets/battery.hpp
index a3366e19..bb26a785 100644
--- a/src/panel/widgets/battery.hpp
+++ b/src/panel/widgets/battery.hpp
@@ -38,6 +38,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/clock.cpp b/src/panel/widgets/clock.cpp
index a3c10632..fc34677c 100644
--- a/src/panel/widgets/clock.cpp
+++ b/src/panel/widgets/clock.cpp
@@ -1,5 +1,4 @@
 #include <glibmm.h>
-#include <iostream>
 #include "clock.hpp"
 
 void WayfireClock::init(Gtk::Box *container)
@@ -39,12 +38,11 @@ bool WayfireClock::update_label()
     auto time = Glib::DateTime::create_now_local();
     auto text = time.format((std::string)format);
 
-    /* Sometimes GLib::DateTime will add leading spaces. This results in
-     * unevenly balanced padding around the text, which looks quite bad.
+    /* Sometimes GLib::DateTime will add leading spaces. This results in unevenly balanced padding around the
+     * text, which looks quite bad.
      *
-     * This could be circumvented with the modifiers the user passes to the
-     * format string, * but to remove the requirement that the user does
-     * something fancy, we just remove any leading spaces. */
+     * This could be circumvented with the modifiers the user passes to the format string, * but to remove the
+     * requirement that the user does something fancy, we just remove any leading spaces. */
     int i = 0;
     while (i < (int)text.length() && text[i] == ' ')
     {
diff --git a/src/panel/widgets/launchers.cpp b/src/panel/widgets/launchers.cpp
index 46da4d35..e407392f 100644
--- a/src/panel/widgets/launchers.cpp
+++ b/src/panel/widgets/launchers.cpp
@@ -5,7 +5,6 @@
 #include <gtkmm/icontheme.h>
 #include <gdk/gdkcairo.h>
 #include <cassert>
-#include <iostream>
 #include <gtk-utils.hpp>
 #include <wf-shell-app.hpp>
 
@@ -44,7 +43,11 @@ 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);
+
     auto style = button.get_style_context();
     style->add_class("flat");
     style->add_class("launcher");
@@ -115,8 +118,7 @@ launcher_container WayfireLaunchers::get_launchers_from_config()
             auto icon_option = section->get_option_or(file_icon_prefix + launcher_name);
             if (icon_option)
             {
-                /* bingo, found command + icon
-                 * now look for the corresponding label  */
+                /* bingo, found command + icon now look for the corresponding label  */
                 auto label_option = section->get_option_or(file_label_prefix + launcher_name);
                 if (label_option)
                 {
@@ -130,8 +132,8 @@ launcher_container WayfireLaunchers::get_launchers_from_config()
             }
         }
 
-        /* an entry is a deskop-file entry if the it has the desktop prefix
-         * but not the file_icon, file_cmd or file_label prefix */
+        /* an entry is a deskop-file entry if the it has the desktop prefix but not the file_icon, file_cmd or
+         * file_label prefix */
         if (begins_with(opt->get_name(), desktop_prefix) &&
             !begins_with(opt->get_name(), file_icon_prefix) &&
             !begins_with(opt->get_name(), file_cmd_prefix) &&
@@ -147,12 +149,32 @@ launcher_container WayfireLaunchers::get_launchers_from_config()
 void WayfireLaunchers::init(Gtk::Box *container)
 {
     box.get_style_context()->add_class("launchers");
+
     container->append(box);
+
+    box.set_halign(Gtk::Align::CENTER);
+    box.set_valign(Gtk::Align::CENTER);
+
     handle_config_reload();
 }
 
+void WayfireLaunchers::update_layout()
+{
+    std::string panel_position = WfOption<std::string>{"panel/position"};
+
+    if (panel_position == PANEL_POSITION_LEFT or panel_position == 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 4f1fb696..3af311ab 100644
--- a/src/panel/widgets/launchers.hpp
+++ b/src/panel/widgets/launchers.hpp
@@ -34,6 +34,9 @@ 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/menu.cpp b/src/panel/widgets/menu.cpp
index 61cb6ad5..e09330ee 100644
--- a/src/panel/widgets/menu.cpp
+++ b/src/panel/widgets/menu.cpp
@@ -10,7 +10,6 @@
 
 #include "menu.hpp"
 #include "gtk-utils.hpp"
-#include "launchers.hpp"
 #include "wf-autohide-window.hpp"
 
 const std::string default_icon = "wayfire";
@@ -156,10 +155,9 @@ uint32_t WfMenuMenuItem::get_search_value()
 }
 
 /* Fuzzy search for pattern in text. We use a greedy algorithm as follows:
- * As long as the pattern isn't matched, try to match the leftmost unmatched
- * character in pattern with the first occurence of this character after the
- * partial match. In the end, we just check if we successfully matched all
- * characters */
+ * As long as the pattern isn't matched, try to match the leftmost unmatched character in pattern with the
+ * first occurence of this character after the partial match. In the end, we just check if we successfully
+ * matched all characters */
 static bool fuzzy_match(Glib::ustring text, Glib::ustring pattern)
 {
     size_t i = 0, // next character in pattern to match
@@ -174,8 +172,7 @@ static bool fuzzy_match(Glib::ustring text, Glib::ustring pattern)
             ++j;
         } else
         {
-            /* Try to match current unmatched character in pattern with the next
-             * character in text */
+            /* Try to match current unmatched character in pattern with the next character in text */
             ++j;
         }
     }
@@ -275,8 +272,7 @@ void WayfireMenu::load_menu_item(AppInfo app_info)
 
     auto name = app_info->get_name();
     auto exec = app_info->get_executable();
-    /* If we don't have the following, then the entry won't be useful anyway,
-     * so we should skip it */
+    /* If we don't have the following, then the entry won't be useful anyway, so we should skip it */
     if (name.empty() || !app_info->get_icon() || exec.empty())
     {
         return;
@@ -290,8 +286,8 @@ void WayfireMenu::load_menu_item(AppInfo app_info)
 
     loaded_apps.insert({name, exec});
 
-    /* Check if this has a 'OnlyShownIn' for a different desktop env
-    *  If so, we throw it in a pile at the bottom just to be safe */
+    /* Check if this has a 'OnlyShownIn' for a different desktop env If so, we throw it in a pile at the
+     * bottom just to be safe */
     if (!app_info->should_show())
     {
         add_category_app("Hidden", app_info);
@@ -618,8 +614,7 @@ void WayfireMenu::update_popover_layout()
         });
     } else
     {
-        /* Layout was already initialized, make sure to remove widgets before
-         * adding them again */
+        /* Layout was already initialized, make sure to remove widgets before adding them again */
         popover_layout_box.remove(search_entry);
         popover_layout_box.remove(scroll_pair);
         popover_layout_box.remove(separator);
@@ -807,9 +802,9 @@ static void app_info_changed(GAppInfoMonitor *gappinfomonitor, gpointer user_dat
 
 void WayfireMenu::init(Gtk::Box *container)
 {
-    /* https://specifications.freedesktop.org/menu-spec/latest/apa.html#main-category-registry
-     * Using the 'Main' categories, with names and icons assigned
-     * Any Categories in .desktop files that are not in this list are ignored */
+    /* https://specifications.freedesktop.org/menu-spec/latest/apa.html#main-category-registry Using the
+     * 'Main' categories, with names and icons assigned Any Categories in .desktop files that are not in this
+     * list are ignored */
     category_list["All"]     = std::make_unique<WfMenuCategory>("All", "applications-other");
     category_list["Network"] = std::make_unique<WfMenuCategory>("Internet",
         "applications-internet");
diff --git a/src/panel/widgets/menu.hpp b/src/panel/widgets/menu.hpp
index 6a872766..105b5714 100644
--- a/src/panel/widgets/menu.hpp
+++ b/src/panel/widgets/menu.hpp
@@ -153,8 +153,8 @@ class WayfireMenu : public WayfireWidget
     void on_search_changed();
     void on_popover_shown();
 
-    /* loaded_apps is a list of the already-opened applications + their execs,
-     * so that we don't show duplicate entries */
+    /* loaded_apps is a list of the already-opened applications + their execs, so that we don't show duplicate
+     * entries */
     std::set<std::pair<std::string, std::string>> loaded_apps;
     std::unordered_map<std::string, std::unique_ptr<WfMenuCategory>> category_list;
     std::string category = "All";
diff --git a/src/panel/widgets/network.cpp b/src/panel/widgets/network.cpp
index 0ed71819..210983b8 100644
--- a/src/panel/widgets/network.cpp
+++ b/src/panel/widgets/network.cpp
@@ -432,8 +432,23 @@ void WayfireNetworkInfo::init(Gtk::Box *container)
     handle_config_reload();
 }
 
+void WayfireNetworkInfo::update_layout()
+{
+    std::string panel_position = WfOption<std::string>{"panel/position"};
+
+    if (panel_position == PANEL_POSITION_LEFT or panel_position == 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 1ef806ef..aad7836d 100644
--- a/src/panel/widgets/network.hpp
+++ b/src/panel/widgets/network.hpp
@@ -79,6 +79,9 @@ 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/notifications/daemon.hpp b/src/panel/widgets/notifications/daemon.hpp
index 8496de72..04688bf9 100644
--- a/src/panel/widgets/notifications/daemon.hpp
+++ b/src/panel/widgets/notifications/daemon.hpp
@@ -5,8 +5,6 @@
 
 #include <giomm/dbusconnection.h>
 
-#include <set>
-
 #define dbus_method(name)                                                                                              \
     void name ## dbus_method(const Glib::ustring & sender, const Glib::VariantContainerBase & parameters,                  \
     const Glib::RefPtr<Gio::DBus::MethodInvocation> & invocation)
@@ -41,21 +39,19 @@ class Daemon
     /*!
      * Initializes and launches the daemon.
      *
-     * Returns a shared pointer to the instance.
-     * Once there are no alive shared pointers to the instance,
-     * the daemon is automatically destroyed.
+     * Returns a shared pointer to the instance. Once there are no alive shared pointers to the instance, the
+     * daemon is automatically destroyed.
      */
     static std::shared_ptr<Daemon> Launch();
 
     /*!
-     * Returns a pointer to the Daemon's instance if it exists
-     * or an empty `shared_ptr` otherwise.
+     * Returns a pointer to the Daemon's instance if it exists or an empty `shared_ptr` otherwise.
      */
     static std::shared_ptr<Daemon> Instance();
 
     ~Daemon();
 
-    const std::map<Notification::id_type, const Notification> & getNotifications() const;
+    const std::map<Notification::id_type, const Notification>& getNotifications() const;
     void closeNotification(Notification::id_type id, CloseReason reason);
     void invokeAction(Notification::id_type id, const Glib::ustring & action_key);
 
diff --git a/src/panel/widgets/notifications/single-notification.cpp b/src/panel/widgets/notifications/single-notification.cpp
index fbb5fb0b..80921cd1 100644
--- a/src/panel/widgets/notifications/single-notification.cpp
+++ b/src/panel/widgets/notifications/single-notification.cpp
@@ -135,7 +135,7 @@ WfSingleNotification::WfSingleNotification(const Notification & notification)
     {
         for (uint i = 0; i + 1 < notification.actions.size(); ++++ i)
         {
-            if (const auto action_key = notification.actions[i];action_key != "default")
+            if (const auto action_key = notification.actions[i];(action_key != "default"))
             {
                 auto action_button = Glib::RefPtr<Gtk::Button>(new Gtk::Button(notification.actions[i + 1]));
                 action_button->signal_clicked().connect(
diff --git a/src/panel/widgets/separator.cpp b/src/panel/widgets/separator.cpp
index 8f8636b9..1e3ea1e5 100644
--- a/src/panel/widgets/separator.cpp
+++ b/src/panel/widgets/separator.cpp
@@ -11,4 +11,24 @@ void WayfireSeparator::init(Gtk::Box *container)
 {
     separator.get_style_context()->add_class("separator");
     container->append(separator);
+
+    update_layout();
+}
+
+void WayfireSeparator::update_layout()
+{
+    std::string panel_position = WfOption<std::string>{"panel/position"};
+
+    if (panel_position == PANEL_POSITION_LEFT or panel_position == 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 74b615bb..e9ca18e6 100644
--- a/src/panel/widgets/separator.hpp
+++ b/src/panel/widgets/separator.hpp
@@ -12,6 +12,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/dbusmenu.cpp b/src/panel/widgets/tray/dbusmenu.cpp
index 82358011..03df7559 100644
--- a/src/panel/widgets/tray/dbusmenu.cpp
+++ b/src/panel/widgets/tray/dbusmenu.cpp
@@ -101,8 +101,8 @@ int DbusMenuModel::iterate_children(Gio::Menu *parent_menu, DbusmenuMenuitem *pa
             bool has_children = dbusmenu_menuitem_get_children(child) != NULL;
 
             /*  #Icons are set, but from what I read they won't be shown in gtk4.
-             *  for some reason TOGGLE_TYPE is always returning as if not set.
-             *  So checkboxes and radios work but are never sent
+             *  for some reason TOGGLE_TYPE is always returning as if not set. So checkboxes and radios work
+             * but are never sent
              */
             if (has_children)
             {
@@ -194,8 +194,8 @@ Glib::RefPtr<Gio::Menu> DbusMenuModel::get_menu()
 }
 
 /*
- *  Strip non-alphabetical characters and add a unique numeric ID.
- *  Keeping alphacharacters can help with debugging but isn't strictly necessary.
+ *  Strip non-alphabetical characters and add a unique numeric ID. Keeping alphacharacters can help with
+ * debugging but isn't strictly necessary.
  *
  *  Watch out for this in localisations. I'm betting it's a source of many bugs to come
  *
diff --git a/src/panel/widgets/tray/item.cpp b/src/panel/widgets/tray/item.cpp
index 4255fcb6..8b823a62 100644
--- a/src/panel/widgets/tray/item.cpp
+++ b/src/panel/widgets/tray/item.cpp
@@ -9,7 +9,6 @@
 #include <glib-object.h>
 #include <giomm/dbusmenumodel.h>
 
-#include <iostream>
 #include <cassert>
 
 static std::pair<Glib::ustring, Glib::ustring> name_and_obj_path(const Glib::ustring & service)
@@ -288,10 +287,9 @@ std::string StatusNotifierItem::get_unique_name()
 }
 
 /*
- *  DBUS names are in the format of :1.61
- *  I have no idea what this means, I frankly don't care, but I need a way to generate an acceptable action
- * group name from this
- *  such that it always gets the same unique output for the same input
+ *  DBUS names are in the format of :1.61 I have no idea what this means, I frankly don't care, but I need a
+ * way to generate an acceptable action group name from this such that it always gets the same unique output
+ * for the same input
  */
 
 const std::string CHARS_IN  = ":0123456789.";
diff --git a/src/panel/widgets/tray/tray.cpp b/src/panel/widgets/tray/tray.cpp
index bf9a0c3a..1ec8ba21 100644
--- a/src/panel/widgets/tray/tray.cpp
+++ b/src/panel/widgets/tray/tray.cpp
@@ -1,10 +1,16 @@
 #include "tray.hpp"
+#include "gtkmm/enums.h"
 
 void WayfireStatusNotifier::init(Gtk::Box *container)
 {
-    icons_hbox.get_style_context()->add_class("tray");
-    icons_hbox.set_spacing(5);
-    container->append(icons_hbox);
+    update_layout();
+    icons_box.set_halign(Gtk::Align::FILL);
+    icons_box.set_valign(Gtk::Align::FILL);
+    icons_box.set_expand(true);
+    icons_box.set_homogeneous(true);
+    icons_box.get_style_context()->add_class("tray");
+    icons_box.set_spacing(5);
+    container->append(icons_box);
 }
 
 void WayfireStatusNotifier::add_item(const Glib::ustring & service)
@@ -15,7 +21,7 @@ void WayfireStatusNotifier::add_item(const Glib::ustring & service)
     }
 
     items.emplace(service, service);
-    icons_hbox.append(items.at(service));
+    icons_box.append(items.at(service));
 }
 
 void WayfireStatusNotifier::remove_item(const Glib::ustring & service)
@@ -25,6 +31,24 @@ void WayfireStatusNotifier::remove_item(const Glib::ustring & service)
         return;
     }
 
-    icons_hbox.remove(items.at(service));
+    icons_box.remove(items.at(service));
     items.erase(service);
 }
+
+void WayfireStatusNotifier::update_layout()
+{
+    std::string panel_position = WfOption<std::string>{"panel/position"};
+
+    if (panel_position == PANEL_POSITION_LEFT or panel_position == PANEL_POSITION_RIGHT)
+    {
+        icons_box.set_orientation(Gtk::Orientation::VERTICAL);
+    } else
+    {
+        icons_box.set_orientation(Gtk::Orientation::HORIZONTAL);
+    }
+}
+
+void WayfireStatusNotifier::handle_config_reload()
+{
+    update_layout();
+}
diff --git a/src/panel/widgets/tray/tray.hpp b/src/panel/widgets/tray/tray.hpp
index 0fbfb881..4001812c 100644
--- a/src/panel/widgets/tray/tray.hpp
+++ b/src/panel/widgets/tray/tray.hpp
@@ -11,9 +11,12 @@ class WayfireStatusNotifier : public WayfireWidget
   private:
     StatusNotifierHost host = StatusNotifierHost(this);
 
-    Gtk::Box icons_hbox;
+    Gtk::Box icons_box;
     std::map<Glib::ustring, StatusNotifierItem> items;
 
+    void update_layout();
+    void handle_config_reload();
+
   public:
     void init(Gtk::Box *container) override;
 
diff --git a/src/panel/widgets/tray/watcher.cpp b/src/panel/widgets/tray/watcher.cpp
index 7ac87975..044ef03c 100644
--- a/src/panel/widgets/tray/watcher.cpp
+++ b/src/panel/widgets/tray/watcher.cpp
@@ -29,7 +29,8 @@ static const auto introspection_data = Gio::DBus::NodeInfo::create_for_xml(
         <signal name="StatusNotifierHostRegistered"/>
     </interface>
 </node>
-)")->lookup_interface();
+)")
+    ->lookup_interface();
 
 Watcher::Watcher() :
     dbus_name_id(Gio::DBus::own_name(Gio::DBus::BusType::SESSION, SNW_NAME,
diff --git a/src/panel/widgets/tray/watcher.hpp b/src/panel/widgets/tray/watcher.hpp
index 4a71cb4c..8427d385 100644
--- a/src/panel/widgets/tray/watcher.hpp
+++ b/src/panel/widgets/tray/watcher.hpp
@@ -18,15 +18,13 @@ class Watcher
     /*!
      * Initializes and launches the watcher, if needed.
      *
-     * Returns a shared pointer to the instance.
-     * Once there are no alive shared pointers to the instance,
-     * the Watcher is automatically destroyed.
+     * Returns a shared pointer to the instance. Once there are no alive shared pointers to the instance, the
+     * Watcher is automatically destroyed.
      */
     static std::shared_ptr<Watcher> Launch();
 
     /*!
-     * Returns a pointer to the Watcher's instance if it exists
-     * or an empty `shared_ptr` otherwise.
+     * Returns a pointer to the Watcher's instance if it exists or an empty `shared_ptr` otherwise.
      */
     static std::shared_ptr<Watcher> Instance();
 
diff --git a/src/panel/widgets/volume.cpp b/src/panel/widgets/volume.cpp
index d6bd8034..c3922452 100644
--- a/src/panel/widgets/volume.cpp
+++ b/src/panel/widgets/volume.cpp
@@ -1,9 +1,6 @@
 #include <gtkmm.h>
-#include <iostream>
 #include <glibmm.h>
 #include "volume.hpp"
-#include "launchers.hpp"
-#include "gtk-utils.hpp"
 
 WayfireVolumeScale::WayfireVolumeScale()
 {
@@ -195,8 +192,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..2519d15b 100644
--- a/src/panel/widgets/volume.hpp
+++ b/src/panel/widgets/volume.hpp
@@ -2,16 +2,13 @@
 #define WIDGETS_VOLUME_HPP
 
 #include "../widget.hpp"
-#include "wf-popover.hpp"
 #include <gtkmm/image.h>
-#include <gtkmm/scale.h>
 #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.
+ * A custom scale which animates transitions when its value is changed programatically.
  */
 class WayfireVolumeScale : public Gtk::Scale
 {
@@ -71,9 +68,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 +90,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/window-list/toplevel.cpp b/src/panel/widgets/window-list/toplevel.cpp
index a811f3fd..b8faf3f5 100644
--- a/src/panel/widgets/window-list/toplevel.cpp
+++ b/src/panel/widgets/window-list/toplevel.cpp
@@ -194,8 +194,8 @@ class WayfireToplevel::impl
     static constexpr int DRAG_THRESHOLD = 3;
     void on_drag_update(double _x, double y)
     {
-        /* Window was not just clicked, but also dragged. Ignore the next click,
-         * which is the one that happens when the drag gesture ends. */
+        /* Window was not just clicked, but also dragged. Ignore the next click, which is the one that happens
+         * when the drag gesture ends. */
         set_ignore_next_click();
 
         int x = _x + grab_start_x;
@@ -229,8 +229,7 @@ class WayfireToplevel::impl
             }
         }
 
-        /* Make sure the grabbed button always stays at the same relative position
-         * to the DnD position */
+        /* Make sure the grabbed button always stays at the same relative position to the DnD position */
         int target_x = x - grab_off_x;
         window_list->set_top_x(target_x);
     }
@@ -245,18 +244,16 @@ class WayfireToplevel::impl
         window_list->set_top_widget(nullptr);
         set_classes(state);
 
-        /* When a button is dropped after dnd, we ignore the unclick
-         * event so action doesn't happen in addition to dropping.
-         * If the drag ends and the unclick event happens outside
-         * the button, unset ignore_next_click or else the next
-         * click on the button won't cause action. */
+        /* When a button is dropped after dnd, we ignore the unclick event so action doesn't happen in
+         * addition to dropping. If the drag ends and the unclick event happens outside the button, unset
+         * ignore_next_click or else the next click on the button won't cause action. */
         if ((x < 0) || (x > width) || (y < 0) || (y > height))
         {
             unset_ignore_next_click();
         }
 
-        /* When dragging with touch or pen, we allow some small movement while
-         * still counting the action as button press as opposed to only dragging. */
+        /* When dragging with touch or pen, we allow some small movement while still counting the action as
+         * button press as opposed to only dragging. */
         if (!drag_exceeds_threshold)
         {
             unset_ignore_next_click();
@@ -314,8 +311,8 @@ class WayfireToplevel::impl
     {
         ignore_next_click = true;
 
-        /* Make sure that the view doesn't show clicked on animations while
-         * dragging (this happens only on some themes) */
+        /* Make sure that the view doesn't show clicked on animations while dragging (this happens only on
+         * some themes) */
         button.set_state_flags(Gtk::StateFlags::SELECTED |
             Gtk::StateFlags::DROP_ACTIVE | Gtk::StateFlags::PRELIGHT);
     }
@@ -329,8 +326,8 @@ class WayfireToplevel::impl
 
     void on_clicked()
     {
-        /* If the button was dragged, we don't want to register the click.
-         * Subsequent clicks should be handled though. */
+        /* If the button was dragged, we don't want to register the click. Subsequent clicks should be handled
+         * though. */
         if (ignore_next_click)
         {
             unset_ignore_next_click();
@@ -559,8 +556,7 @@ static void handle_toplevel_output_leave(void *data, toplevel_t, wl_output *outp
     impl->handle_output_leave(output);
 }
 
-/* wl_array_for_each isn't supported in C++, so we have to manually
- * get the data from wl_array, see:
+/* wl_array_for_each isn't supported in C++, so we have to manually get the data from wl_array, see:
  *
  * https://gitlab.freedesktop.org/wayland/wayland/issues/34 */
 template<class T>
@@ -681,8 +677,8 @@ std::string tolower(std::string str)
 
 /* Gio::DesktopAppInfo
  *
- * Usually knowing the app_id, we can get a desktop app info from Gio
- * The filename is either the app_id + ".desktop" or lower_app_id + ".desktop" */
+ * Usually knowing the app_id, we can get a desktop app info from Gio The filename is either the app_id +
+ * ".desktop" or lower_app_id + ".desktop" */
 Icon get_from_desktop_app_info(std::string app_id)
 {
     Glib::RefPtr<Gio::DesktopAppInfo> app_info;
@@ -724,8 +720,7 @@ Icon get_from_desktop_app_info(std::string app_id)
     return Icon{};
 }
 
-/* Second method: Just look up the built-in icon theme,
- * perhaps some icon can be found there */
+/* Second method: Just look up the built-in icon theme, perhaps some icon can be found there */
 
 void set_image_from_icon(Gtk::Image& image,
     std::string app_id_list, int size, int scale)
@@ -733,8 +728,8 @@ void set_image_from_icon(Gtk::Image& image,
     std::string app_id;
     std::istringstream stream(app_id_list);
 
-    /* Wayfire sends a list of app-id's in space separated format, other compositors
-     * send a single app-id, but in any case this works fine */
+    /* Wayfire sends a list of app-id's in space separated format, other compositors send a single app-id, but
+     * in any case this works fine */
     auto display = image.get_display();
     while (stream >> app_id)
     {
@@ -742,8 +737,8 @@ void set_image_from_icon(Gtk::Image& image,
         std::string icon_name = "unknown";
         if (!icon)
         {
-            /* Perhaps no desktop app info, but we might still be able to
-             * get an icon directly from the icon theme */
+            /* Perhaps no desktop app info, but we might still be able to get an icon directly from the icon
+             * theme */
             if (Gtk::IconTheme::get_for_display(display)->lookup_icon(app_id, size))
             {
                 icon_name = app_id;
diff --git a/src/panel/widgets/window-list/toplevel.hpp b/src/panel/widgets/window-list/toplevel.hpp
index 36c98838..1fe603fc 100644
--- a/src/panel/widgets/window-list/toplevel.hpp
+++ b/src/panel/widgets/window-list/toplevel.hpp
@@ -20,8 +20,8 @@ enum WayfireToplevelState
     WF_TOPLEVEL_STATE_MINIMIZED = (1 << 2),
 };
 
-/* Represents a single opened toplevel window.
- * It displays the window icon on all outputs' docks that it is visible on */
+/* Represents a single opened toplevel window. It displays the window icon on all outputs' docks that it is
+ * visible on */
 class WayfireToplevel
 {
   public:
diff --git a/src/panel/widgets/window-list/window-list.cpp b/src/panel/widgets/window-list/window-list.cpp
index 3e67f111..55f66829 100644
--- a/src/panel/widgets/window-list/window-list.cpp
+++ b/src/panel/widgets/window-list/window-list.cpp
@@ -4,7 +4,6 @@
 
 #include "toplevel.hpp"
 #include "window-list.hpp"
-#include "panel.hpp"
 
 #define DEFAULT_SIZE_PC 0.1
 
@@ -84,8 +83,8 @@ void WayfireWindowList::set_top_widget(Gtk::Widget *top)
 
     if (layout->top_widget)
     {
-        /* Set original top_x to where the widget currently is, so that we don't
-         * mess with it before the real position is set */
+        /* Set original top_x to where the widget currently is, so that we don't mess with it before the real
+         * position is set */
         this->layout->top_x = get_absolute_position(0, *top);
     }
 
@@ -133,8 +132,7 @@ Gtk::Widget*WayfireWindowList::get_widget_before(int x)
 {
     Gtk::Allocation given_point{x, get_allocated_height() / 2, 1, 1};
 
-    /* Widgets are stored bottom to top, so we will return the bottom-most
-     * widget at the given position */
+    /* Widgets are stored bottom to top, so we will return the bottom-most widget at the given position */
     Gtk::Widget *previous = nullptr;
     auto children = this->get_children();
     for (auto& child : children)
@@ -159,8 +157,7 @@ Gtk::Widget*WayfireWindowList::get_widget_at(int x)
 {
     Gtk::Allocation given_point{x, get_allocated_height() / 2, 1, 1};
 
-    /* Widgets are stored bottom to top, so we will return the bottom-most
-     * widget at the given position */
+    /* Widgets are stored bottom to top, so we will return the bottom-most widget at the given position */
     auto children = this->get_children();
     for (auto& child : children)
     {
diff --git a/src/panel/widgets/window-list/window-list.hpp b/src/panel/widgets/window-list/window-list.hpp
index f38c64ab..30fe691a 100644
--- a/src/panel/widgets/window-list/window-list.hpp
+++ b/src/panel/widgets/window-list/window-list.hpp
@@ -36,32 +36,28 @@ class WayfireWindowList : public Gtk::Box, public WayfireWidget
     void add_output(WayfireOutput *output);
 
     /**
-     * Set the widget which should always be rendered on top of the other child
-     * widgets */
+     * Set the widget which should always be rendered on top of the other child widgets */
     void set_top_widget(Gtk::Widget *top = nullptr);
     /** Set the absolute position of the top widget */
     void set_top_x(int x);
 
     /**
      * @param x the x-axis position, relative to ref
-     * @param ref The widget that x is relative to. ref must be a child
-     * widget of this box
+     * @param ref The widget that x is relative to. ref must be a child widget of this box
      * @return the position x, but relative to the box
      */
     int get_absolute_position(int x, Gtk::Widget& ref);
 
-    /** Find the direct child widget at the given box-relative coordinates,
-     * ignoring the top widget if possible, i.e if the top widget and some
-     * other widget are at the given coordinates, then the bottom widget will
-     * be returned
+    /** Find the direct child widget at the given box-relative coordinates, ignoring the top widget if
+     * possible, i.e if the top widget and some other widget are at the given coordinates, then the bottom
+     * widget will be returned
      *
      * @return The direct child widget or none if it doesn't exist
      */
     Gtk::Widget *get_widget_at(int x);
-    /** Find the direct child widget before the given box-relative coordinates,
-     * ignoring the top widget if possible, i.e if the top widget and some
-     * other widget are at the given coordinates, then the bottom widget will
-     * be returned
+    /** Find the direct child widget before the given box-relative coordinates, ignoring the top widget if
+     * possible, i.e if the top widget and some other widget are at the given coordinates, then the bottom
+     * widget will be returned
      *
      * @return The direct child widget or none if it doesn't exist
      */
diff --git a/src/util/gtk-utils.cpp b/src/util/gtk-utils.cpp
index 80cec7b5..1fb083fe 100644
--- a/src/util/gtk-utils.cpp
+++ b/src/util/gtk-utils.cpp
@@ -72,3 +72,38 @@ void image_set_icon(Gtk::Image *image, std::string path)
         image->set_from_icon_name(path);
     }
 }
+
+void apply_rotation(Gtk::Widget& widget, std::string rotation)
+{
+    // doing this allows having rotated wigdets without a css file, with the Gtk::Widget::set_angle now being
+    // deprecated
+    static auto orientation_css =
+        R"(
+		.left {
+			transform: rotate(270deg);
+		}
+		.right {
+			transform: rotate(90deg);
+		}
+	)";
+    auto orientation_provider = Gtk::CssProvider::create();
+    orientation_provider->load_from_data(orientation_css);
+    Gtk::StyleContext::add_provider_for_display(Gdk::Display::get_default(), orientation_provider,
+        GTK_STYLE_PROVIDER_PRIORITY_USER);
+
+    if (widget.get_style_context()->has_class(ROTATION_LEFT))
+    {
+        widget.get_style_context()->remove_class(ROTATION_LEFT);
+    } else if (widget.get_style_context()->has_class(ROTATION_RIGHT))
+    {
+        widget.get_style_context()->remove_class(ROTATION_RIGHT);
+    }
+
+    if (rotation == ROTATION_LEFT)
+    {
+        widget.get_style_context()->add_class(ROTATION_LEFT);
+    } else if (rotation == ROTATION_RIGHT)
+    {
+        widget.get_style_context()->add_class(ROTATION_RIGHT);
+    }
+}
diff --git a/src/util/gtk-utils.hpp b/src/util/gtk-utils.hpp
index 0272f2bf..60a7d4d8 100644
--- a/src/util/gtk-utils.hpp
+++ b/src/util/gtk-utils.hpp
@@ -22,4 +22,9 @@ void invert_pixbuf(Glib::RefPtr<Gdk::Pixbuf>& pbuff);
 
 void image_set_icon(Gtk::Image *image, std::string path);
 
+#define ROTATION_LEFT "left"
+#define ROTATION_RIGHT "right"
+
+void apply_rotation(Gtk::Widget& widget, std::string rotation);
+
 #endif /* end of include guard: WF_GTK_UTILS */
diff --git a/src/util/wf-autohide-window.cpp b/src/util/wf-autohide-window.cpp
index 96155640..97fe0b80 100644
--- a/src/util/wf-autohide-window.cpp
+++ b/src/util/wf-autohide-window.cpp
@@ -10,15 +10,14 @@
 #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"}},
+    autohide_animation{WfOption<int>{section + "/autohide_duration"}},
     edge_offset{section + "/edge_offset"},
-    autohide_opt{section + "/autohide"}
+    autohide_opt{section + "/autohide"},
+    autohide_show_delay{section + "/autohide_show_delay"},
+    autohide_hide_delay{section + "/autohide_hide_delay"}
 {
     this->output = output;
     this->set_decorated(false);
@@ -39,7 +38,7 @@ 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([=]
@@ -47,7 +46,7 @@ WayfireAutohidingWindow::WayfireAutohidingWindow(WayfireOutput *output,
         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);
@@ -111,6 +110,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 +137,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 +160,7 @@ void WayfireAutohidingWindow::m_show_uncertain()
         {
             schedule_hide(0);
             return false;
-        }, AUTOHIDE_HIDE_DELAY);
+        }, autohide_hide_delay);
     }
 }
 
@@ -150,6 +169,8 @@ 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);
@@ -160,8 +181,17 @@ void WayfireAutohidingWindow::update_position()
         return;
     }
 
+    // need different measurements depending on position
+    if (anchor == GTK_LAYER_SHELL_EDGE_LEFT or anchor == 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();
@@ -191,25 +221,36 @@ static zwf_hotspot_v2_listener hotspot_listener = {
 };
 
 /**
- * An autohide window needs 2 hotspots.
- * One of them is used to trigger autohide and is generally a tiny strip on the
- * edge of the output.
+ * An autohide window needs 2 hotspots. One of them is used to trigger autohide and is generally a tiny strip
+ * on the edge of the output.
  *
- * 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.
+ * 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.
  */
 
 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))
+
+    auto position = check_position(this->position);
+
+    int allocated;
+    if (position == WF_WINDOW_POSITION_LEFT or position == WF_WINDOW_POSITION_RIGHT)
     {
-        return;
+        allocated = this->get_allocated_width();
+    } else
+    {
+        allocated = this->get_allocated_height();
     }
 
-    this->last_hotspot_height = get_allocated_height();
-    this->last_edge_offset    = edge_offset;
+    if ((allocated == last_hotspot_size) && (edge_offset == last_edge_offset) && (position == last_position))
+    {
+        return;
+    }
 
+    this->last_hotspot_size = allocated;
+    this->last_edge_offset  = edge_offset;
+    this->last_position     = position;
     if (this->edge_hotspot)
     {
         zwf_hotspot_v2_destroy(edge_hotspot);
@@ -220,15 +261,26 @@ void WayfireAutohidingWindow::setup_hotspot()
         zwf_hotspot_v2_destroy(panel_hotspot);
     }
 
-    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;
+    uint32_t edge;
+    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_offset, autohide_show_delay);
 
     this->panel_hotspot = zwf_output_v2_create_hotspot(output->output,
-        edge, this->get_allocated_height(), 0); // immediate
+        edge, allocated, 0); // immediate
 
     this->edge_callbacks =
         std::make_unique<WayfireAutohidingWindowHotspotCallbacks>();
@@ -261,7 +313,7 @@ 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);
         }
     };
 
@@ -329,7 +381,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)());
     start_draw_timer();
     update_margin();
     return false; // disconnect
@@ -345,7 +397,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)
@@ -366,7 +418,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
@@ -390,10 +442,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), 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())
@@ -430,12 +482,12 @@ void WayfireAutohidingWindow::set_active_popover(WayfireMenuButton& button)
     /*
      *  if (should_grab_focus)
      *  {
-     *   // First, set exclusive mode to grab input
-     *   gtk_layer_set_keyboard_mode(this->gobj(), GTK_LAYER_SHELL_KEYBOARD_MODE_EXCLUSIVE);
+     *   // First, set exclusive mode to grab input gtk_layer_set_keyboard_mode(this->gobj(),
+     * GTK_LAYER_SHELL_KEYBOARD_MODE_EXCLUSIVE);
      *   wl_surface_commit(get_wl_surface());
      *
      *   // Next, allow releasing of focus when clicking outside of the panel
-     *   gtk_layer_set_keyboard_mode(this->gobj(), GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND);
+     * gtk_layer_set_keyboard_mode(this->gobj(), GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND);
      *  }
      */
     // TODO come back for intentional focus steal
@@ -460,7 +512,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..5788b6b2 100644
--- a/src/util/wf-autohide-window.hpp
+++ b/src/util/wf-autohide-window.hpp
@@ -12,6 +12,8 @@ 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 +25,11 @@ 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 5.
+     * section/autohide_show_delay 6. section/autohide_hide_delay
      *
-     * 1. section/position
-     * 2. section/autohide_duration
-     * 3. section/edge_offset
-     * 4. section/autohide
      */
     WayfireAutohidingWindow(WayfireOutput *output, const std::string& section);
     WayfireAutohidingWindow(WayfireAutohidingWindow&&) = delete;
@@ -47,32 +47,29 @@ 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);
 
-    /** When auto exclusive zone is set, the window will adjust its exclusive
-     * zone based on the window size.
+    /** When auto exclusive zone is set, the window will adjust its exclusive zone based on the window size.
      *
      * Note that autohide margin isn't taken into account. */
     void set_auto_exclusive_zone(bool has_zone = false);
 
     /**
-     * Set the currently active popover button.
-     * The lastly activated popover, if any, will be closed, in order to
-     * show this new one.
+     * Set the currently active popover button. 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.
+     * In addition, if the window has an active popover, it will grab the keyboard input and deactivate the
+     * popover when the focus is lost.
      */
     void set_active_popover(WayfireMenuButton& button);
 
     /**
      * No-op if the given popover is not the currently active popover.
      *
-     * Unsets the currently active popover and reverses the effects of setting
-     * making it active with set_active_popover()
+     * Unsets the currently active popover and reverses the effects of setting making it active with
+     * set_active_popover()
      */
     void unset_active_popover(WayfireMenuButton& popover);
 
@@ -82,13 +79,17 @@ class WayfireAutohidingWindow : public Gtk::Window
     WfOption<std::string> position;
     void update_position();
 
-    wf::animation::simple_animation_t y_position;
+    wf::animation::simple_animation_t autohide_animation;
+    int (Gtk::Widget::*get_allocated_height_or_width)() const;
     bool update_margin();
 
     WfOption<int> edge_offset;
     int last_edge_offset = -1;
 
     WfOption<bool> autohide_opt;
+    WfOption<int> autohide_show_delay;
+    WfOption<int> autohide_hide_delay;
+
     bool last_autohide_value = autohide_opt;
     void setup_autohide();
     void update_autohide();
@@ -109,8 +110,9 @@ 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;
+    std::string last_position = "";
+    int32_t last_hotspot_size = -1;
+    bool input_inside_panel   = false;
     zwf_hotspot_v2 *edge_hotspot  = NULL;
     zwf_hotspot_v2 *panel_hotspot = NULL;
     std::unique_ptr<WayfireAutohidingWindowHotspotCallbacks> edge_callbacks;
diff --git a/src/util/wf-option-wrap.hpp b/src/util/wf-option-wrap.hpp
index 562a189e..99130a3f 100644
--- a/src/util/wf-option-wrap.hpp
+++ b/src/util/wf-option-wrap.hpp
@@ -4,8 +4,7 @@
 #include "wf-shell-app.hpp"
 
 /**
- * An implementation of wf::base_option_wrapper_t for wf-shell-app based
- * programs.
+ * An implementation of wf::base_option_wrapper_t for wf-shell-app based programs.
  */
 template<class Type>
 class WfOption : public wf::base_option_wrapper_t<Type>
diff --git a/src/util/wf-popover.cpp b/src/util/wf-popover.cpp
index a12c0ed7..946e70f4 100644
--- a/src/util/wf-popover.cpp
+++ b/src/util/wf-popover.cpp
@@ -1,6 +1,6 @@
 #include "wf-popover.hpp"
+#include "gtkmm/enums.h"
 #include "wf-autohide-window.hpp"
-#include <iostream>
 
 WayfireMenuButton::WayfireMenuButton(const std::string& section) :
     panel_position{section + "/position"}
@@ -10,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 ((std::string)panel_position == "top")
+        {
+            set_direction(Gtk::ArrowType::DOWN);
+        } else if ((std::string)panel_position == "bottom")
+        {
+            set_direction(Gtk::ArrowType::UP);
+        } else if ((std::string)panel_position == "left")
+        {
+            set_direction(Gtk::ArrowType::RIGHT);
+        } else if ((std::string)panel_position == "right")
+        {
+            set_direction(Gtk::ArrowType::LEFT);
+        }
 
         this->unset_popover();
         // m_popover.set_constrain_to(Gtk::POPOVER_CONSTRAINT_NONE);
diff --git a/src/util/wf-popover.hpp b/src/util/wf-popover.hpp
index 17ba17bd..dac14633 100644
--- a/src/util/wf-popover.hpp
+++ b/src/util/wf-popover.hpp
@@ -6,8 +6,8 @@
 #include <wf-option-wrap.hpp>
 
 /**
- * A button which shows a popover on click. It adjusts the popup position
- * automatically based on panel position (valid values are "top" and "bottom")
+ * A button which shows a popover on click. It adjusts the popup position automatically based on panel
+ * position (valid values are "top" and "bottom")
  */
 class WayfireMenuButton : public Gtk::MenuButton
 {
@@ -30,8 +30,8 @@ class WayfireMenuButton : public Gtk::MenuButton
     {}
 
     /**
-     * Set whether the popup should grab input focus when opened
-     * By default, the menu button interacts with the keyboard.
+     * Set whether the popup should grab input focus when opened By default, the menu button interacts with
+     * the keyboard.
      */
     void set_keyboard_interactive(bool interactive = true);
 
@@ -42,8 +42,7 @@ class WayfireMenuButton : public Gtk::MenuButton
     bool is_popover_focused() const;
 
     /**
-     * Grab the keyboard focus.
-     * Also sets the popover to keyboard interactive.
+     * Grab the keyboard focus. Also sets the popover to keyboard interactive.
      *
      * NOTE: this works only if the popover was already opened.
      */
diff --git a/src/util/wf-shell-app.hpp b/src/util/wf-shell-app.hpp
index 44c1357b..9809e108 100644
--- a/src/util/wf-shell-app.hpp
+++ b/src/util/wf-shell-app.hpp
@@ -29,8 +29,7 @@ struct WayfireOutput
 /**
  * A basic shell application.
  *
- * It is suitable for applications that need to show one or more windows
- * per monitor.
+ * It is suitable for applications that need to show one or more windows per monitor.
  */
 class WayfireShellApp
 {
@@ -39,8 +38,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 */
     static std::unique_ptr<WayfireShellApp> instance;
     std::optional<std::string> cmdline_config;
     std::optional<std::string> cmdline_css;
@@ -51,8 +49,7 @@ class WayfireShellApp
     virtual void add_output(GMonitor monitor);
     virtual void rem_output(GMonitor monitor);
 
-    /* The following functions can be overridden in the shell implementation to
-     * handle the events */
+    /* The following functions can be overridden in the shell implementation to handle the events */
     virtual void on_activate();
     virtual bool parse_cfgfile(const Glib::ustring & option_name,
         const Glib::ustring & value, bool has_value);
@@ -60,6 +57,7 @@ class WayfireShellApp
         const Glib::ustring & value, bool has_value);
     virtual void handle_new_output(WayfireOutput *output)
     {}
+
     virtual void handle_output_removed(WayfireOutput *output)
     {}
 
@@ -78,15 +76,15 @@ class WayfireShellApp
 
     virtual void on_config_reload()
     {}
+
     void on_css_reload();
     void clear_css_rules();
     void add_css_file(std::string file, int priority);
 
 
     /**
-     * WayfireShellApp is a singleton class.
-     * Using this function, any part of the application can get access to the
-     * shell app.
+     * WayfireShellApp is a singleton class. Using this function, any part of the application can get access
+     * to the shell app.
      */
     static WayfireShellApp& get();
 };
diff --git a/wf-shell.ini.example b/wf-shell.ini.example
index d381b4cf..b5eb9d76 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