diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 878be36d..bacec687 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -9,7 +9,7 @@ jobs:
     steps:
       - run: echo 'http://dl-cdn.alpinelinux.org/alpine/v3.22/community' > /etc/apk/repositories
       - run: echo 'http://dl-cdn.alpinelinux.org/alpine/v3.22/main' >> /etc/apk/repositories
-      - run: apk --no-cache add git g++ binutils pkgconf meson ninja musl-dev gtkmm4-dev vala gobject-introspection gobject-introspection-dev pulseaudio-dev wireplumber-dev libdbusmenu-glib-dev alsa-lib-dev yyjson-dev
+      - run: apk --no-cache add git g++ binutils pkgconf meson ninja musl-dev gtkmm4-dev vala gobject-introspection gobject-introspection-dev pulseaudio-dev wireplumber-dev libdbusmenu-glib-dev alsa-lib-dev yyjson-dev linux-pam-dev util-linux-login openssl-dev
       - run: echo 'http://dl-cdn.alpinelinux.org/alpine/edge/testing' >> /etc/apk/repositories
       - run: echo 'http://dl-cdn.alpinelinux.org/alpine/edge/main' >> /etc/apk/repositories
       - run: apk --no-cache add wayland-protocols wayfire-dev gtk4-layer-shell-dev gtk4-layer-shell
diff --git a/data/css/default.css b/data/css/default.css
index eed40763..a1005ba8 100644
--- a/data/css/default.css
+++ b/data/css/default.css
@@ -146,6 +146,39 @@
     animation-fill-mode: forwards;
 }
 
+.wf-locker .password{
+    padding: 10px;
+    border-radius: 10px;
+    background: #0004;
+}
+.wf-locker .fingerprint-overlay-image {
+    -gtk-icon-size: 64px;
+}
+.wf-locker .fingerprint-overlay-image.good {
+    color: #0f0;
+}
+.wf-locker .fingerprint-overlay-image.bad {
+    color: #f00;
+}
+.wf-locker .fingerprint-overlay-image.info {
+    color: #88f;
+}
+.wf-locker .mpris image.albumart {
+    -gtk-icon-size:96px;
+}
+.wf-locker .user image{
+    -gtk-icon-size:96px;
+}
+.wf-locker image.weather {
+    -gtk-icon-size:80px;
+    padding-left: 25px;
+    padding-right: 25px;
+    padding-bottom: 25px;
+}
+.wf-locker label.weather {
+    padding-left: 25px;
+}
+
 @keyframes embiggen {
     to {
         -gtk-icon-size: 64px;
diff --git a/data/meson.build b/data/meson.build
index a06c63fb..e35455ef 100644
--- a/data/meson.build
+++ b/data/meson.build
@@ -1,5 +1,6 @@
 install_data('wayfire.png', install_dir: icon_dir)
 install_data('wallpaper.jpg', install_dir: resource_dir)
+install_data('wf-locker-pin.desktop', install_dir: join_paths(get_option('prefix'), 'share', 'applications'))
 
 install_data(join_paths('icons', '48x48', 'wayfire.png'), install_dir: join_paths(get_option('prefix'), 'share', 'icons', 'hicolor', '48x48', 'apps'))
 install_data(join_paths('icons', '64x64', 'wayfire.png'), install_dir: join_paths(get_option('prefix'), 'share', 'icons', 'hicolor', '64x64', 'apps'))
@@ -12,4 +13,6 @@ install_data(join_paths('icons', '256x256', 'wayfire.png'), install_dir: join_pa
 install_data(join_paths('icons', '512x512', 'wayfire.png'), install_dir: join_paths(get_option('prefix'), 'share', 'icons', 'hicolor', '512x512', 'apps'))
 install_data(join_paths('icons', 'scalable', 'wayfire.svg'), install_dir: join_paths(get_option('prefix'), 'share', 'icons', 'hicolor', 'scalable', 'apps'))
 
+install_data('wf-locker-password', install_dir:'/etc/pam.d/')
+
 subdir('css')
\ No newline at end of file
diff --git a/data/wf-locker-password b/data/wf-locker-password
new file mode 100644
index 00000000..c1355e38
--- /dev/null
+++ b/data/wf-locker-password
@@ -0,0 +1 @@
+auth include login
diff --git a/data/wf-locker-pin.desktop b/data/wf-locker-pin.desktop
new file mode 100644
index 00000000..beffbf1b
--- /dev/null
+++ b/data/wf-locker-pin.desktop
@@ -0,0 +1,9 @@
+[Desktop Entry]
+Version=1.0
+Type=Application
+Exec=wf-locker-pin
+Icon=lock-symbolic
+Terminal=false
+Name=Wf Shell Change PIN
+Categories=Utility;Settings;DesktopSettings;
+NotShowIn=GNOME;KDE;
\ No newline at end of file
diff --git a/meson.build b/meson.build
index 50d6dc66..e472534f 100644
--- a/meson.build
+++ b/meson.build
@@ -14,6 +14,7 @@ project(
 )
 
 wayfire = dependency('wayfire')
+pam = dependency('pam')
 wayland_client = dependency('wayland-client')
 wayland_protos = dependency('wayland-protocols')
 gtkmm = dependency('gtkmm-4.0', version: '>=4.12')
@@ -26,6 +27,7 @@ dbusmenu_gtk = dependency('dbusmenu-glib-0.4')
 libgvc = subproject('gvc', default_options: ['static=true'], required: get_option('pulse'))
 xkbregistry = dependency('xkbregistry')
 json = subproject('wf-json').get_variable('wfjson')
+openssl = dependency('openssl')
 
 if get_option('wayland-logout') == true
 	wayland_logout = subproject('wayland-logout')
diff --git a/metadata/background.xml.in b/metadata/background.xml.in
index be3f88e8..cdf9e6ce 100644
--- a/metadata/background.xml.in
+++ b/metadata/background.xml.in
@@ -21,6 +21,10 @@
 		<_short>Randomize</_short>
 		<default>false</default>
 	</option>
+	<option name="blank" type="bool">
+		<_short>Blank screen on startup</_short>
+		<default>true</default>
+	</option>
 	<option name="fill_mode" type="string">
 		<_short>Fill mode</_short>
 		<default>stretch</default>
diff --git a/metadata/locker.xml b/metadata/locker.xml
new file mode 100644
index 00000000..88de6115
--- /dev/null
+++ b/metadata/locker.xml
@@ -0,0 +1,734 @@
+<?xml version="1.0"?>
+<wf-shell>
+	<plugin name="locker">
+	<_short>Locker</_short>
+	<category>Shell</category>
+	<group>
+	<_short>General</_short>
+	<option name="background_image" type="bool">
+		<_short>Use wf-background image</_short>
+		<default>true</default>
+	</option>
+	<option name="background_color" type="string">
+		<_short>Background Color</_short>
+		<default>gtk_headerbar</default>
+	</option>
+	<option name="hide_time" type="double">
+		<_short>Hide contents when inactive</_short>
+		<_long>When no user input is detected, hide the unlock controls. 0.0 means never. Time is in seconds</_long>
+		<default>5.0</default>
+		<min>0</min>
+	</option>
+	<option name="hide_anim" type="int">
+		<_short>Hide contents animation</_short>
+		<default>1</default>
+		<desc>
+			<value>0</value>
+			<_name>None</_name>
+		</desc>
+		<desc>
+			<value>1</value>
+			<_name>Fade</_name>
+		</desc>
+		<desc>
+			<value>2</value>
+			<_name>Slide Down</_name>
+		</desc>
+		<desc>
+			<value>3</value>
+			<_name>Slide Left</_name>
+		</desc>
+		<desc>
+			<value>4</value>
+			<_name>Slide Right</_name>
+		</desc>
+		<desc>
+			<value>5</value>
+			<_name>Slide Up</_name>
+		</desc>
+		<desc>
+			<value>6</value>
+			<_name>Swing Down</_name>
+		</desc>
+		<desc>
+			<value>7</value>
+			<_name>Swing Left</_name>
+		</desc>
+		<desc>
+			<value>8</value>
+			<_name>Swing Right</_name>
+		</desc>
+		<desc>
+			<value>9</value>
+			<_name>Swing Up</_name>
+		</desc>
+	</option>
+	<option name="hide_anim_dur" type="double">
+		<_short>Hide contents duration</_short>
+		<_long>Seconds to animate hide/show of inactive windows</_long>
+		<default>0.400</default>
+		<min>0.0</min>
+	</option>
+	<option name="prewake" type="double">
+		<_short>Early instant unlock</_short>
+		<_long>If the user moves mouse or presses a key within this many milliseconds of lock, instantly unlock</_long>
+		<default>1.0</default>
+		<min>0</min>
+		<max>9.0</max>
+	</option>
+	<option name="lockout_attempts" type="int">
+		<_short>Lock after failed attempts</_short>
+		<default>5</default>
+		<min>1</min>
+	</option>
+	<option name="lockout_timer" type="int">
+		<_short>Lockout time</_short>
+		<default>10</default>
+		<min>10</min>
+	</option>
+	</group>
+	<group>
+	<_short>Password</_short>
+	<option name="password_enable" type="bool">
+		<_short>Enable</_short>
+		<_long>Show a password entry field to unlock with a keyboard</_long>
+		<default>true</default>
+	</option>
+	<option name="password_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>center-center</default>
+	</option>
+	<option name="password_always" type="bool">
+	    <_short>Always show</_short>
+		<default>false</default>
+	</option>
+	</group>
+	<group>
+	<_short>PIN</_short>
+	<option name="pin_enable" type="bool">
+		<_short>Enable</_short>
+		<_long>Show a PIN pad and authenticate against users chosen PIN</_long>
+		<default>true</default>
+	</option>
+	<option name="pin_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>bottom-center</default>
+	</option>
+	<option name="pin_pad_font" type="string">
+		<_short>Pin Pad Font</_short>
+		<default>32pt default</default>
+	</option>
+	<option name="pin_reply_font" type="string">
+		<_short>Pin Reply Font</_short>
+		<default>20pt default</default>
+	</option>
+	<option name="pin_always" type="bool">
+	    <_short>Always show</_short>
+		<default>false</default>
+	</option>
+	</group>
+	<group>
+	<_short>Fingerprint</_short>
+	<option name="fingerprint_enable" type="bool">
+		<_short>Enable</_short>
+		<_long>Allow authentication with fingerprint reader</_long>
+		<default>true</default>
+	</option>
+	<option name="fingerprint_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>center-right</default>
+	</option>
+	<option name="fingerprint_font" type="string">
+		<_short>Fingerprint Reply Font</_short>
+		<default>default</default>
+	</option>
+	<option name="fingerprint_icon_size" type="int">
+		<_short>Fingerprint Icon Size</_short>
+		<default>128</default>
+	</option>
+	<option name="fingerprint_always" type="bool">
+	    <_short>Always show</_short>
+		<default>false</default>
+	</option>
+	</group>
+	<group>
+	<_short>Network</_short>
+	<option name="network_enable" type="bool">
+		<_short>Enable</_short>
+		<default>true</default>
+	</option>
+	<option name="network_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>top-right</default>
+	</option>
+	<option name="network_always" type="bool">
+	    <_short>Always show</_short>
+	    <default>true</default>	
+	</option>
+	<option name="network_font" type="string">
+		<_short>Clock Font</_short>
+		<default>20pt default</default>
+	</option>
+	<option name="network_icon_size" type="int">
+		<_short>Icon Size</_short>
+		<default>48</default>
+		<min>16</min>
+	</option>
+	</group>
+	<group>
+	<_short>Clock</_short>
+	<option name="clock_enable" type="bool">
+		<_short>Enable</_short>
+		<default>true</default>
+	</option>
+	<option name="clock_format" type="string">
+		<_short>Clock Format</_short>
+		<default>%H:%M%n&lt;span font-size='xx-small'&gt;%e %b %Y&lt;/span&gt;</default>
+	</option>
+	<option name="clock_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>top-center</default>
+	</option>
+	<option name="clock_always" type="bool">
+	    <_short>Always show</_short>
+	    <default>true</default>	
+	</option>
+	<option name="clock_font" type="string">
+		<_short>Clock Font</_short>
+		<default>32pt default</default>
+	</option>
+	</group>
+	<group>
+	<_short>Weather</_short>
+	<option name="weather_enable" type="bool">
+		<_short>Enable</_short>
+		<default>true</default>
+	</option>
+	<option name="weather_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>bottom-left</default>
+	</option>
+	<option name="weather_font" type="string">
+		<_short>Weather Font</_short>
+		<default>64pt default</default>
+	</option>
+	<option name="weather_always" type="bool">
+	    <_short>Always show</_short>
+		<default>true</default>
+	</option>
+	</group>
+	<group>
+	<_short>User</_short>
+	<option name="user_enable" type="bool">
+		<_short>Enable</_short>
+		<default>true</default>
+	</option>
+	<option name="user_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>center-center</default>
+	</option>
+	<option name="user_font" type="string">
+		<_short>Font</_short>
+		<default>16pt default</default>
+	</option>
+	<option name="user_always" type="bool">
+	    <_short>Always show</_short>
+		<default>true</default>
+	</option>
+	</group>
+	<group>
+	<_short>Now Playing</_short>
+	<option name="mpris_enable" type="bool">
+		<_short>Enable</_short>
+		<default>true</default>
+	</option>
+	<option name="mpris_format" type="string">
+		<_short>Format</_short>
+		<_long>What information, and how, to display on lockscreen.
+			%track  : Name of currently playing track
+			%album  : Name of currently playing album
+			%artist : Name of artist of currently playing track
+			%n      : New line
+		</_long>
+		<default>Now Playing:%n%track%n%album%n%artist</default>
+	</option>
+	<option name="mpris_control" type="bool">
+		<_short>Controls</_short>
+		<_long>show buttons to allow play, pause, skip and stop</_long>
+		<default>true</default>
+	</option>
+	<option name="mpris_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>bottom-right</default>
+	</option>
+	<option name="mpris_always" type="bool">
+	    <_short>Always show</_short>
+		<default>false</default>
+	</option>
+	</group>
+	<group>
+	<_short>Battery</_short>
+	<option name="battery_enable" type="bool">
+		<_short>Enable</_short>
+		<default>true</default>
+	</option>
+	<option name="battery_status" type="string">
+		<_short>Battery Status</_short>
+		<default>percentage</default>
+		<desc>
+			<value>icon</value>
+			<_name>Icon</_name>
+		</desc>
+		<desc>
+			<value>percentage</value>
+			<_name>Icon with Percentage</_name>
+		</desc>
+		<desc>
+			<value>full</value>
+			<_name>Full Information</_name>
+		</desc>
+	</option>
+	<option name="battery_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>top-left</default>
+	</option>
+	<option name="battery_percent_font" type="string">
+		<_short>Percent Font</_short>
+		<default>32pt default</default>
+	</option>
+	<option name="battery_description_font" type="string">
+		<_short>Description Font</_short>
+		<default>10pt default</default>
+	</option>
+	<option name="battery_icon_size" type="int">
+		<_short>Icon Size</_short>
+		<default>96</default>
+		<min>16</min>
+	</option>
+	<option name="battery_always" type="bool">
+	    <_short>Always show</_short>
+		<default>true</default>
+	</option>
+	</group>
+	<group>
+	<_short>Volume</_short>
+	<option name="volume_enable" type="bool">
+		<_short>Enable</_short>
+		<default>true</default>
+	</option>
+	<option name="volume_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>top-right</default>
+	</option>
+	<option name="volume_always" type="bool">
+	    <_short>Always show</_short>
+		<default>false</default>
+	</option>
+	</group>
+	<group>
+	<_short>Instant Unlock</_short>
+	<option name="instant_unlock_enable" type="bool">
+		<_short>Enable</_short>
+		<_long>Show a button which unlocks instantly without a password</_long>
+		<default>false</default>
+	</option>
+	<option name="instant_unlock_position" type="string">
+		<desc>
+			<value>top-left</value>
+			<_name>Top Left</_name>
+		</desc>
+		<desc>
+		    <value>top-center</value>
+	        <_name>Top</_name>
+		</desc>
+		<desc>
+			<value>top-right</value>
+			<_name>Top Right</_name>
+		</desc>
+		<desc>
+			<value>center-left</value>
+			<_name>Left</_name>
+		</desc>
+		<desc>
+			<value>center-center</value>
+			<_name>Center</_name>
+		</desc>
+		<desc>
+			<value>center-right</value>
+			<_name>Right</_name>
+		</desc>
+		<desc>
+			<value>bottom-left</value>
+			<_name>Bottom Left</_name>
+		</desc>
+		<desc>
+			<value>bottom-center</value>
+			<_name>Bottom</_name>
+		</desc>
+		<desc>
+			<value>bottom-right</value>
+			<_name>Bottom Right</_name>
+		</desc>
+		<default>bottom-center</default>
+	</option>
+	<option name="instant_unlock_font" type="string">
+		<_short>Font</_short>
+		<default>default</default>
+	</option>
+	<option name="instant_unlock_always" type="bool">
+	    <_short>Always show</_short>
+		<default>false</default>
+	</option>
+	</group>
+	</plugin>
+</wf-shell>
diff --git a/metadata/meson.build b/metadata/meson.build
index eb98e8c2..18c0b544 100644
--- a/metadata/meson.build
+++ b/metadata/meson.build
@@ -7,3 +7,4 @@ configure_file(input: 'background.xml.in', output: 'background.xml',
 
 install_data('dock.xml', install_dir: metadata_dir)
 install_data('panel.xml', install_dir: metadata_dir)
+install_data('locker.xml', install_dir: metadata_dir)
diff --git a/src/background/background.cpp b/src/background/background.cpp
index 759a54d7..ae19f29f 100644
--- a/src/background/background.cpp
+++ b/src/background/background.cpp
@@ -1,332 +1,159 @@
+#include <fcntl.h>
 #include <wordexp.h>
 #include <glibmm/main.h>
 #include <gtkmm.h>
 #include <gdkmm.h>
 #include <gdk/wayland/gdkwayland.h>
-#include <gdk-pixbuf/gdk-pixbuf.h>
-
 #include <random>
 #include <algorithm>
-
 #include <iostream>
+#include <fstream>
 #include <map>
+#include <sys/stat.h>
 
 #include <gtk-utils.hpp>
 #include <gtk4-layer-shell.h>
 #include <glib-unix.h>
 
 #include "background.hpp"
+#include "background-gl.hpp"
 
-
-
-static const char *vertex_shader =
-    R"(
-attribute vec2 in_position;
-
-//uniform mat4 matrix;
-attribute highp vec2 uvpos;
-varying vec2 uv;
-
-void main() {
-    uv = uvpos;
-    gl_Position = vec4(in_position, 0.0, 1.0);
-}
-)";
-
-static const char *fragment_shader =
-    R"(
-precision highp float;
-uniform sampler2D bg_texture_from;
-uniform sampler2D bg_texture_to;
-uniform float progress;
-uniform vec4 from_adj;
-uniform vec4 to_adj;
-
-varying vec2 uv;
-
-void main() {
-    vec2 from_uv = vec2((uv.x * from_adj.z) - from_adj.x, (uv.y * from_adj.w) - from_adj.y);
-    vec2 to_uv = vec2((uv.x * to_adj.z) - to_adj.x, (uv.y * to_adj.w) - to_adj.y);
-    vec4 from = texture2D(bg_texture_from, from_uv);
-    vec4 to = texture2D(bg_texture_to, to_uv);
-    vec3 color = mix(from.rgb, to.rgb, progress);
-    gl_FragColor = vec4(color, 1.0);
-}
-)";
-
-/* Create and compile a shader */
-static GLuint create_shader(int type, const char *src)
+void WayfireBackground::setup_window()
 {
-    GLuint shader;
-    int status;
-
-    shader = glCreateShader(type);
-    glShaderSource(shader, 1, &src, NULL);
-    glCompileShader(shader);
+    gl_area = Glib::RefPtr<BackgroundGLArea>(new BackgroundGLArea());
+    set_decorated(false);
 
-    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
-    if (status == GL_FALSE)
-    {
-        int log_len;
-        char *buffer;
+    gtk_layer_init_for_window(gobj());
+    gtk_layer_set_layer(gobj(), GTK_LAYER_SHELL_LAYER_BACKGROUND);
+    gtk_layer_set_monitor(gobj(), this->output->monitor->gobj());
 
-        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_len);
+    gtk_layer_set_anchor(gobj(), GTK_LAYER_SHELL_EDGE_TOP, true);
+    gtk_layer_set_anchor(gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, true);
+    gtk_layer_set_anchor(gobj(), GTK_LAYER_SHELL_EDGE_LEFT, true);
+    gtk_layer_set_anchor(gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, true);
+    gtk_layer_set_keyboard_mode(gobj(), GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND);
 
-        buffer = (char*)g_malloc(log_len + 1);
-        glGetShaderInfoLog(shader, log_len, NULL, buffer);
+    gtk_layer_set_exclusive_zone(gobj(), -1);
 
-        printf("Compile failure in %s shader:\n%s",
-            type == GL_VERTEX_SHADER ? "vertex" : "fragment",
-            buffer);
-
-        g_free(buffer);
-
-        glDeleteShader(shader);
-
-        return 0;
-    }
-
-    return shader;
+    set_child(*gl_area);
+    present();
 }
 
-/* Initialize the shaders and link them into a program */
-static GLuint init_shaders()
+WayfireBackground::WayfireBackground(WayfireOutput *output)
 {
-    GLuint vertex, fragment;
-    GLuint program = 0;
-    int status;
-
-    vertex = create_shader(GL_VERTEX_SHADER, vertex_shader);
-
-    if (vertex == 0)
-    {
-        return 0;
-    }
-
-    fragment = create_shader(GL_FRAGMENT_SHADER, fragment_shader);
-
-    if (fragment == 0)
-    {
-        glDeleteShader(vertex);
-        return 0;
-    }
-
-    program = glCreateProgram();
-    glAttachShader(program, vertex);
-    glAttachShader(program, fragment);
-
-    glLinkProgram(program);
+    this->output = output;
 
-    glGetProgramiv(program, GL_LINK_STATUS, &status);
-    if (status == GL_FALSE)
+    if (output->output && inhibit_start)
     {
-        int log_len;
-        char *buffer;
-
-        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_len);
-
-        buffer = (char*)g_malloc(log_len + 1);
-        glGetProgramInfoLog(program, log_len, NULL, buffer);
-
-        g_warning("Linking failure:\n%s", buffer);
-
-        g_free(buffer);
-
-        glDeleteProgram(program);
-        program = 0;
-
-        goto out;
+        this->inhibited = true;
+        zwf_output_v2_inhibit_output(output->output);
     }
 
-    glDetachShader(program, vertex);
-    glDetachShader(program, fragment);
-
-out:
-    glDeleteShader(vertex);
-    glDeleteShader(fragment);
-
-    return program;
+    setup_window();
 }
 
-void BackgroundImage::generate_adjustments(int width, int height)
+void WayfireBackground::uninhibit()
 {
-    // Sanity checks
-    if ((width == 0) ||
-        (height == 0) ||
-        (source == nullptr) ||
-        (source->get_width() == 0) ||
-        (source->get_height() == 0))
+    if (inhibited && output->output)
     {
-        return;
+        zwf_output_v2_inhibit_output_done(output->output);
+        inhibited = false;
     }
+}
 
-    double screen_width  = (double)width;
-    double screen_height = (double)height;
-    double source_width  = (double)source->get_width();
-    double source_height = (double)source->get_height();
+WayfireBackground::~WayfireBackground()
+{}
 
-    adjustments = Glib::RefPtr<BackgroundImageAdjustments>(new BackgroundImageAdjustments());
-    std::string fill_and_crop_string = "fill_and_crop";
-    std::string stretch_string = "stretch";
-    if (!stretch_string.compare(fill_type))
-    {
-        adjustments->x = 0.0;
-        adjustments->y = 0.0;
-        adjustments->scale_x = 1.0;
-        adjustments->scale_y = 1.0;
-    } else if (!fill_and_crop_string.compare(fill_type))
-    {
-        auto width_difference  = screen_width - source_width;
-        auto height_difference = screen_height - source_height;
-        if (width_difference > height_difference)
-        {
-            adjustments->scale_x = 1.0;
-            adjustments->scale_y = (screen_height / screen_width) * (source_width / source_height);
-            adjustments->x = 0.0;
-            adjustments->y = (screen_height - source_height * (screen_width / source_width)) *
-                adjustments->scale_y * 0.5 * (1.0 / screen_height);
-        } else
-        {
-            adjustments->scale_x = (screen_width / screen_height) * (source_height / source_width);
-            adjustments->scale_y = 1.0;
-            adjustments->x = (screen_width - source_width * (screen_height / source_height)) *
-                adjustments->scale_x * 0.5 * (1.0 / screen_width);
-            adjustments->y = 0.0;
-        }
-    } else /* "preserve_aspect" */
-    {
-        auto width_difference  = screen_width / source_width;
-        auto height_difference = screen_height / source_height;
-        if (width_difference > height_difference)
-        {
-            adjustments->scale_x = (screen_width / screen_height) * (source_height / source_width);
-            adjustments->scale_y = 1.0;
-            adjustments->x = (screen_width - source_width * (screen_height / source_height)) *
-                adjustments->scale_x * 0.5 * (1.0 / screen_width);
-            adjustments->y = 0.0;
-        } else
-        {
-            adjustments->scale_x = 1.0;
-            adjustments->scale_y = (screen_height / screen_width) * (source_width / source_height);
-            adjustments->x = 0.0;
-            adjustments->y = (screen_height - source_height * (screen_width / source_width)) *
-                adjustments->scale_y * 0.5 * (1.0 / screen_height);
-        }
-    }
+int main(int argc, char **argv)
+{
+    WayfireBackgroundApp::create(argc, argv);
+    return 0;
 }
 
-void BackgroundGLArea::show_image(Glib::RefPtr<BackgroundImage> next_image)
+void WayfireBackgroundApp::create(int argc, char **argv)
 {
-    if (!next_image || !next_image->source ||
-        (background->window_width <= 0) || (background->window_height <= 0))
+    if (instance)
     {
-        to_image   = nullptr;
-        from_image = nullptr;
-        return;
+        throw std::logic_error("Running WayfireBackgroundApp twice!");
     }
 
-    from_image = to_image;
-    to_image   = next_image;
-
-    int width, height;
-
-    to_image->generate_adjustments(background->window_width, background->window_height);
-    width  = to_image->source->get_width();
-    height = to_image->source->get_height();
-    glBindTexture(GL_TEXTURE_2D, to_image->tex_id);
-    auto format = to_image->source->get_has_alpha() ? GL_RGBA : GL_RGB;
-    glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE,
-        to_image->source->get_pixels());
-    glBindTexture(GL_TEXTURE_2D, 0);
-
-    fade = {
-        fade_duration,
-        wf::animation::smoothing::sigmoid
-    };
-    fade.animate(0.0, 1.0);
-
-    this->queue_draw();
+    instance = std::unique_ptr<WayfireShellApp>(new WayfireBackgroundApp{});
+    instance->init_app();
+    g_unix_signal_add(SIGUSR1, sigusr1_handler, (void*)instance.get());
+    instance->run(argc, argv);
 }
 
-static GLuint create_texture()
+void WayfireBackgroundApp::on_activate()
 {
-    GLuint tex;
-
-    glGenTextures(1, &tex);
-    glBindTexture(GL_TEXTURE_2D, tex);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glBindTexture(GL_TEXTURE_2D, 0);
+    WayfireShellApp::on_activate();
 
-    return tex;
+    prep_cache();
+    change_background();
 }
 
-BackgroundImage::BackgroundImage()
+void WayfireBackgroundApp::prep_cache()
 {
-    tex_id = create_texture();
+    char *xdg_runtime_dir = getenv("XDG_RUNTIME_DIR");
+    if (xdg_runtime_dir)
+    {
+        cache_file = std::string(xdg_runtime_dir) + "/wf-background.cache";
+        std::cout << "Using cache file " << this->cache_file << std::endl;
+    } else
+    {
+        std::cout << "Not writing to cache file " << std::endl;
+    }
 }
 
-BackgroundImage::~BackgroundImage()
+void WayfireBackgroundApp::handle_new_output(WayfireOutput *output)
 {
-    glDeleteTextures(1, &tex_id);
+    backgrounds[output] = std::unique_ptr<WayfireBackground>(
+        new WayfireBackground(output));
 }
 
-Glib::RefPtr<BackgroundImage> WayfireBackground::create_from_file_safe(std::string path)
+void WayfireBackgroundApp::handle_output_removed(WayfireOutput *output)
 {
-    Glib::RefPtr<BackgroundImage> image = Glib::RefPtr<BackgroundImage>(new BackgroundImage());
-    image->fill_type = (std::string)background_fill_mode;
-
-    try {
-        image->source = Gdk::Pixbuf::create_from_file(path);
-    } catch (...)
-    {
-        return nullptr;
-    }
-
-    if (image->source == nullptr)
-    {
-        return nullptr;
-    }
-
-    return image;
+    backgrounds.erase(output);
 }
 
-bool WayfireBackground::change_background()
+std::string WayfireBackgroundApp::get_application_name()
 {
-    auto next_image = load_next_background();
-    if (!next_image)
-    {
-        return false;
-    }
-
-    gl_area->show_image(next_image);
-
-    return true;
+    return "org.wayfire.background";
 }
 
-bool WayfireBackground::load_images_from_dir(std::string path)
+std::vector<std::string> WayfireBackgroundApp::get_background_list(std::string path)
 {
     wordexp_t exp;
-
+    std::cout << "Looking in " << path << std::endl;
     /* Expand path */
     if (wordexp(path.c_str(), &exp, 0))
     {
-        return false;
+        std::cout << "Error getting list of images" << std::endl;
+        exit(0);
     }
 
     if (!exp.we_wordc)
     {
-        wordfree(&exp);
-        return false;
+        std::cout << "Error getting list of images" << std::endl;
+        exit(0);
+    }
+
+    std::vector<std::string> images;
+    struct stat s;
+    if (stat(path.c_str(), &s) == 0)
+    {
+        if (s.st_mode & S_IFREG || s.st_mode & S_IFLNK)
+        {
+            wordfree(&exp);
+            images.push_back(path);
+            return images;
+        }
     }
 
     auto dir = opendir(exp.we_wordv[0]);
     if (!dir)
     {
-        wordfree(&exp);
-        return false;
+        std::cout << "Error getting list of images" << std::endl;
+        exit(0);
     }
 
     /* Iterate over all files in the directory */
@@ -347,7 +174,8 @@ bool WayfireBackground::load_images_from_dir(std::string path)
             if (S_ISDIR(next.st_mode))
             {
                 /* Recursive search */
-                load_images_from_dir(fullpath);
+                auto list = get_background_list(fullpath);
+                images.insert(std::end(images), std::begin(list), std::end(list));
             } else
             {
                 images.push_back(fullpath);
@@ -357,6 +185,7 @@ bool WayfireBackground::load_images_from_dir(std::string path)
 
     wordfree(&exp);
 
+    bool background_randomize = WfOption<bool>{"background/randomize"};
     if (background_randomize && images.size())
     {
         std::random_device random_device;
@@ -364,301 +193,59 @@ bool WayfireBackground::load_images_from_dir(std::string path)
         std::shuffle(images.begin(), images.end(), random_gen);
     }
 
-    return true;
+    return images;
 }
 
-Glib::RefPtr<BackgroundImage> WayfireBackground::load_next_background()
+void WayfireBackgroundApp::change_background()
 {
-    Glib::RefPtr<BackgroundImage> image;
-    while (!image)
+    std::string background_path = WfOption<std::string>{"background/image"};
+    auto list = get_background_list(background_path);
+    auto idx  = find(list.begin(), list.end(), current_background) - list.begin();
+    for (auto var : list)
     {
-        if (!images.size())
-        {
-            std::cerr << "Failed to load background images from " <<
-                    (std::string)background_image << std::endl;
-            // window.remove();
-            return nullptr;
-        }
-
-        current_background = (current_background + 1) % images.size();
-
-        auto path = images[current_background];
-        image = create_from_file_safe(path);
-
-        if (!image)
-        {
-            images.erase(images.begin() + current_background);
-        } else
-        {
-            std::cout << "Picked background " << path << std::endl;
-        }
+        std::cout << var << std::endl;
     }
 
-    return image;
-}
-
-void WayfireBackground::update_background()
-{
-    Glib::RefPtr<BackgroundImage> image = Glib::RefPtr<BackgroundImage>(new BackgroundImage());
-    auto current = gl_area->get_current_image();
-    if (current != nullptr)
+    std::cout << current_background << "  " << idx << std::endl;
+    idx = (idx + 1) % list.size();
+    // gl_area->show_image(list[idx]);
+    for (auto & it : backgrounds)
     {
-        image->source    = current->source;
-        image->fill_type = background_fill_mode;
-        gl_area->show_image(image);
-    }
-}
-
-void WayfireBackground::reset_background()
-{
-    images.clear();
-    current_background = 0;
-    change_bg_conn.disconnect();
-}
-
-void WayfireBackground::set_background()
-{
-    reset_background();
+        it.second->gl_area->show_image(list[idx]);
 
-    std::string path = background_image;
-    try {
-        if (load_images_from_dir(path) && images.size())
-        {
-            auto image = load_next_background();
-            if (!image)
-            {
-                throw std::exception();
-            }
-
-            gl_area->show_image(image);
-        } else
-        {
-            auto image = create_from_file_safe(path);
-            if (!image)
-            {
-                throw std::exception();
-            }
-
-            gl_area->show_image(image);
-        }
-    } catch (...)
-    {
-        std::cerr << "Failed to load background image(s) " << path << std::endl;
+        it.second->uninhibit();
     }
 
+    write_cache(list[idx]);
     reset_cycle_timeout();
-
-    if (inhibited && output->output)
-    {
-        zwf_output_v2_inhibit_output_done(output->output);
-        inhibited = false;
-    }
-}
-
-void WayfireBackground::reset_cycle_timeout()
-{
-    int cycle_timeout = background_cycle_timeout * 1000;
-    change_bg_conn.disconnect();
-    if (images.size())
-    {
-        change_bg_conn = Glib::signal_timeout().connect(sigc::mem_fun(
-            *this, &WayfireBackground::change_background), cycle_timeout);
-    }
-}
-
-void BackgroundGLArea::realize()
-{
-    this->make_current();
-    program = init_shaders();
-}
-
-bool BackgroundGLArea::render(const Glib::RefPtr<Gdk::GLContext>& context)
-{
-    static const float vertices[] = {
-        1.0f, 1.0f,
-        -1.0f, 1.0f,
-        -1.0f, -1.0f,
-        1.0f, -1.0f,
-    };
-    static const float uv_coords[] = {
-        1.0f, 0.0f,
-        0.0f, 0.0f,
-        0.0f, 1.0f,
-        1.0f, 1.0f,
-    };
-    static float from_adj[4] = {0.0, 0.0, 1.0, 1.0};
-    if (from_image)
-    {
-        from_adj[0] = from_image->adjustments->x;
-        from_adj[1] = from_image->adjustments->y;
-        from_adj[2] = from_image->adjustments->scale_x;
-        from_adj[3] = from_image->adjustments->scale_y;
-    }
-
-    static float to_adj[4] = {0.0, 0.0, 1.0, 1.0};
-    if (to_image)
-    {
-        to_adj[0] = to_image->adjustments->x;
-        to_adj[1] = to_image->adjustments->y;
-        to_adj[2] = to_image->adjustments->scale_x;
-        to_adj[3] = to_image->adjustments->scale_y;
-    }
-
-    glClearColor(0.0, 0.0, 0.0, 1.0);
-    glClear(GL_COLOR_BUFFER_BIT);
-    glUseProgram(program);
-    if (from_image)
-    {
-        glActiveTexture(GL_TEXTURE0);
-        glBindTexture(GL_TEXTURE_2D, from_image->tex_id);
-        GLuint from_tex_uniform = glGetUniformLocation(program, "bg_texture_from");
-        glUniform1i(from_tex_uniform, 0);
-    }
-
-    glActiveTexture(GL_TEXTURE1);
-    glBindTexture(GL_TEXTURE_2D, to_image->tex_id);
-    GLuint to_tex_uniform = glGetUniformLocation(program, "bg_texture_to");
-    glUniform1i(to_tex_uniform, 1);
-    glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices);
-    glEnableVertexAttribArray(1);
-    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, uv_coords);
-    GLuint progress = glGetUniformLocation(program, "progress");
-    glUniform1f(progress, fade);
-    GLuint from_adj_loc = glGetUniformLocation(program, "from_adj");
-    glUniform4fv(from_adj_loc, 1, from_adj);
-    GLuint to_adj_loc = glGetUniformLocation(program, "to_adj");
-    glUniform4fv(to_adj_loc, 1, to_adj);
-
-    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, 0);
-    glActiveTexture(GL_TEXTURE1);
-    glBindTexture(GL_TEXTURE_2D, 0);
-    glDisableVertexAttribArray(0);
-    glDisableVertexAttribArray(1);
-    glUseProgram(0);
-
-    if (fade.running())
-    {
-        Glib::signal_idle().connect([=] ()
-        {
-            this->queue_draw();
-            return false;
-        });
-    }
-
-    return true;
-}
-
-BackgroundGLArea::BackgroundGLArea(WayfireBackground *background)
-{
-    this->background = background;
+    current_background = list[idx];
 }
 
-BackgroundWindow::BackgroundWindow(WayfireBackground *background)
+gboolean WayfireBackgroundApp::sigusr1_handler(void *instance)
 {
-    this->background = background;
+    ((WayfireBackgroundApp*)instance)->change_background();
+    return TRUE;
 }
 
-void BackgroundWindow::size_allocate_vfunc(int width, int height, int baseline)
+void WayfireBackgroundApp::write_cache(std::string path)
 {
-    Gtk::Widget::size_allocate_vfunc(width, height, baseline);
-    background->window_width  = width;
-    background->window_height = height;
-
-    background->set_background();
-}
-
-void WayfireBackground::setup_window()
-{
-    gl_area = Glib::RefPtr<BackgroundGLArea>(new BackgroundGLArea(this));
-    window  = Glib::RefPtr<BackgroundWindow>(new BackgroundWindow(this));
-    window->set_decorated(false);
-
-    gtk_layer_init_for_window(window->gobj());
-    gtk_layer_set_layer(window->gobj(), GTK_LAYER_SHELL_LAYER_BACKGROUND);
-    gtk_layer_set_monitor(window->gobj(), this->output->monitor->gobj());
-
-    gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_TOP, true);
-    gtk_layer_set_anchor(window->gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, true);
-    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_keyboard_mode(window->gobj(), GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND);
-
-    gtk_layer_set_exclusive_zone(window->gobj(), -1);
-    gl_area->signal_realize().connect(sigc::mem_fun(*gl_area, &BackgroundGLArea::realize));
-    gl_area->signal_render().connect(sigc::mem_fun(*gl_area, &BackgroundGLArea::render), false);
-    window->set_child(*gl_area);
-
-    auto update_background = [=] () { this->update_background(); };
-    auto set_background    = [=] () { this->set_background(); };
-    auto reset_cycle = [=] () { reset_cycle_timeout(); };
-    background_image.set_callback(set_background);
-    background_fill_mode.set_callback(update_background);
-    background_cycle_timeout.set_callback(reset_cycle);
-
-    window->present();
-}
-
-WayfireBackground::WayfireBackground(WayfireShellApp *app, WayfireOutput *output)
-{
-    this->app    = app;
-    this->output = output;
-
-    if (output->output)
+    std::cout << "Writing path to cache " << path << std::endl;
+    if (cache_file.length() > 1)
     {
-        this->inhibited = true;
-        zwf_output_v2_inhibit_output(output->output);
+        std::ofstream out(cache_file);
+        out << path;
+        out.close();
     }
-
-    setup_window();
-}
-
-WayfireBackground::~WayfireBackground()
-{
-    reset_background();
 }
 
-class WayfireBackgroundApp : public WayfireShellApp
+void WayfireBackgroundApp::reset_cycle_timeout()
 {
-    std::map<WayfireOutput*, std::unique_ptr<WayfireBackground>> backgrounds;
-
-  public:
-    using WayfireShellApp::WayfireShellApp;
-    static void create(int argc, char **argv)
-    {
-        WayfireShellApp::instance =
-            std::make_unique<WayfireBackgroundApp>();
-        g_unix_signal_add(SIGUSR1, sigusr1_handler, (void*)instance.get());
-        instance->run(argc, argv);
-    }
-
-    void handle_new_output(WayfireOutput *output) override
-    {
-        backgrounds[output] = std::unique_ptr<WayfireBackground>(
-            new WayfireBackground(this, output));
-    }
-
-    void handle_output_removed(WayfireOutput *output) override
-    {
-        backgrounds.erase(output);
-    }
-
-    static gboolean sigusr1_handler(void *instance)
+    int background_cycle = 1000 * WfOption<int>{"background/cycle_timeout"};
+    change_bg_conn.disconnect();
+    change_bg_conn = Glib::signal_timeout().connect(
+        [this] ()
     {
-        for (const auto& [_, bg] : ((WayfireBackgroundApp*)instance)->backgrounds)
-        {
-            bg->change_background();
-        }
-
-        return TRUE;
-    }
-};
-
-int main(int argc, char **argv)
-{
-    WayfireBackgroundApp::create(argc, argv);
-    return 0;
+        change_background();
+        return G_SOURCE_REMOVE;
+    }, background_cycle);
 }
diff --git a/src/background/background.hpp b/src/background/background.hpp
index 1affa40c..2bf4af60 100644
--- a/src/background/background.hpp
+++ b/src/background/background.hpp
@@ -1,106 +1,55 @@
 #pragma once
 
 #include <glibmm/refptr.h>
-#include <gtkmm/drawingarea.h>
 #include <gtkmm/window.h>
 #include <wf-shell-app.hpp>
 #include <wf-option-wrap.hpp>
 #include <wayfire/util/duration.hpp>
-
 #include <epoxy/gl.h>
 
-class WayfireBackground;
+#include "background-gl.hpp"
+#include "sigc++/connection.h"
 
-class BackgroundImageAdjustments
-{
-  public:
-    GLfloat scale_x = -1, scale_y = -1;
-    GLfloat x, y;
-};
 
-class BackgroundImage
+class WayfireBackground : public Gtk::Window
 {
+  private:
+    void setup_window();
+    WayfireOutput *output;
+    WfOption<bool> inhibit_start{"background/blank"};
+    bool inhibited = false;
+
   public:
-    BackgroundImage();
-    ~BackgroundImage();
-    Glib::RefPtr<Gdk::Pixbuf> source;
-    std::string fill_type;
-    Glib::RefPtr<BackgroundImageAdjustments> adjustments;
+    WayfireBackground(WayfireOutput *output);
 
-    void generate_adjustments(int width, int height);
-    GLuint tex_id = 0;
+    ~WayfireBackground();
+    Glib::RefPtr<BackgroundGLArea> gl_area;
+    void uninhibit();
 };
 
-class BackgroundGLArea : public Gtk::GLArea
+class WayfireBackgroundApp : public WayfireShellApp
 {
-    WayfireBackground *background;
-    GLuint program = 0;
-    wf::animation::simple_animation_t fade;
-    WfOption<int> fade_duration{"background/fade_duration"};
-
-    /* These two pixbufs are used for fading one background
-     * image to the next when changing backgrounds or when
-     * automatically cycling through a directory of images.
-     * pbuf is the current image to which we are fading and
-     * pbuf2 is the image from which we are fading. x and y
-     * are used as offsets when preserve aspect is set. */
-    Glib::RefPtr<BackgroundImage> to_image, from_image;
+    std::map<WayfireOutput*, std::unique_ptr<WayfireBackground>> backgrounds;
+    std::string cache_file = "", current_background;
+    sigc::connection change_bg_conn;
 
   public:
-    BackgroundGLArea(WayfireBackground *background);
-    void realize();
-    bool render(const Glib::RefPtr<Gdk::GLContext>& context);
-    void show_image(Glib::RefPtr<BackgroundImage> image);
-    Glib::RefPtr<BackgroundImage> get_current_image()
+    using WayfireShellApp::WayfireShellApp;
+    void on_activate() override;
+    static void create(int argc, char **argv);
+
+    void handle_new_output(WayfireOutput *output) override;
+    void handle_output_removed(WayfireOutput *output) override;
+    std::string get_application_name() override;
+    Gio::Application::Flags get_extra_application_flags() override
     {
-        return to_image;
+        return Gio::Application::Flags::NON_UNIQUE;
     }
-};
-
-class BackgroundWindow : public Gtk::Window
-{
-    WayfireBackground *background;
-
-  public:
-    BackgroundWindow(WayfireBackground *background);
 
-  protected:
-    void size_allocate_vfunc(int width, int height, int baseline) override;
-};
-
-class WayfireBackground
-{
-    WayfireShellApp *app;
-    WayfireOutput *output;
-
-    Glib::RefPtr<BackgroundGLArea> gl_area;
-    std::vector<std::string> images;
-    Glib::RefPtr<Gtk::Window> window;
-
-    bool inhibited = false;
-    uint current_background;
-    sigc::connection change_bg_conn;
-
-    WfOption<std::string> background_image{"background/image"};
-    WfOption<int> background_cycle_timeout{"background/cycle_timeout"};
-    WfOption<bool> background_randomize{"background/randomize"};
-    WfOption<std::string> background_fill_mode{"background/fill_mode"};
-
-    Glib::RefPtr<BackgroundImage> create_from_file_safe(std::string path);
-    bool background_transition_frame(int timer);
-    bool load_images_from_dir(std::string path);
-    Glib::RefPtr<BackgroundImage> load_next_background();
-    void reset_background();
-    void update_background();
+    std::vector<std::string> get_background_list(std::string path);
+    void change_background();
+    static gboolean sigusr1_handler(void *instance);
+    void write_cache(std::string path);
     void reset_cycle_timeout();
-
-    void setup_window();
-
-  public:
-    guint window_width  = 0;
-    guint window_height = 0;
-    WayfireBackground(WayfireShellApp *app, WayfireOutput *output);
-    void set_background();
-    bool change_background();
-    ~WayfireBackground();
+    void prep_cache();
 };
diff --git a/src/dock/dock-app.cpp b/src/dock/dock-app.cpp
index dc6e6d9b..c10f0164 100644
--- a/src/dock/dock-app.cpp
+++ b/src/dock/dock-app.cpp
@@ -1,4 +1,5 @@
 #include "dock.hpp"
+#include "giomm/application.h"
 #include "toplevel.hpp"
 #include "toplevel-icon.hpp"
 #include <iostream>
@@ -148,9 +149,20 @@ void WfDockApp::create(int argc, char **argv)
     }
 
     instance = std::unique_ptr<WfDockApp>{new WfDockApp()};
+    instance->init_app();
     instance->run(argc, argv);
 }
 
+std::string WfDockApp::get_application_name()
+{
+    return "org.wayfire.dock";
+}
+
+Gio::Application::Flags WfDockApp::get_extra_application_flags()
+{
+    return Gio::Application::Flags::NON_UNIQUE;
+}
+
 WfDockApp::WfDockApp() : WayfireShellApp(), priv(new WfDockApp::impl())
 {}
 WfDockApp::~WfDockApp() = default;
diff --git a/src/dock/dock.hpp b/src/dock/dock.hpp
index d4db695c..3ae4b1f7 100644
--- a/src/dock/dock.hpp
+++ b/src/dock/dock.hpp
@@ -5,6 +5,7 @@
 #include <wlr-foreign-toplevel-management-unstable-v1-client-protocol.h>
 #include <wf-option-wrap.hpp>
 
+#include "giomm/application.h"
 #include "wf-shell-app.hpp"
 
 class WfDock
@@ -37,6 +38,8 @@ class WfDockApp : public WayfireShellApp
      * call to run() */
     static void create(int argc, char **argv);
     virtual ~WfDockApp();
+    std::string get_application_name() override;
+    Gio::Application::Flags get_extra_application_flags() override;
 
     void on_activate() override;
     void handle_new_output(WayfireOutput *output) override;
diff --git a/src/locker-pin/locker-pin.cpp b/src/locker-pin/locker-pin.cpp
new file mode 100644
index 00000000..6965ef17
--- /dev/null
+++ b/src/locker-pin/locker-pin.cpp
@@ -0,0 +1,213 @@
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <openssl/crypto.h>
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+#include <iomanip>
+
+#include "locker-pin.hpp"
+
+WayfirePinChangeApp::WayfirePinChangeApp() : Gtk::Application("org.wayfire.locker-pin",
+        Gio::Application::Flags::NONE)
+{
+    signal_activate().connect(sigc::mem_fun(*this, &WayfirePinChangeApp::activate));
+    char *config_home = getenv("XDG_CONFIG_HOME");
+    if (config_home == NULL)
+    {
+        hash_file = std::string(getenv("HOME")) + "/.config/wf-locker.hash";
+    } else
+    {
+        hash_file = std::string(std::string(config_home) + "/wf-locker.hash");
+    }
+
+    std::ifstream f(hash_file);
+    if (!f.is_open())
+    {
+        std::cerr << "No PIN hash set" << std::endl;
+        hash = "";
+        return;
+    }
+
+    std::string s;
+    if (!getline(f, s))
+    {
+        std::cerr << "No PIN hash set" << std::endl;
+        hash = "";
+        return;
+    }
+
+    if (s.length() != 128)
+    {
+        std::cerr << "Invalid PIN hash" << std::endl;
+        hash = "";
+        return;
+    }
+
+    hash = s;
+}
+
+void WayfirePinChangeApp::activate()
+{
+    add_window(window);
+    window.set_child(grid);
+    grid.attach(label, 0, 0, 3, 1);
+
+    for (int val = 0; val < 10; val++)
+    {
+        std::string val_string = std::to_string(val);
+        numbers[val].set_label(val_string);
+        numbers[val].signal_clicked().connect(
+            [this, val_string] ()
+        {
+            pin_key(val_string);
+        });
+    }
+
+    cancel.set_label("❌");
+    submit.set_label("✔️");
+    cancel.signal_clicked().connect(
+        [this] ()
+    {
+        pin_cancel();
+    });
+    submit.signal_clicked().connect(
+        [this] ()
+    {
+        pin_submit();
+    });
+
+    grid.attach(numbers[0], 1, 4);
+    grid.attach(numbers[1], 0, 1);
+    grid.attach(numbers[2], 1, 1);
+    grid.attach(numbers[3], 2, 1);
+    grid.attach(numbers[4], 0, 2);
+    grid.attach(numbers[5], 1, 2);
+    grid.attach(numbers[6], 2, 2);
+    grid.attach(numbers[7], 0, 3);
+    grid.attach(numbers[8], 1, 3);
+    grid.attach(numbers[9], 2, 3);
+    grid.attach(submit, 2, 4);
+    grid.attach(cancel, 0, 4);
+
+    if (hash.length() > 1)
+    {
+        stage = Stage::PREVIOUS;
+    } else
+    {
+        stage = Stage::FIRST;
+    }
+
+    set_label();
+    grid.set_halign(Gtk::Align::CENTER);
+    grid.set_valign(Gtk::Align::CENTER);
+    window.present();
+}
+
+void WayfirePinChangeApp::set_label()
+{
+    std::string asterisks(pin.length(), '*');
+
+    if (stage == Stage::PREVIOUS)
+    {
+        label.set_label("Enter current PIN\n" + asterisks);
+    } else if (stage == Stage::FIRST)
+    {
+        label.set_label("Enter new PIN\n" + asterisks);
+    } else if (stage == Stage::CONFIRM)
+    {
+        label.set_label("Confirm new PIN\n" + asterisks);
+    }
+}
+
+void WayfirePinChangeApp::pin_cancel()
+{
+    pin = "";
+    set_label();
+}
+
+void WayfirePinChangeApp::pin_key(std::string key)
+{
+    if (pin.length() >= 20)
+    {
+        return;
+    }
+
+    pin = pin + key;
+    set_label();
+}
+
+void WayfirePinChangeApp::pin_submit()
+{
+    if (pin.length() == 0)
+    {
+        return;
+    }
+
+    if (stage == Stage::PREVIOUS)
+    {
+        std::string tmphash = sha512(pin);
+        if (tmphash == hash)
+        {
+            stage = Stage::FIRST;
+            pin   = "";
+            set_label();
+            return;
+        }
+
+        pin = "";
+        set_label();
+        return;
+    } else if (stage == Stage::FIRST)
+    {
+        confirm = sha512(pin);
+        pin     = "";
+        stage   = Stage::CONFIRM;
+        set_label();
+        return;
+    } else if (stage == Stage::CONFIRM)
+    {
+        std::string tmphash = sha512(pin);
+        if (tmphash == confirm)
+        {
+            std::ofstream out(hash_file);
+            out << tmphash;
+            out.close();
+            exit(0);
+        }
+
+        confirm = "";
+        pin     = "";
+        stage   = Stage::FIRST;
+        set_label();
+        return;
+    }
+}
+
+std::string WayfirePinChangeApp::sha512(const std::string input)
+{
+    unsigned char hash[EVP_MAX_MD_SIZE];
+    unsigned int hash_length = 0;
+    EVP_MD_CTX *mdctx = EVP_MD_CTX_create();
+    EVP_DigestInit(mdctx, EVP_sha512());
+    EVP_DigestUpdate(mdctx, input.c_str(), input.size());
+    EVP_DigestFinal(mdctx, hash, &hash_length);
+    EVP_MD_CTX_free(mdctx);
+
+    std::stringstream ss;
+
+    for (int i = 0; i < SHA512_DIGEST_LENGTH; i++)
+    {
+        ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(hash[i]);
+    }
+
+    return ss.str();
+}
+
+/* Starting point */
+int main(int argc, char **argv)
+{
+    auto app = new WayfirePinChangeApp();
+    app->run();
+    exit(0);
+}
diff --git a/src/locker-pin/locker-pin.hpp b/src/locker-pin/locker-pin.hpp
new file mode 100644
index 00000000..47e131be
--- /dev/null
+++ b/src/locker-pin/locker-pin.hpp
@@ -0,0 +1,31 @@
+#pragma once
+#include "gtkmm.h"
+
+enum Stage
+{
+    PREVIOUS,
+    FIRST,
+    CONFIRM,
+};
+
+class WayfirePinChangeApp : public Gtk::Application
+{
+    std::string hash_file;
+    Gtk::Window window;
+    Gtk::Grid grid;
+    Gtk::Button numbers[10], cancel, submit;
+    Gtk::Label label;
+
+    std::string hash = "", pin = "", confirm = "";
+    Stage stage;
+
+  public:
+    WayfirePinChangeApp();
+    void activate();
+    void set_label();
+    void pin_key(std::string);
+    void pin_cancel();
+    void pin_submit();
+
+    std::string sha512(const std::string input);
+};
diff --git a/src/locker-pin/meson.build b/src/locker-pin/meson.build
new file mode 100644
index 00000000..9f43f3d3
--- /dev/null
+++ b/src/locker-pin/meson.build
@@ -0,0 +1,11 @@
+deps = [
+  gtkmm,
+  openssl,
+]
+
+executable(
+  'wf-locker-pin',
+  ['locker-pin.cpp'],
+  dependencies: deps,
+  install: true,
+)
diff --git a/src/locker/locker.cpp b/src/locker/locker.cpp
new file mode 100644
index 00000000..1fcb5ec2
--- /dev/null
+++ b/src/locker/locker.cpp
@@ -0,0 +1,608 @@
+#include <csignal>
+#include <iostream>
+#include <fstream>
+#include <giomm/application.h>
+#include <glibmm.h>
+#include <glibmm/miscutils.h>
+#include <gtkmm/headerbar.h>
+#include <gtkmm/box.h>
+#include <gtkmm/centerbox.h>
+#include <gtkmm/application.h>
+#include <gdkmm/monitor.h>
+#include <gdk/wayland/gdkwayland.h>
+#include <gtk4-session-lock.h>
+#include <memory>
+#include <wayfire/config/file.hpp>
+#include <sys/inotify.h>
+
+#include "background-gl.hpp"
+#include "css-config.hpp"
+#include "glib.h"
+#include "glibmm/main.h"
+#include "lockscreen.hpp"
+#include "plugin/battery.hpp"
+#include "plugin/clock.hpp"
+#include "plugin/weather.hpp"
+#include "plugin/instant.hpp"
+#include "plugin/password.hpp"
+#include "plugin/pin.hpp"
+#include "plugin/fingerprint.hpp"
+#include "plugin/user.hpp"
+#include "plugin/volume.hpp"
+#include "plugin/mpris.hpp"
+#include "plugin/network.hpp"
+#include "wf-option-wrap.hpp"
+#include "wf-shell-app.hpp"
+#include "locker.hpp"
+
+#define INOT_BUF_SIZE (1024 * sizeof(inotify_event))
+
+Gio::Application::Flags WayfireLockerApp::get_extra_application_flags()
+{
+    return Gio::Application::Flags::NONE;
+}
+
+std::string WayfireLockerApp::get_application_name()
+{
+    return "org.wayfire.locker";
+}
+
+WayfireLockerApp::WayfireLockerApp()
+{}
+
+WayfireLockerApp::~WayfireLockerApp()
+{}
+
+void WayfireLockerApp::perform_lock()
+{
+    WayfireLockerApp::get().init_plugins();
+    if (is_debug())
+    {
+        if (!m_is_locked)
+        {
+            on_monitor_present(nullptr);
+        }
+    } else
+    {
+        /* Demand the session be locked */
+        gtk_session_lock_instance_lock(lock);
+    }
+}
+
+/* Called before each activate */
+void WayfireLockerApp::command_line()
+{
+    app->add_main_option_entry(
+        [=] (const Glib::ustring & option_name,
+             const Glib::ustring & value, bool has_value)
+    {
+        can_early_wake = false;
+        return true;
+    },
+        "now", 'n', "Instant lock", "", Glib::OptionEntry::Flags::NO_ARG);
+}
+
+void WayfireLockerApp::on_activate()
+{
+    if (activated)
+    {
+        if (!m_is_locked)
+        {
+            /* Relock logic, currently unused */
+            if (can_early_wake)
+            {
+                prewake_signal = Glib::signal_timeout().connect([this] ()
+                {
+                    kill_parent(ExitType::LOCKED);
+
+                    can_early_wake = false;
+                    return G_SOURCE_REMOVE;
+                }, WfOption<double>{"locker/prewake"} *1000);
+            }
+
+            perform_lock();
+        } else
+        {
+            kill_parent(ExitType::LOCKED);
+        }
+
+        /* Called again but already screen locked. No worries */
+        return;
+    }
+
+    /* Set a timer for early-wake unlock */
+    WayfireShellApp::on_activate();
+
+    if (can_early_wake)
+    {
+        prewake_signal = Glib::signal_timeout().connect([this] ()
+        {
+            kill_parent(ExitType::LOCKED);
+            can_early_wake = false;
+            return G_SOURCE_REMOVE;
+        }, WfOption<double>{"locker/prewake"} *1000);
+        /* TODO Hot config for this? */
+        // exit_on_unlock = WfOption<bool>{"locker/exit_on_unlock"};
+    }
+
+    auto debug = Glib::getenv("WF_LOCKER_DEBUG");
+    if (debug == "1")
+    {
+        m_is_debug = true;
+    }
+
+    lock = gtk_session_lock_instance_new();
+    /* Session lock callbacks */
+    g_signal_connect(lock, "locked", G_CALLBACK(on_session_locked_c), lock);
+    g_signal_connect(lock, "failed", G_CALLBACK(on_session_lock_failed_c), lock);
+    g_signal_connect(lock, "unlocked", G_CALLBACK(on_session_unlocked_c), lock);
+    g_signal_connect(lock, "monitor", G_CALLBACK(on_monitor_present_c), lock);
+    alternative_monitors = true; /* Don't use WayfireShellApp monitor tracking, we get a different set */
+    new CssFromConfigString("locker/background_color", ".wf-locker {background-color:", ";}");
+    new CssFromConfigFont("locker/clock_font", ".wf-locker .clock {", "}");
+    new CssFromConfigFont("locker/weather_font", ".wf-locker .weather {", "}");
+    new CssFromConfigFont("locker/user_font", ".wf-locker .user {", "}");
+    new CssFromConfigFont("locker/pin_pad_font", ".wf-locker .pinpad-button {", "}");
+    new CssFromConfigFont("locker/pin_reply_font", ".wf-locker .pinpad-current {", "}");
+    new CssFromConfigFont("locker/fingerprint_font", ".wf-locker .fingerprint-text {", "}");
+    new CssFromConfigFont("locker/battery_percent_font", ".wf-locker .battery-percent {", "}");
+    new CssFromConfigFont("locker/battery_description_font", ".wf-locker .battery-description {", "}");
+    new CssFromConfigFont("locker/instant_unlock_font", ".wf-locker .instant-unlock {", "}");
+    new CssFromConfigInt("locker/battery_icon_size", ".wf-locker .battery-image {-gtk-icon-size:", "px;}");
+    new CssFromConfigInt("locker/fingerprint_icon_size", ".wf-locker .fingerprint-icon {-gtk-icon-size:",
+        "px;}");
+    new CssFromConfigDouble("locker/prewake", ".fade-in {animation-name: slowfade;animation-duration: ",
+        "s; animation-timing-function: linear; animation-iteration-count: 1; animation-fill-mode: forwards;} @keyframes slowfade { from {opacity:0; background: #0000;} to {opacity:1;}}");
+    new CssFromConfigFont("locker/network_font", ".wf-locker .network {", "}");
+    new CssFromConfigInt("locker/network_icon_size", ".wf-locker .network {-gtk-icon-size:", "px;}");
+
+    /* Init plugins */
+    plugins.emplace("clock", Plugin(new WayfireLockerClockPlugin()));
+    plugins.emplace("weather", Plugin(new WayfireLockerWeatherPlugin()));
+    plugins.emplace("battery", Plugin(new WayfireLockerBatteryPlugin()));
+    plugins.emplace("password", Plugin(new WayfireLockerPasswordPlugin()));
+    plugins.emplace("instant", (Plugin(new WayfireLockerInstantPlugin())));
+    plugins.emplace("pin", Plugin(new WayfireLockerPinPlugin()));
+    plugins.emplace("fingerprint", Plugin(new WayfireLockerFingerprintPlugin()));
+    plugins.emplace("volume", Plugin(new WayfireLockerVolumePlugin()));
+    plugins.emplace("mpris", Plugin(new WayfireLockerMPRISPlugin()));
+    plugins.emplace("aboutuser", Plugin(new WayfireLockerUserPlugin()));
+    plugins.emplace("network", Plugin(new WayfireLockerNetworkPlugin()));
+
+    /* Get background cache */
+    char *xdg_runtime_dir = getenv("XDG_RUNTIME_DIR");
+    if (xdg_runtime_dir)
+    {
+        this->cache_file = std::string(xdg_runtime_dir) + "/wf-background.cache";
+        std::cout << "Using cache file " << this->cache_file << std::endl;
+        inotify_bg_file = inotify_init();
+        Glib::signal_io().connect(
+            [this] (Glib::IOCondition cond)
+        {
+            char buf[INOT_BUF_SIZE];
+            read(inotify_bg_file, buf, INOT_BUF_SIZE);
+            reload_background();
+            return G_SOURCE_CONTINUE;
+        },
+            inotify_bg_file, Glib::IOCondition::IO_IN | Glib::IOCondition::IO_HUP);
+        reload_background();
+    } else
+    {
+        std::cout << "Not reading from cache file " << std::endl;
+    }
+
+    /* Create plugin option callbacks */
+    for (auto & it : plugins)
+    {
+        Plugin plugin = it.second;
+        plugin->enable.set_callback(
+            [plugin, this] ()
+        {
+            if (plugin->enable)
+            {
+                plugin->init();
+                for (auto & it : window_list)
+                {
+                    int id = it.first;
+                    plugin->add_output(id, it.second->grid);
+                }
+            } else
+            {
+                for (auto & it : window_list)
+                {
+                    int id = it.first;
+                    plugin->remove_output(id, it.second->grid);
+                }
+
+                plugin->deinit();
+            }
+        });
+        plugin->position.set_callback(
+            [this, plugin] ()
+        {
+            for (auto & it : window_list)
+            {
+                int id = it.first;
+                auto window = it.second;
+                plugin->remove_output(id, window->grid);
+                plugin->add_output(id, window->grid);
+            }
+        });
+    }
+
+    perform_lock();
+}
+
+/** Called just as lock starts but before window is shown */
+void WayfireLockerApp::init_plugins()
+{
+    for (auto & it : plugins)
+    {
+        Plugin plugin = it.second;
+        if (plugin->enable)
+        {
+            it.second->init();
+        }
+    }
+}
+
+/** Called after an unlock */
+void WayfireLockerApp::deinit_plugins()
+{
+    for (auto & it : plugins)
+    {
+        Plugin plugin = it.second;
+        if (plugin->enable)
+        {
+            it.second->deinit();
+        }
+    }
+}
+
+/* A new monitor has been added to the lockscreen */
+void WayfireLockerApp::on_monitor_present(GdkMonitor *monitor)
+{
+    int id = window_id_count;
+    window_id_count++;
+    /* Create lockscreen with a grid for contents */
+    window_list.emplace(id, new WayfireLockerAppLockscreen(background_path));
+    auto window = window_list[id];
+
+    for (auto& it : plugins)
+    {
+        Plugin plugin = it.second;
+        if (plugin->enable)
+        {
+            it.second->add_output(id, window->grid);
+        }
+    }
+
+    windows_signals.push_back(window->signal_realize().connect(
+        [this] ()
+    {
+        if (!can_early_wake)
+        {
+            windows_signals.push_back(Glib::signal_timeout().connect([this] ()
+            {
+                kill_parent(ExitType::LOCKED);
+                return G_SOURCE_REMOVE;
+            }, 100));
+        }
+    }, true));
+
+    windows_signals.push_back(window->signal_close_request().connect([this, id] ()
+    {
+        for (auto& it : plugins)
+        {
+            Plugin plugin = it.second;
+            if (plugin->enable)
+            {
+                plugin->remove_output(id, window_list[id]->grid);
+            }
+        }
+
+        if (m_is_debug)
+        {
+            deinit_plugins();
+            m_is_locked = false;
+            if (exit_on_unlock)
+            {
+                exit(0);
+            }
+        }
+
+        return false;
+    }, false));
+    if (is_debug())
+    {
+        init_plugins();
+        m_is_locked = true;
+        window->present();
+    } else
+    {
+        gtk_session_lock_instance_assign_window_to_monitor(lock, window->gobj(), monitor);
+    }
+
+    if (can_early_wake)
+    {
+        window->add_css_class("fade-in");
+    }
+}
+
+/* Called on any successful auth to unlock & end locker */
+void WayfireLockerApp::perform_unlock(std::string reason)
+{
+    /* Offset the actual logic so that any callbacks that call
+     *  this get a chance to exit cleanly. */
+    Glib::signal_idle().connect([this, reason] ()
+    {
+        std::cout << "Unlocked : " << reason << std::endl;
+        kill_parent(ExitType::USER_UNLOCKED);
+        if (m_is_debug)
+        {
+            /* We need to manually close in debug mode */
+            for (auto & it : window_list)
+            {
+                it.second->close();
+            }
+
+            if (WayfireLockerApp::get().exit_on_unlock)
+            {
+                exit(0);
+            }
+        } else
+        {
+            gtk_session_lock_instance_unlock(lock);
+        }
+
+        for (auto & it : window_list)
+        {
+            it.second->disconnect();
+        }
+
+        for (auto signal : windows_signals)
+        {
+            signal.disconnect();
+        }
+
+        if (lockout_signal)
+        {
+            lockout_signal.disconnect();
+        }
+
+        if (prewake_signal)
+        {
+            prewake_signal.disconnect();
+        }
+
+        return G_SOURCE_REMOVE;
+    });
+}
+
+void WayfireLockerApp::create(int argc, char **argv, pid_t p_pid)
+{
+    if (instance)
+    {
+        throw std::logic_error("Running WayfireLockerApp twice!");
+    }
+
+    instance = std::unique_ptr<WayfireShellApp>(new WayfireLockerApp{});
+    (dynamic_cast<WayfireLockerApp&>(*instance)).p_pid = p_pid;
+    instance->init_app();
+    instance->run(argc, argv);
+    /* In case exit has happened before parent quits */
+    (dynamic_cast<WayfireLockerApp&>(*instance)).kill_parent(ExitType::ERROR_NOT_LOCKED);
+}
+
+bool WayfireLockerApp::is_locked()
+{
+    if (!m_is_debug)
+    {
+        return gtk_session_lock_instance_is_locked(lock);
+    }
+
+    return m_is_locked;
+}
+
+void WayfireLockerApp::set_is_locked(bool locked)
+{
+    m_is_locked = locked;
+}
+
+/* Starting point */
+int main(int argc, char **argv)
+{
+    pid_t c_pid, p_pid = getpid();
+    c_pid = fork();
+    if (c_pid == -1)
+    {
+        std::cerr << "Unable to fork, exiting" << std::endl;
+        return 1;
+    } else if (c_pid > 0)
+    {
+        signal(ExitType::LOCKED, [] (int)
+        {
+            std::cout << "Locked :: exit(0)" << std::endl;
+            exit(0); /* Fully locked, return control */
+        });
+        signal(ExitType::USER_UNLOCKED, [] (int)
+        {
+            std::cout << "Unlocked :: exit(2)" << std::endl;
+            exit(2); /* User fully authenticated or interupted before lock */
+        });
+        signal(ExitType::ERROR_NOT_LOCKED, [] (int)
+        {
+            std::cout << "Error :: exit(1)" << std::endl;
+            exit(1);
+        });
+        sleep(12);
+        std::cout << "Timed out" << std::endl;
+        exit(1); /* Lock timed out */
+    } else
+    {
+        if (!gtk_session_lock_is_supported())
+        {
+            std::cerr << "This session does not support locking" << std::endl;
+            kill(p_pid, ExitType::ERROR_NOT_LOCKED);
+            exit(1);
+        }
+
+        WayfireLockerApp::create(argc, argv, p_pid);
+    }
+
+    return 0;
+}
+
+/* lock session calllbacks */
+void on_session_locked_c(GtkSessionLockInstance *lock, void *data)
+{
+    std::cout << "Session locked" << std::endl;
+    WayfireLockerApp::get().set_is_locked(true);
+}
+
+void on_session_lock_failed_c(GtkSessionLockInstance *lock, void *data)
+{
+    std::cout << "Session lock failed" << std::endl;
+    WayfireLockerApp::get().set_is_locked(false);
+    WayfireLockerApp::get().kill_parent(ExitType::ERROR_NOT_LOCKED);
+    exit(0);
+}
+
+void on_session_unlocked_c(GtkSessionLockInstance *lock, void *data)
+{
+    std::cout << "Session unlocked" << std::endl;
+    WayfireLockerApp::get().set_is_locked(false);
+    WayfireLockerApp::get().deinit_plugins();
+    if (WayfireLockerApp::get().exit_on_unlock)
+    {
+        // Exiting too early causes a lock-out
+        Glib::signal_idle().connect([] () -> bool
+        {
+            WayfireLockerApp::get().kill_parent(ExitType::USER_UNLOCKED);
+            exit(0);
+        }, 1);
+    }
+
+    // Lose windows, but not right away to avoid lock-screen-crash for 1 frame
+    Glib::signal_idle().connect([] ()
+    {
+        WayfireLockerApp::get().window_list.clear();
+        return G_SOURCE_REMOVE;
+    });
+}
+
+void on_monitor_present_c(GtkSessionLockInstance *lock, GdkMonitor *monitor, void *data)
+{
+    WayfireLockerApp::get().on_monitor_present(monitor);
+}
+
+/* Find user config */
+std::string WayfireLockerApp::get_config_file()
+{
+    if (cmdline_config.has_value())
+    {
+        return cmdline_config.value();
+    }
+
+    std::string config_dir;
+
+    char *config_home = getenv("XDG_CONFIG_HOME");
+    if (config_home == NULL)
+    {
+        config_dir = std::string(getenv("HOME")) + "/.config";
+    } else
+    {
+        config_dir = std::string(config_home);
+    }
+
+    return config_dir + "/wf-shell.ini";
+}
+
+Plugin WayfireLockerApp::get_plugin(std::string name)
+{
+    if (plugins.find(name) == plugins.end())
+    {
+        return nullptr;
+    }
+
+    return plugins.at(name);
+}
+
+void WayfireLockerApp::user_activity()
+{
+    if (can_early_wake)
+    {
+        can_early_wake = false;
+        perform_unlock("Early Activity");
+    }
+}
+
+void WayfireLockerApp::recieved_bad_auth()
+{
+    bad_auth_count++;
+    if (bad_auth_count > WfOption<int>{"locker/lockout_attempts"})
+    {
+        // Lockout now
+        lockout = true;
+        for (auto & it : plugins)
+        {
+            it.second->lockout_changed(true);
+        }
+
+        //
+        lockout_signal = Glib::signal_timeout().connect_seconds(
+            [this] ()
+        {
+            lockout = false;
+            bad_auth_count = 0;
+            for (auto & it : plugins)
+            {
+                it.second->lockout_changed(false);
+            }
+
+            return G_SOURCE_REMOVE;
+        }, WfOption<int>{"locker/lockout_timer"});
+    }
+}
+
+bool WayfireLockerApp::is_locked_out()
+{
+    return lockout;
+}
+
+void WayfireLockerApp::reload_background()
+{
+    if (cache_file.length() > 1)
+    {
+        std::ifstream f(cache_file);
+        if (f.is_open())
+        {
+            std::string s;
+            if (getline(f, s))
+            {
+                std::cout << "Background " << s << std::endl;
+                for (auto & it : window_list)
+                {
+                    auto widget = it.second;
+                    widget->background.show_image(s);
+                }
+
+                background_path = s;
+            }
+        }
+    }
+
+    // Re add notify
+    inotify_add_watch(inotify_bg_file,
+        cache_file.c_str(),
+        IN_CREATE | IN_MODIFY | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE);
+}
+
+void WayfireLockerApp::kill_parent(ExitType exittype)
+{
+    if (p_pid)
+    {
+        kill(p_pid, exittype); /* We are fully locked */
+        p_pid = 0;
+    }
+}
diff --git a/src/locker/locker.hpp b/src/locker/locker.hpp
new file mode 100644
index 00000000..d611b141
--- /dev/null
+++ b/src/locker/locker.hpp
@@ -0,0 +1,106 @@
+#pragma once
+#include <csignal>
+#include <memory>
+#include <gtkmm/cssprovider.h>
+#include <gtk4-session-lock.h>
+#include <wayland-client.h>
+
+#include "glibmm/refptr.h"
+#include "lockscreen.hpp"
+#include "sigc++/connection.h"
+#include "wf-shell-app.hpp"
+#include "plugin.hpp"
+
+using Plugin = std::shared_ptr<WayfireLockerPlugin>;
+void on_session_locked_c(GtkSessionLockInstance *lock, void *data);
+void on_session_lock_failed_c(GtkSessionLockInstance *lock, void *data);
+void on_session_unlocked_c(GtkSessionLockInstance *lock, void *data);
+void on_monitor_present_c(GtkSessionLockInstance *lock, GdkMonitor *monitor, void *data);
+
+enum ExitType
+{
+    USER_UNLOCKED    = SIGUSR1,
+    LOCKED           = SIGHUP,
+    ERROR_NOT_LOCKED = SIGTERM,
+};
+
+class WayfireLockerApp : public WayfireShellApp
+{
+  private:
+    WayfireLockerApp(WayfireLockerApp const& copy);
+    WayfireLockerApp& operator =(WayfireLockerApp const& copy);
+
+    std::string get_config_file() override;
+
+    GtkSessionLockInstance *lock;
+    std::map<std::string, Plugin> plugins = {};
+
+    bool m_is_debug     = false;
+    bool m_is_locked    = false;
+    bool instant_lock   = false;
+    int window_id_count = 0;
+    int bad_auth_count  = 0;
+    bool lockout = false;
+    std::string cache_file = "";
+    std::string background_path = "";
+    pid_t p_pid;
+
+    int inotify_bg_file;
+    Glib::RefPtr<BackgroundImage> background_file;
+
+
+    std::vector<Glib::RefPtr<Gtk::CssProvider>> css_rules;
+    sigc::connection lockout_signal, prewake_signal;
+    std::vector<sigc::connection> windows_signals;
+
+  public:
+    using WayfireShellApp::WayfireShellApp;
+    static void create(int argc, char **argv, pid_t p_pid);
+    static WayfireLockerApp& get()
+    {
+        return (WayfireLockerApp&)WayfireShellApp::get();
+    }
+
+    Gio::Application::Flags get_extra_application_flags() override;
+    std::string get_application_name() override;
+    void command_line() override;
+
+    /* Starts the program. get() is valid afterward the first (and the only)
+     * call to create() */
+    void on_monitor_present(GdkMonitor *monitor);
+    void on_activate() override;
+    bool is_debug()
+    {
+        return m_is_debug;
+    }
+
+    bool exit_on_unlock = true;
+
+
+    bool is_locked();
+    void set_is_locked(bool locked);
+    WayfireLockerApp();
+    ~WayfireLockerApp();
+
+    Plugin get_plugin(std::string name);
+
+    /* Give commands to compositor about lock state, or emulate them*/
+    void perform_unlock(std::string reason);
+    void perform_lock();
+    void init_plugins();
+    void deinit_plugins();
+    bool can_early_wake = true;
+    void user_activity();
+
+    void recieved_bad_auth();
+    bool is_locked_out();
+    void reload_background();
+
+    /* Send a signal to parent process
+     *  SIGHUP = We are successfully locked. exit(0)
+     *  SIGTERM = An error occured, and we did not lock. exit(2)
+     */
+    void kill_parent(ExitType);
+
+    std::map<int, std::shared_ptr<WayfireLockerAppLockscreen>> window_list;
+};
diff --git a/src/locker/lockergrid.hpp b/src/locker/lockergrid.hpp
new file mode 100644
index 00000000..053b61be
--- /dev/null
+++ b/src/locker/lockergrid.hpp
@@ -0,0 +1,151 @@
+#pragma once
+#include <algorithm>
+#include <exception>
+#include <gtkmm/centerbox.h>
+#include <gtkmm/box.h>
+
+#include "timedrevealer.hpp"
+
+
+class WayfireLockerGrid : public Gtk::CenterBox
+{
+    Gtk::CenterBox row1, row2, row3;
+    Gtk::Box box[9];
+
+  public:
+    void window_activity()
+    {
+        for (int count = 0; count < 9; count++)
+        {
+            for (auto child = box[count].get_first_child();
+                 child != nullptr;
+                 child = child->get_next_sibling())
+            {
+                auto cast_child = (WayfireLockerTimedRevealer*)child;
+                cast_child->activity();
+            }
+        }
+    }
+
+    void remove(WayfireLockerTimedRevealer & widget)
+    {
+        for (int count = 0; count < 9; count++)
+        {
+            auto list    = box[count].get_children();
+            int children = std::count(list.begin(), list.end(), &widget);
+            if (children == 1)
+            {
+                box[count].remove(widget);
+            }
+        }
+    }
+
+    /* Config string to box from grid */
+    void attach(WayfireLockerTimedRevealer & widget, std::string pos_string)
+    {
+        if (pos_string == "top-left")
+        {
+            attach(widget, 0, 0);
+        } else if (pos_string == "top-center")
+        {
+            attach(widget, 1, 0);
+        } else if (pos_string == "top-right")
+        {
+            attach(widget, 2, 0);
+        } else if (pos_string == "center-left")
+        {
+            attach(widget, 0, 1);
+        } else if (pos_string == "center-center")
+        {
+            attach(widget, 1, 1);
+        } else if (pos_string == "center-right")
+        {
+            attach(widget, 2, 1);
+        } else if (pos_string == "bottom-left")
+        {
+            attach(widget, 0, 2);
+        } else if (pos_string == "bottom-center")
+        {
+            attach(widget, 1, 2);
+        } else if (pos_string == "bottom-right")
+        {
+            attach(widget, 2, 2);
+        } else
+        {
+            throw std::exception();
+        }
+    }
+
+    void attach(WayfireLockerTimedRevealer & widget, int col, int row)
+    {
+        if ((col > 2) || (row > 2) || (col < 0) || (row < 0))
+        {
+            throw std::exception();
+        }
+
+        if (col == 0)
+        {
+            widget.set_halign(Gtk::Align::START);
+        } else if (col == 1)
+        {
+            widget.set_halign(Gtk::Align::CENTER);
+        } else if (col == 2)
+        {
+            widget.set_halign(Gtk::Align::END);
+        }
+
+        if (row == 0)
+        {
+            widget.set_valign(Gtk::Align::START);
+        } else if (row == 1)
+        {
+            widget.set_valign(Gtk::Align::CENTER);
+        } else if (row == 2)
+        {
+            widget.set_valign(Gtk::Align::END);
+        }
+
+        box[col + (row * 3)].append(widget);
+    }
+
+    WayfireLockerGrid()
+    {
+        set_start_widget(row1);
+        set_center_widget(row2);
+        set_end_widget(row3);
+        set_orientation(Gtk::Orientation::VERTICAL);
+        row1.set_start_widget(box[0]);
+        row1.set_center_widget(box[1]);
+        row1.set_end_widget(box[2]);
+        row2.set_start_widget(box[3]);
+        row2.set_center_widget(box[4]);
+        row2.set_end_widget(box[5]);
+        row3.set_start_widget(box[6]);
+        row3.set_center_widget(box[7]);
+        row3.set_end_widget(box[8]);
+        for (int i = 0; i < 9; i++)
+        {
+            box[i].set_orientation(Gtk::Orientation::VERTICAL);
+        }
+
+        box[0].set_valign(Gtk::Align::START);
+        box[1].set_valign(Gtk::Align::START);
+        box[2].set_valign(Gtk::Align::START);
+        box[3].set_valign(Gtk::Align::CENTER);
+        box[4].set_valign(Gtk::Align::CENTER);
+        box[5].set_valign(Gtk::Align::CENTER);
+        box[6].set_valign(Gtk::Align::END);
+        box[7].set_valign(Gtk::Align::END);
+        box[8].set_valign(Gtk::Align::END);
+
+        box[0].set_halign(Gtk::Align::START);
+        box[1].set_halign(Gtk::Align::CENTER);
+        box[2].set_halign(Gtk::Align::END);
+        box[3].set_halign(Gtk::Align::START);
+        box[4].set_halign(Gtk::Align::CENTER);
+        box[5].set_halign(Gtk::Align::END);
+        box[6].set_halign(Gtk::Align::START);
+        box[7].set_halign(Gtk::Align::CENTER);
+        box[8].set_halign(Gtk::Align::END);
+    }
+};
diff --git a/src/locker/lockscreen.cpp b/src/locker/lockscreen.cpp
new file mode 100644
index 00000000..ed40f41d
--- /dev/null
+++ b/src/locker/lockscreen.cpp
@@ -0,0 +1,97 @@
+#include "glib.h"
+#include "locker.hpp"
+#include "lockergrid.hpp"
+#include "lockscreen.hpp"
+
+
+WayfireLockerAppLockscreen::WayfireLockerAppLockscreen(std::string background_path)
+{
+    grid = std::make_shared<WayfireLockerGrid>();
+    set_child(overlay);
+    overlay.set_child(background);
+    overlay.add_overlay(*grid);
+    grid->set_halign(Gtk::Align::FILL);
+    grid->set_valign(Gtk::Align::FILL);
+    add_css_class("wf-locker");
+    grid->set_expand(true);
+
+    /* Prepare background */
+    Glib::signal_idle().connect([this, background_path] ()
+    {
+        background.show_image(background_path);
+        return G_SOURCE_REMOVE;
+    });
+
+    auto wf_background_cb = [this] ()
+    {
+        if ((bool)wf_background)
+        {
+            background.show();
+        } else
+        {
+            background.hide();
+        }
+    };
+    wf_background.set_callback(wf_background_cb);
+    wf_background_cb();
+
+    /* Mouse press or screen touch */
+    auto click_gesture = Gtk::GestureClick::create();
+    click_gesture->set_propagation_phase(Gtk::PropagationPhase::CAPTURE);
+    signals.push_back(click_gesture->signal_released().connect([=] (int count, double x, double y)
+    {
+        window_activity();
+    }));
+    add_controller(click_gesture);
+
+    /* Mouse movement */
+    auto pointer_gesture = Gtk::EventControllerMotion::create();
+    signals.push_back(pointer_gesture->signal_motion().connect([=] (double x, double y)
+    {
+        // Avoid first motion event and repeated with same location
+        int ix = x;
+        int iy = y;
+        if ((last_x < 0) && (last_y < 0))
+        {
+            last_x = ix;
+            last_y = iy;
+            return;
+        }
+
+        if ((ix == last_x) && (iy == last_y))
+        {
+            return;
+        }
+
+        last_x = ix;
+        last_y = iy;
+        window_activity();
+    }));
+    add_controller(pointer_gesture);
+    /* Keypress */
+    auto typing_gesture = Gtk::EventControllerKey::create();
+    typing_gesture->set_propagation_phase(Gtk::PropagationPhase::CAPTURE);
+    signals.push_back(typing_gesture->signal_key_pressed().connect([=] (guint keyval, guint keycode,
+                                                                        Gdk::ModifierType state)
+    {
+        window_activity();
+        return false;
+    }, false));
+    add_controller(typing_gesture);
+}
+
+void WayfireLockerAppLockscreen::window_activity()
+{
+    // Alert entire locker, in case of pre-wake
+    WayfireLockerApp::get().user_activity();
+    // Alert all widgets in window, to reveal themselves
+    grid->window_activity();
+}
+
+void WayfireLockerAppLockscreen::disconnect()
+{
+    for (auto signal : signals)
+    {
+        signal.disconnect();
+    }
+}
diff --git a/src/locker/lockscreen.hpp b/src/locker/lockscreen.hpp
new file mode 100644
index 00000000..1d6db345
--- /dev/null
+++ b/src/locker/lockscreen.hpp
@@ -0,0 +1,29 @@
+#pragma once
+#include <gtkmm.h>
+#include <giomm.h>
+#include <memory>
+#include <sigc++/connection.h>
+
+#include "background-gl.hpp"
+#include "gtkmm/overlay.h"
+#include "wf-option-wrap.hpp"
+#include "lockergrid.hpp"
+class WayfireLockerAppLockscreen : public Gtk::Window
+{
+  public:
+    Gtk::Overlay overlay;
+    BackgroundGLArea background;
+    std::shared_ptr<WayfireLockerGrid> grid;
+    sigc::connection timeout;
+    WfOption<double> hide_timeout{"locker/hide_time"};
+    WfOption<bool> wf_background{"locker/background_image"};
+    std::vector<sigc::connection> signals;
+    int last_x = -1, last_y = -1;
+
+    WayfireLockerAppLockscreen(std::string background_path);
+
+    void start_disappear_timer();
+    void disconnect();
+
+    void window_activity();
+};
diff --git a/src/locker/meson.build b/src/locker/meson.build
new file mode 100644
index 00000000..3ca1fefd
--- /dev/null
+++ b/src/locker/meson.build
@@ -0,0 +1,37 @@
+widget_sources = [
+    'plugin/clock.cpp',
+    'plugin/weather.cpp',
+    'plugin/battery.cpp',
+    'plugin/password.cpp',
+    'plugin/instant.cpp',
+    'plugin/pin.cpp',
+    'plugin/fingerprint.cpp',
+    'plugin/mpris.cpp',
+    'plugin/user.cpp',
+    'plugin/network.cpp',
+]
+deps = [
+  gtklayershell,
+  gtkmm,
+  wayland_client,
+  libutil,
+  wf_protos,
+  wfconfig,
+  xkbregistry,
+  json,
+  pam,
+  openssl,
+  epoxy,
+]
+
+if libpulse.found()
+  widget_sources += 'plugin/volume.cpp'
+  deps += [libpulse, libgvc]
+endif
+
+executable(
+  'wf-locker',
+  ['locker.cpp', 'lockscreen.cpp', 'timedrevealer.cpp'] + widget_sources,
+  dependencies: deps,
+  install: true,
+)
diff --git a/src/locker/plugin.hpp b/src/locker/plugin.hpp
new file mode 100644
index 00000000..1a9687f5
--- /dev/null
+++ b/src/locker/plugin.hpp
@@ -0,0 +1,30 @@
+#pragma once
+#include "wf-option-wrap.hpp"
+#include "lockergrid.hpp"
+#define DEFAULT_PANEL_HEIGHT "48"
+#define DEFAULT_ICON_SIZE 32
+
+#define PANEL_POSITION_BOTTOM "bottom"
+#define PANEL_POSITION_TOP "top"
+
+/* Differs to panel widgets.
+ *  One instance of each plugin exists and it must account for
+ *  multiple widgets in multiple windows. */
+class WayfireLockerPlugin
+{
+  public:
+    WayfireLockerPlugin(std::string prefix) :
+        enable(WfOption<bool>{prefix + "_enable"}),
+        always(WfOption<bool>{prefix + "_always"}),
+        position(WfOption<std::string>{prefix + "_position"})
+    {}
+    WfOption<bool> enable, always;
+    WfOption<std::string> position;
+    virtual void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)    = 0;
+    virtual void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) = 0;
+    virtual void init()   = 0; /* Called just before lockscreens shown. */
+    virtual void deinit() = 0; /* Called after lockscreen unlocked. */
+    virtual void lockout_changed(bool lockout)
+    {} /* Called when too many failed logins have occured */
+    virtual ~WayfireLockerPlugin() = default;
+};
diff --git a/src/locker/plugin/battery.cpp b/src/locker/plugin/battery.cpp
new file mode 100644
index 00000000..f10d9280
--- /dev/null
+++ b/src/locker/plugin/battery.cpp
@@ -0,0 +1,285 @@
+#include <memory>
+#include <iostream>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+#include <string>
+
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+#include "battery.hpp"
+
+
+static const std::string BATTERY_STATUS_ICON    = "icon"; // icon
+static const std::string BATTERY_STATUS_PERCENT = "percentage"; // icon + percentage
+static const std::string BATTERY_STATUS_FULL    = "full"; // icon + percentage + TimeToFull/TimeToEmpty
+
+static bool is_charging(uint32_t state)
+{
+    return (state == 1) || (state == 5);
+}
+
+static bool is_discharging(uint32_t state)
+{
+    return (state == 2) || (state == 6);
+}
+
+static std::string state_descriptions[] = {
+    "Unknown", // 0
+    "Charging", // 1
+    "Discharging", // 2
+    "Empty", // 3
+    "Fully charged", // 4
+    "Pending charge", // 5
+    "Pending discharge", // 6
+};
+
+static std::string get_device_type_description(uint32_t type)
+{
+    if (type == 2)
+    {
+        return "Battery ";
+    }
+
+    if (type == 3)
+    {
+        return "UPS ";
+    }
+
+    return "";
+}
+
+static std::string format_digit(int digit)
+{
+    return digit <= 9 ? ("0" + std::to_string(digit)) :
+           std::to_string(digit);
+}
+
+static std::string uint_to_time(int64_t time)
+{
+    int hrs = time / 3600;
+    int min = (time / 60) % 60;
+
+    return format_digit(hrs) + ":" + format_digit(min);
+}
+
+void WayfireLockerBatteryPlugin::update_percentages(std::string text)
+{
+    for (auto& it : widgets)
+    {
+        it.second->label.set_label(text);
+    }
+}
+
+void WayfireLockerBatteryPlugin::update_descriptions(std::string text)
+{
+    for (auto& it : widgets)
+    {
+        it.second->subtext.set_label(text);
+    }
+}
+
+void WayfireLockerBatteryPlugin::update_images()
+{
+    Glib::Variant<Glib::ustring> icon_name;
+    display_device->get_cached_property(icon_name, ICON);
+    for (auto& it : widgets)
+    {
+        it.second->image.set_from_icon_name(icon_name.get());
+    }
+}
+
+WayfireLockerBatteryPluginWidget::WayfireLockerBatteryPluginWidget() :
+    WayfireLockerTimedRevealer("locker/battery_always")
+{
+    set_child(grid);
+    label.add_css_class("battery-percent");
+    subtext.add_css_class("battery-description");
+    image.add_css_class("battery-image");
+
+    grid.attach(image, 0, 0);
+    grid.attach(label, 1, 0);
+    grid.attach(subtext, 0, 1, 2, 1);
+}
+
+void WayfireLockerBatteryPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.emplace(id, new WayfireLockerBatteryPluginWidget());
+    auto widget = widgets[id];
+
+    if (!show_state)
+    {
+        widget->hide();
+    }
+
+    grid->attach(*widget, (std::string)position);
+
+    update_details();
+}
+
+void WayfireLockerBatteryPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    grid->remove(*widgets[id]);
+    widgets.erase(id);
+}
+
+void WayfireLockerBatteryPlugin::init()
+{
+    if (!setup_dbus())
+    {
+        hide();
+    }
+}
+
+void WayfireLockerBatteryPlugin::deinit()
+{
+    if (signal)
+    {
+        signal.disconnect();
+    }
+
+    display_device = nullptr;
+    upower_proxy   = nullptr;
+    connection     = nullptr;
+}
+
+bool WayfireLockerBatteryPlugin::setup_dbus()
+{
+    auto cancellable = Gio::Cancellable::create();
+    connection = Gio::DBus::Connection::get_sync(Gio::DBus::BusType::SYSTEM, cancellable);
+    if (!connection)
+    {
+        std::cerr << "Failed to connect to dbus" << std::endl;
+        return false;
+    }
+
+    upower_proxy = Gio::DBus::Proxy::create_sync(connection, UPOWER_NAME,
+        "/org/freedesktop/UPower",
+        "org.freedesktop.UPower");
+    if (!upower_proxy)
+    {
+        std::cerr << "Failed to connect to UPower" << std::endl;
+        return false;
+    }
+
+    display_device = Gio::DBus::Proxy::create_sync(connection,
+        UPOWER_NAME,
+        DISPLAY_DEVICE,
+        "org.freedesktop.UPower.Device");
+    if (!display_device)
+    {
+        return false;
+    }
+
+    Glib::Variant<bool> present;
+    display_device->get_cached_property(present, SHOULD_DISPLAY);
+    if (present.get())
+    {
+        signal = display_device->signal_properties_changed().connect(
+            sigc::mem_fun(*this, &WayfireLockerBatteryPlugin::on_properties_changed));
+
+        return true;
+    }
+
+    return false;
+}
+
+void WayfireLockerBatteryPlugin::on_properties_changed(
+    const Gio::DBus::Proxy::MapChangedProperties& properties,
+    const std::vector<Glib::ustring>& invalidated)
+{
+    bool invalid_icon = false, invalid_details = false;
+    for (auto& prop : properties)
+    {
+        if (prop.first == ICON)
+        {
+            invalid_icon = true;
+        }
+
+        if ((prop.first == TYPE) || (prop.first == STATE) || (prop.first == PERCENTAGE) ||
+            (prop.first == TIMETOFULL) || (prop.first == TIMETOEMPTY))
+        {
+            invalid_details = true;
+        }
+
+        if (prop.first == SHOULD_DISPLAY)
+        {}
+    }
+
+    if (invalid_icon)
+    {
+        update_images();
+    }
+
+    if (invalid_details)
+    {
+        update_details();
+    }
+}
+
+void WayfireLockerBatteryPlugin::update_details()
+{
+    if (display_device == nullptr)
+    {
+        std::cout << "No battery proxy!" << std::endl;
+        return;
+    }
+
+    Glib::Variant<guint32> type;
+    display_device->get_cached_property(type, TYPE);
+
+    Glib::Variant<guint32> vstate;
+    display_device->get_cached_property(vstate, STATE);
+    uint32_t state = vstate.get();
+
+    Glib::Variant<gdouble> vpercentage;
+    display_device->get_cached_property(vpercentage, PERCENTAGE);
+    auto percentage_string = std::to_string((int)vpercentage.get()) + "%";
+
+    Glib::Variant<gint64> time_to_full;
+    display_device->get_cached_property(time_to_full, TIMETOFULL);
+
+    Glib::Variant<gint64> time_to_empty;
+    display_device->get_cached_property(time_to_empty, TIMETOEMPTY);
+
+    std::string description = state_descriptions[state];
+    if (is_charging(state))
+    {
+        description += ", " + uint_to_time(time_to_full.get()) + " until full";
+    } else if (is_discharging(state))
+    {
+        description += ", " + uint_to_time(time_to_empty.get()) + " remaining";
+    }
+
+    if (state == 0) /* Unknown */
+    {
+        hide();
+        return;
+    }
+
+    show();
+    update_descriptions(get_device_type_description(type.get()) + description);
+    update_percentages(percentage_string);
+    update_images();
+}
+
+void WayfireLockerBatteryPlugin::hide()
+{
+    show_state = false;
+    for (auto& it : widgets)
+    {
+        it.second->hide();
+    }
+}
+
+void WayfireLockerBatteryPlugin::show()
+{
+    show_state = true;
+    for (auto& it : widgets)
+    {
+        it.second->show();
+    }
+}
+
+WayfireLockerBatteryPlugin::WayfireLockerBatteryPlugin() :
+    WayfireLockerPlugin("locker/battery")
+{}
diff --git a/src/locker/plugin/battery.hpp b/src/locker/plugin/battery.hpp
new file mode 100644
index 00000000..d1983aab
--- /dev/null
+++ b/src/locker/plugin/battery.hpp
@@ -0,0 +1,65 @@
+#pragma once
+#include <memory>
+#include <string>
+#include <gtkmm/label.h>
+#include <gtkmm/image.h>
+#include <gtkmm/grid.h>
+#include <giomm.h>
+
+#include "plugin.hpp"
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+
+using DBusConnection = Glib::RefPtr<Gio::DBus::Connection>;
+using DBusProxy = Glib::RefPtr<Gio::DBus::Proxy>;
+/* Shamelessly copied in from battery in panel */
+
+#define UPOWER_NAME "org.freedesktop.UPower"
+#define DISPLAY_DEVICE "/org/freedesktop/UPower/devices/DisplayDevice"
+
+#define ICON           "IconName"
+#define TYPE           "Type"
+#define STATE          "State"
+#define PERCENTAGE     "Percentage"
+#define TIMETOFULL     "TimeToFull"
+#define TIMETOEMPTY    "TimeToEmpty"
+#define SHOULD_DISPLAY "IsPresent"
+
+class WayfireLockerBatteryPluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    Gtk::Grid grid;
+    Gtk::Image image;
+    Gtk::Label label, subtext;
+    WayfireLockerBatteryPluginWidget();
+};
+
+class WayfireLockerBatteryPlugin : public WayfireLockerPlugin
+{
+  private:
+    DBusConnection connection;
+    DBusProxy upower_proxy, display_device;
+    void on_properties_changed(
+        const Gio::DBus::Proxy::MapChangedProperties& properties,
+        const std::vector<Glib::ustring>& invalidated);
+    bool setup_dbus();
+    sigc::connection signal;
+
+  public:
+    WayfireLockerBatteryPlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+    void hide();
+    void show();
+    bool show_state = true;
+
+    void update_percentages(std::string text);
+    void update_descriptions(std::string text);
+    void update_images();
+    void update_details();
+
+
+    std::map<int, std::shared_ptr<WayfireLockerBatteryPluginWidget>> widgets;
+};
diff --git a/src/locker/plugin/clock.cpp b/src/locker/plugin/clock.cpp
new file mode 100644
index 00000000..9d4edaf6
--- /dev/null
+++ b/src/locker/plugin/clock.cpp
@@ -0,0 +1,80 @@
+#include <memory>
+#include <glibmm.h>
+#include <gtkmm/box.h>
+
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+#include "clock.hpp"
+
+
+void WayfireLockerClockPlugin::update_labels(std::string text)
+{
+    for (auto& it : widgets)
+    {
+        it.second->label.set_markup(text);
+    }
+
+    label_contents = text;
+}
+
+WayfireLockerClockPluginWidget::WayfireLockerClockPluginWidget(std::string contents) :
+    WayfireLockerTimedRevealer("locker/clock_always")
+{
+    set_child(label);
+    label.add_css_class("clock");
+    label.set_markup(contents);
+    label.set_justify(Gtk::Justification::CENTER);
+}
+
+void WayfireLockerClockPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.emplace(id, new WayfireLockerClockPluginWidget(label_contents));
+    auto widget = widgets[id];
+
+    grid->attach(*widget, position);
+}
+
+void WayfireLockerClockPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    grid->remove(*widgets[id]);
+    widgets.erase(id);
+}
+
+void WayfireLockerClockPlugin::update_time()
+{
+    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.
+     *
+     * 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] == ' ')
+    {
+        i++;
+    }
+
+    this->update_labels(text.substr(i));
+}
+
+WayfireLockerClockPlugin::WayfireLockerClockPlugin() :
+    WayfireLockerPlugin("locker/clock")
+{}
+
+void WayfireLockerClockPlugin::init()
+{
+    timeout = Glib::signal_timeout().connect_seconds(
+        [this] ()
+    {
+        this->update_time();
+        return G_SOURCE_CONTINUE;
+    }, 1);
+}
+
+void WayfireLockerClockPlugin::deinit()
+{
+    timeout.disconnect();
+}
diff --git a/src/locker/plugin/clock.hpp b/src/locker/plugin/clock.hpp
new file mode 100644
index 00000000..69a79380
--- /dev/null
+++ b/src/locker/plugin/clock.hpp
@@ -0,0 +1,34 @@
+#pragma once
+#include <gtkmm/label.h>
+#include <unordered_map>
+
+#include "plugin.hpp"
+#include "timedrevealer.hpp"
+#include "wf-option-wrap.hpp"
+#include "lockergrid.hpp"
+
+class WayfireLockerClockPluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    Gtk::Label label;
+    WayfireLockerClockPluginWidget(std::string contents);
+};
+
+class WayfireLockerClockPlugin : public WayfireLockerPlugin
+{
+  public:
+    WayfireLockerClockPlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+
+    WfOption<std::string> format{"locker/clock_format"};
+
+    sigc::connection timeout;
+    void update_labels(std::string text);
+    void update_time();
+
+    std::unordered_map<int, std::shared_ptr<WayfireLockerClockPluginWidget>> widgets;
+    std::string label_contents = "";
+};
diff --git a/src/locker/plugin/fingerprint.cpp b/src/locker/plugin/fingerprint.cpp
new file mode 100644
index 00000000..5dabaccb
--- /dev/null
+++ b/src/locker/plugin/fingerprint.cpp
@@ -0,0 +1,428 @@
+#include <memory>
+#include <string>
+#include <iostream>
+#include <giomm.h>
+#include <giomm/dbusproxy.h>
+#include <glibmm/ustring.h>
+#include <glibmm/variant.h>
+#include <gtkmm/image.h>
+#include <gtkmm/box.h>
+#include <glib.h>
+
+#include "locker.hpp"
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+#include "fingerprint.hpp"
+
+/**
+ * Fingerprint Reader Auth
+ *
+ * Based on fprintd DBUS Spec:
+ * https://fprint.freedesktop.org/fprintd-dev/
+ */
+
+WayfireLockerFingerprintPlugin::WayfireLockerFingerprintPlugin() :
+    WayfireLockerPlugin("locker/fingerprint")
+{}
+
+WayfireLockerFingerprintPlugin::~WayfireLockerFingerprintPlugin()
+{
+    if (device_proxy)
+    {
+        device_proxy->call_sync("Release");
+    }
+}
+
+void WayfireLockerFingerprintPlugin::on_connection(const Glib::RefPtr<Gio::DBus::Connection> & connection,
+    const Glib::ustring & name)
+{
+    /* Bail here if config has this disabled */
+    if (!enable)
+    {
+        return;
+    }
+
+    Gio::DBus::Proxy::create(connection,
+        "net.reactivated.Fprint",
+        "/net/reactivated/Fprint/Manager",
+        "net.reactivated.Fprint.Manager",
+        [this, connection] (const Glib::RefPtr<Gio::AsyncResult> & result)
+    {
+        manager_proxy = Gio::DBus::Proxy::create_finish(result);
+        get_device();
+    });
+}
+
+void WayfireLockerFingerprintPlugin::get_device()
+{
+    if (device_proxy != nullptr)
+    {
+        std::cerr << "get_device when device_proxy is not null" << std::endl;
+        return;
+    }
+
+    try {
+        auto default_device = manager_proxy->call_sync("GetDefaultDevice");
+        Glib::Variant<Glib::ustring> item_path;
+        default_device.get_child(item_path, 0);
+        Gio::DBus::Proxy::create(connection,
+            "net.reactivated.Fprint",
+            item_path.get(),
+            "net.reactivated.Fprint.Device",
+            sigc::mem_fun(*this, &WayfireLockerFingerprintPlugin::on_device_acquired));
+    } catch (Glib::Error & e) /* TODO : Narrow down? */
+    {
+        hide();
+        return;
+    }
+}
+
+void WayfireLockerFingerprintPlugin::on_device_acquired(const Glib::RefPtr<Gio::AsyncResult> & result)
+{
+    device_proxy = Gio::DBus::Proxy::create_finish(result);
+    update("Listing fingers...", "system-search-symbolic", "info");
+    char *username = getlogin();
+    auto reply     = device_proxy->call_sync("ListEnrolledFingers", nullptr,
+        Glib::Variant<std::tuple<Glib::ustring>>::create(username));
+    Glib::Variant<std::vector<Glib::ustring>> array;
+    reply.get_child(array, 0);
+
+    if (array.get_n_children() == 0)
+    {
+        // Zero fingers for this user.
+        show();
+        update("No fingerprints enrolled", "dialog-error-symbolic", "bad");
+        // Don't hide entirely, allow the user to see this specific fail
+        return;
+    }
+
+    show();
+    update("Fingerprint Device Ready", "system-search-symbolic", "info");
+    Glib::Variant<Glib::ustring> finger;
+    reply.get_child(finger, 0);
+
+    start_fingerprint_scanning();
+}
+
+void WayfireLockerFingerprintPlugin::start_fingerprint_scanning()
+{
+    if (!enable)
+    {
+        return;
+    }
+
+    if (WayfireLockerApp::get().is_locked_out())
+    {
+        return;
+    }
+
+    if (signal)
+    {
+        signal.disconnect();
+    }
+
+    signal = device_proxy->signal_signal().connect([this] (const Glib::ustring & sender_name,
+                                                           const Glib::ustring & signal_name,
+                                                           const Glib::VariantContainerBase & params)
+    {
+        if (device_proxy == nullptr)
+        {
+            return; // Skip close-down messages
+        }
+
+        if (signal_name == "VerifyStatus")
+        {
+            Glib::Variant<Glib::ustring> mesg;
+            Glib::Variant<bool> done;
+            params.get_child(mesg, 0);
+            params.get_child(done, 1);
+            bool is_done = done.get();
+
+            update(mesg.get(), "system-search-symbolic", "info");
+            if (mesg.get() == "verify-match")
+            {
+                std::cout << "Match" << std::endl;
+                stop_fingerprint_scanning();
+                WayfireLockerApp::get().perform_unlock("Fingerprint verified");
+                return;
+            }
+
+            if (mesg.get() == "verify-no-match")
+            {
+                std::cout << "No match" << std::endl;
+                show();
+                update("Invalid fingerprint", "dialog-error-symbolic", "bad");
+                stop_fingerprint_scanning();
+                WayfireLockerApp::get().recieved_bad_auth();
+
+                /* Reschedule fingerprint scan */
+                starting_fingerprint = Glib::signal_timeout().connect(
+                    [this] ()
+                {
+                    this->start_fingerprint_scanning();
+                    return G_SOURCE_REMOVE;
+                }, 500);
+                return;
+            } else if (mesg.get() == "verify-unknown-error")
+            {
+                update("Unknown error", "dialog-error-symbolic", "info");
+                stop_fingerprint_scanning();
+                /* Reschedule fingerprint scan */
+                starting_fingerprint = Glib::signal_timeout().connect(
+                    [this] ()
+                {
+                    this->start_fingerprint_scanning();
+                    return G_SOURCE_REMOVE;
+                }, 500);
+                return;
+            } else if (mesg.get() == "verify-disconnected")
+            {
+                update("Reader disconnected", "dialog-error-symbolic", "bad");
+                /* This needs testing on a machine with removable fprint reader */
+                device_proxy = nullptr;
+                if (signal)
+                {
+                    signal.disconnect();
+                }
+
+                /* Delay, cools down a repeated failing loop */
+                finding_new_device = Glib::signal_timeout().connect_seconds(
+                    [this] ()
+                {
+                    get_device();
+                    return G_SOURCE_REMOVE;
+                }, 2);
+                return;
+            }
+
+            if (is_done && (device_proxy != nullptr))
+            {
+                stop_fingerprint_scanning();
+            }
+        } else if (signal_name == "VerifyFingerSelected")
+        {
+            /* TODO potentially present this to user to tell them
+             *  which fingerprint is being expected */
+            Glib::Variant<Glib::ustring> finger_name;
+            params.get_child(finger_name, 0);
+            std::cout << "Finger : " << finger_name.get() << std::endl;
+        }
+    }, false);
+    if (device_proxy)
+    {
+        if (starting_fingerprint)
+        {
+            starting_fingerprint.disconnect();
+        }
+
+        try {
+            char *username = getlogin();
+            device_proxy->call_sync("Claim", nullptr,
+                Glib::Variant<std::tuple<Glib::ustring>>::create({username}));
+        } catch (Glib::Error & e) /* TODO : Narrow down? */
+        {
+            stop_fingerprint_scanning();
+            std::cout << "Fingerprint device already claimed, try in 3s" << std::endl;
+            update("Fingerprint reader busy...", "dialog-error-symbolic", "info");
+            Glib::signal_timeout().connect_seconds(
+                [this] ()
+            {
+                this->start_fingerprint_scanning();
+                return G_SOURCE_REMOVE;
+            }, 3);
+            return;
+        }
+
+        show();
+        update("Use fingerprint to unlock", "process-completed-symbolic", "good");
+        device_proxy->call_sync("VerifyStart",
+            nullptr,
+            Glib::Variant<std::tuple<Glib::ustring>>::create({""}));
+    } else
+    {
+        update("Unable to start fingerprint scan", "dialog-error-symbolic", "bad");
+        hide();
+    }
+}
+
+void WayfireLockerFingerprintPlugin::stop_fingerprint_scanning()
+{
+    if (starting_fingerprint)
+    {
+        starting_fingerprint.disconnect();
+    }
+
+    if (!device_proxy)
+    {
+        return;
+    }
+
+    if (signal)
+    {
+        signal.disconnect();
+    }
+
+    /* Stop if running. Eventually log or respond to errors
+     *   but for now, avoid crashing lockscreen on close-down */
+    try {
+        device_proxy->call_sync("VerifyStop");
+        device_proxy->call_sync("Release");
+    } catch (Glib::Error & e)
+    {}
+}
+
+void WayfireLockerFingerprintPlugin::init()
+{
+    auto cancellable = Gio::Cancellable::create();
+    connection = Gio::DBus::Connection::get_sync(Gio::DBus::BusType::SYSTEM, cancellable);
+    if (!connection)
+    {
+        std::cerr << "Failed to connect to dbus" << std::endl;
+        return;
+    }
+
+    Gio::DBus::Proxy::create(
+        connection,
+        "net.reactivated.Fprint",
+        "/net/reactivated/Fprint/Manager",
+        "net.reactivated.Fprint.Manager",
+        [this] (const Glib::RefPtr<Gio::AsyncResult> & result)
+    {
+        auto manager_proxy = Gio::DBus::Proxy::create_finish(result);
+        try {
+            auto default_device = manager_proxy->call_sync("GetDefaultDevice");
+            Glib::Variant<Glib::ustring> item_path;
+            default_device.get_child(item_path, 0);
+            Gio::DBus::Proxy::create(connection,
+                "net.reactivated.Fprint",
+                item_path.get(),
+                "net.reactivated.Fprint.Device",
+                sigc::mem_fun(*this, &WayfireLockerFingerprintPlugin::on_device_acquired));
+        } catch (Glib::Error & e) /* TODO : Narrow down? */
+        {
+            hide();
+            return;
+        }
+    });
+}
+
+void WayfireLockerFingerprintPlugin::deinit()
+{
+    // Ensure we return state to allow other programs to use scanner
+    stop_fingerprint_scanning();
+    if (signal)
+    {
+        signal.disconnect();
+    }
+
+    if (starting_fingerprint)
+    {
+        starting_fingerprint.disconnect();
+    }
+
+    if (finding_new_device)
+    {
+        finding_new_device.disconnect();
+    }
+
+    device_proxy = nullptr;
+}
+
+WayfireLockerFingerprintPluginWidget::WayfireLockerFingerprintPluginWidget(std::string label_contents,
+    std::string image_contents,
+    std::string color_contents) :
+    WayfireLockerTimedRevealer("locker/fingerprint_always")
+{
+    set_child(box);
+    image_print.set_from_icon_name("auth-fingerprint-symbolic");
+    image_overlay.set_from_icon_name(image_contents);
+    label.set_label(label_contents);
+    overlay.set_child(image_print);
+    overlay.add_overlay(image_overlay);
+    image_overlay.set_halign(Gtk::Align::END);
+    image_overlay.set_valign(Gtk::Align::END);
+
+    overlay.add_css_class("fingerprint-overlay");
+    image_print.add_css_class("fingerprint-icon");
+    image_overlay.add_css_class("fingerprint-overlay-image");
+    label.add_css_class("fingerprint-text");
+    if (color_contents != "")
+    {
+        image_overlay.add_css_class(color_contents);
+    }
+
+    box.set_orientation(Gtk::Orientation::VERTICAL);
+    box.append(overlay);
+    box.append(label);
+}
+
+void WayfireLockerFingerprintPlugin::lockout_changed(bool lockout)
+{
+    if (lockout)
+    {
+        update("Too many attempts", "dialog-error-symbolic", "bad");
+        stop_fingerprint_scanning();
+    } else
+    {
+        if (enable && device_proxy)
+        {
+            show();
+            start_fingerprint_scanning();
+        }
+    }
+}
+
+void WayfireLockerFingerprintPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.emplace(id, new WayfireLockerFingerprintPluginWidget(label_contents, icon_contents,
+        color_contents));
+    auto widget = widgets[id];
+    if (!show_state)
+    {
+        widget->hide();
+    }
+
+    grid->attach(*widget, position);
+}
+
+void WayfireLockerFingerprintPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    grid->remove(*widgets[id]);
+    widgets.erase(id);
+}
+
+void WayfireLockerFingerprintPlugin::update(std::string label, std::string image, std::string color)
+{
+    icon_contents  = image;
+    label_contents = label;
+    color_contents = color;
+
+    for (auto& it : widgets)
+    {
+        it.second->label.set_label(label);
+        auto widget = &it.second->image_overlay;
+        widget->set_from_icon_name(image);
+        widget->remove_css_class("info");
+        widget->remove_css_class("bad");
+        widget->remove_css_class("good");
+        widget->add_css_class(color);
+    }
+}
+
+void WayfireLockerFingerprintPlugin::hide()
+{
+    show_state = false;
+    for (auto & it : widgets)
+    {
+        it.second->hide();
+    }
+}
+
+void WayfireLockerFingerprintPlugin::show()
+{
+    show_state = true;
+    for (auto & it : widgets)
+    {
+        it.second->show();
+    }
+}
diff --git a/src/locker/plugin/fingerprint.hpp b/src/locker/plugin/fingerprint.hpp
new file mode 100644
index 00000000..58245fa1
--- /dev/null
+++ b/src/locker/plugin/fingerprint.hpp
@@ -0,0 +1,63 @@
+#pragma once
+#include <gtkmm/box.h>
+#include <gtkmm/label.h>
+#include <gtkmm/image.h>
+#include <gtkmm/overlay.h>
+#include <giomm.h>
+#include <giomm/dbusproxy.h>
+#include <glibmm/refptr.h>
+#include <sigc++/connection.h>
+
+#include "lockergrid.hpp"
+#include "plugin.hpp"
+#include "timedrevealer.hpp"
+
+using DBusConnection = Glib::RefPtr<Gio::DBus::Connection>;
+using DBusProxy = Glib::RefPtr<Gio::DBus::Proxy>;
+
+class WayfireLockerFingerprintPluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    Gtk::Box box;
+    Gtk::Overlay overlay;
+    Gtk::Image image_print;
+    Gtk::Image image_overlay;
+    Gtk::Label label;
+    WayfireLockerFingerprintPluginWidget(std::string label_contents, std::string image_contents,
+        std::string color_contents);
+};
+
+class WayfireLockerFingerprintPlugin : public WayfireLockerPlugin
+{
+  private:
+    DBusConnection connection;
+    Glib::RefPtr<Gio::DBus::Proxy> device_proxy, manager_proxy;
+    sigc::connection signal;
+    sigc::connection starting_fingerprint, finding_new_device;
+
+  public:
+
+    WayfireLockerFingerprintPlugin();
+    ~WayfireLockerFingerprintPlugin();
+    void on_connection(const Glib::RefPtr<Gio::DBus::Connection> & connection, const Glib::ustring & name);
+    void get_device();
+    void on_device_acquired(const Glib::RefPtr<Gio::AsyncResult> & result);
+    void start_fingerprint_scanning();
+    void stop_fingerprint_scanning();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+    void lockout_changed(bool lockout) override;
+    void hide();
+    void show();
+    void color(std::string color);
+
+    bool show_state = false;
+    void update(std::string text, std::string image, std::string color);
+
+    std::map<int, std::shared_ptr<WayfireLockerFingerprintPluginWidget>> widgets;
+    std::string icon_contents  = "";
+    std::string label_contents = "";
+    std::string color_contents = "";
+};
diff --git a/src/locker/plugin/instant.cpp b/src/locker/plugin/instant.cpp
new file mode 100644
index 00000000..3c19369a
--- /dev/null
+++ b/src/locker/plugin/instant.cpp
@@ -0,0 +1,45 @@
+#include <memory>
+#include <gtkmm/button.h>
+#include <gtkmm/box.h>
+
+#include "locker.hpp"
+#include "lockergrid.hpp"
+#include "plugin.hpp"
+#include "timedrevealer.hpp"
+#include "instant.hpp"
+
+WayfireLockerInstantPlugin::WayfireLockerInstantPlugin() :
+    WayfireLockerPlugin("locker/instant_unlock")
+{}
+
+WayfireLockerInstantPluginWidget::WayfireLockerInstantPluginWidget() :
+    WayfireLockerTimedRevealer("locker/instant_unlock_always")
+{
+    set_child(button);
+    button.set_label("Unlock now");
+    button.add_css_class("instant-unlock");
+}
+
+void WayfireLockerInstantPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.emplace(id, new WayfireLockerInstantPluginWidget());
+    auto widget = widgets[id];
+    grid->attach(*widget, position);
+
+    widget->button.signal_clicked().connect([] ()
+    {
+        WayfireLockerApp::get().perform_unlock("Instant unlock pressed");
+    }, false);
+}
+
+void WayfireLockerInstantPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    grid->remove(*widgets[id]);
+    widgets.erase(id);
+}
+
+void WayfireLockerInstantPlugin::init()
+{}
+
+void WayfireLockerInstantPlugin::deinit()
+{}
diff --git a/src/locker/plugin/instant.hpp b/src/locker/plugin/instant.hpp
new file mode 100644
index 00000000..78f55a5d
--- /dev/null
+++ b/src/locker/plugin/instant.hpp
@@ -0,0 +1,25 @@
+#pragma once
+#include <gtkmm/button.h>
+
+#include "plugin.hpp"
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+
+class WayfireLockerInstantPluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    Gtk::Button button;
+    WayfireLockerInstantPluginWidget();
+};
+
+class WayfireLockerInstantPlugin : public WayfireLockerPlugin
+{
+  public:
+    WayfireLockerInstantPlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+
+    std::unordered_map<int, std::shared_ptr<WayfireLockerInstantPluginWidget>> widgets;
+};
diff --git a/src/locker/plugin/mpris.cpp b/src/locker/plugin/mpris.cpp
new file mode 100644
index 00000000..019c53e0
--- /dev/null
+++ b/src/locker/plugin/mpris.cpp
@@ -0,0 +1,398 @@
+#include <memory>
+#include <giomm/asyncresult.h>
+#include <giomm/dbusconnection.h>
+#include <giomm/dbusproxy.h>
+#include <glibmm.h>
+#include <wf-option-wrap.hpp>
+
+#include "lockergrid.hpp"
+#include "plugin.hpp"
+#include "mpris.hpp"
+
+/* Widget of controls for one player on one screen
+ * https://specifications.freedesktop.org/mpris/latest/index.html */
+WayfireLockerMPRISWidget::WayfireLockerMPRISWidget(std::string name,
+    Glib::RefPtr<Gio::DBus::Proxy> proxy) :
+    WayfireLockerTimedRevealer("locker/mpris_always"),
+    proxy(proxy),
+    name(name)
+{
+    image.add_css_class("albumart");
+    add_css_class("mpris");
+
+    kill.set_halign(Gtk::Align::END);
+    box.append(image);
+    box.append(sidebox);
+
+    sidebox.set_orientation(Gtk::Orientation::VERTICAL);
+    sidebox.append(label);
+    sidebox.append(controlbox);
+
+    label.set_halign(Gtk::Align::START);
+    label.set_valign(Gtk::Align::START);
+    label.set_wrap(true);
+
+    controlbox.set_expand(true);
+    controlbox.append(prev);
+    controlbox.append(playpause);
+    controlbox.append(next);
+    controlbox.append(kill);
+    controlbox.set_valign(Gtk::Align::END);
+    controlbox.set_halign(Gtk::Align::START);
+    kill.set_hexpand(true);
+    kill.set_halign(Gtk::Align::END);
+
+    signals.push_back(next.signal_clicked().connect(
+        [proxy] ()
+    {
+        proxy->call("Next", [proxy] (Glib::RefPtr<Gio::AsyncResult> res) {proxy->call_finish(res);}, nullptr);
+    }));
+
+    signals.push_back(prev.signal_clicked().connect(
+        [proxy] ()
+    {
+        proxy->call("Previous",
+            [proxy] (Glib::RefPtr<Gio::AsyncResult> res) {proxy->call_finish(res);}, nullptr);
+    }));
+
+    signals.push_back(playpause.signal_clicked().connect(
+        [proxy] ()
+    {
+        proxy->call("PlayPause",
+            [proxy] (Glib::RefPtr<Gio::AsyncResult> res) {proxy->call_finish(res);}, nullptr);
+    }));
+
+    signals.push_back(kill.signal_clicked().connect(
+        [proxy] ()
+    {
+        proxy->call("Stop", [proxy] (Glib::RefPtr<Gio::AsyncResult> res) {proxy->call_finish(res);}, nullptr);
+    }));
+
+    signals.push_back(proxy->signal_properties_changed().connect(
+        [this] (const Gio::DBus::Proxy::MapChangedProperties& properties,
+                const std::vector<Glib::ustring>& invalidated)
+    {
+        for (auto & it : properties)
+        {
+            auto [id, value] = it;
+            if (id == "PlaybackStatus")
+            {
+                auto value_string = Glib::VariantBase::cast_dynamic<Glib::Variant<std::string>>(value);
+                playbackstatus(value_string.get());
+            } else if (id == "Metadata")
+            {
+                auto value_array = Glib::VariantBase::cast_dynamic<Glib::Variant<std::map<std::string,
+                    Glib::VariantBase>>>(value);
+                metadata(value_array.get());
+            } else if (id == "CanGoNext")
+            {
+                auto value_bool = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(value);
+                cangonext(value_bool.get());
+            } else if (id == "CanGoPrevious")
+            {
+                auto value_bool = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(value);
+                cangoprev(value_bool.get());
+            } else if (id == "CanControl")
+            {
+                auto value_bool = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(value);
+                cancontrol(value_bool.get());
+            }
+        }
+    }));
+
+    Glib::Variant<std::string> playbackstatus_value;
+    proxy->get_cached_property(playbackstatus_value, "PlaybackStatus");
+    playbackstatus(playbackstatus_value.get());
+
+    Glib::Variant<std::map<std::string, Glib::VariantBase>> metadata_value;
+    proxy->get_cached_property(metadata_value, "Metadata");
+    metadata(metadata_value.get());
+
+    Glib::Variant<bool> cangonext_value;
+    proxy->get_cached_property(cangonext_value, "CanGoNext");
+    cangonext(cangonext_value.get());
+
+    Glib::Variant<bool> cangoprev_value;
+    proxy->get_cached_property(cangoprev_value, "CanGoPrevious");
+    cangoprev(cangoprev_value.get());
+
+    Glib::Variant<bool> cancontrol_value;
+    proxy->get_cached_property(cancontrol_value, "CanControl");
+    cancontrol(cancontrol_value.get());
+
+    kill.set_icon_name("media-playback-stop");
+    playpause.set_icon_name("media-playback-pause");
+    prev.set_icon_name("media-skip-backward");
+    next.set_icon_name("media-skip-forward");
+
+    set_child(box);
+}
+
+WayfireLockerMPRISWidget::~WayfireLockerMPRISWidget()
+{
+    for (auto signal : signals)
+    {
+        signal.disconnect();
+    }
+}
+
+void WayfireLockerMPRISWidget::playbackstatus(std::string value)
+{
+    if (value == "Stopped")
+    {
+        box.hide();
+        return;
+    }
+
+    box.show();
+    if (value == "Paused")
+    {
+        playpause.set_icon_name("media-playback-start");
+    } else
+    {
+        playpause.set_icon_name("media-playback-pause");
+    }
+
+    activity();
+}
+
+/* https://www.freedesktop.org/wiki/Specifications/mpris-spec/metadata/ */
+void WayfireLockerMPRISWidget::metadata(std::map<std::string, Glib::VariantBase> value)
+{
+    std::string title = "", album = "", artist = "", art = "";
+    for (auto & it : value)
+    {
+        std::string id = it.first;
+        if (id == "xesam:title")
+        {
+            title = Glib::VariantBase::cast_dynamic<Glib::Variant<std::string>>(it.second).get();
+        } else if (id == "xesam:album")
+        {
+            album = Glib::VariantBase::cast_dynamic<Glib::Variant<std::string>>(it.second).get();
+        } else if (id == "xesam:artist")
+        {
+            auto artists =
+                Glib::VariantBase::cast_dynamic<Glib::Variant<std::vector<std::string>>>(it.second).get();
+            if (artists.size() > 0)
+            {
+                artist = artists[0];
+            }
+        } else if (id == "mpris:artUrl")
+        {
+            art = Glib::VariantBase::cast_dynamic<Glib::Variant<std::string>>(it.second).get();
+        }
+    }
+
+    if (art.length() < 8)
+    {
+        image_path = "";
+        image.hide();
+    } else
+    {
+        art = art.substr(7);
+        if (art != image_path)
+        {
+            image.show();
+            image.set(art);
+            image_path = art;
+        }
+    }
+
+    std::vector<std::tuple<std::string, std::string>> pairs = {
+        {"%track", title},
+        {"%album", album},
+        {"%artist", artist},
+        {"%n", "\n"}
+    };
+    Glib::ustring output =
+        substitute_strings(pairs, (std::string)WfOption<std::string>{"locker/mpris_format"});
+    label.set_label(output);
+    activity();
+}
+
+void WayfireLockerMPRISWidget::cangonext(bool value)
+{
+    if (value)
+    {
+        next.show();
+    } else
+    {
+        next.hide();
+    }
+}
+
+void WayfireLockerMPRISWidget::cangoprev(bool value)
+{
+    if (value)
+    {
+        prev.show();
+    } else
+    {
+        prev.hide();
+    }
+}
+
+void WayfireLockerMPRISWidget::cancontrol(bool value)
+{
+    if (value)
+    {
+        controlbox.show();
+    } else
+    {
+        controlbox.hide();
+    }
+}
+
+void WayfireLockerMPRISCollective::add_child(std::string id, Glib::RefPtr<Gio::DBus::Proxy> proxy)
+{
+    children.emplace(id, new WayfireLockerMPRISWidget(id, proxy));
+    box.append(*children[id]);
+}
+
+void WayfireLockerMPRISCollective::rem_child(std::string id)
+{
+    box.remove(*children[id]);
+    children.erase(id);
+}
+
+WayfireLockerMPRISPlugin::WayfireLockerMPRISPlugin() :
+    WayfireLockerPlugin("locker/mpris")
+{}
+
+void WayfireLockerMPRISPlugin::init()
+{
+    Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType::SESSION,
+        "org.freedesktop.DBus",
+        "/org/freedesktop/DBus",
+        "org.freedesktop.DBus",
+        [this] (const Glib::RefPtr<Gio::AsyncResult> & result)
+    {
+        // Got a dbus proxy
+        manager_proxy = Gio::DBus::Proxy::create_finish(result);
+        auto val = manager_proxy->call_sync("ListNames");
+        Glib::Variant<std::vector<std::string>> list;
+        val.get_child(list, 0);
+        auto l2 = list.get();
+        for (auto t : l2)
+        {
+            if (t.substr(0, 23) == "org.mpris.MediaPlayer2.")
+            {
+                add_client(t);
+            }
+        }
+
+        /* https://dbus.freedesktop.org/doc/dbus-java/api/org/freedesktop/DBus.NameOwnerChanged.html */
+        signal = manager_proxy->signal_signal().connect(
+            [this] (const Glib::ustring & sender_name,
+                    const Glib::ustring & signal_name,
+                    const Glib::VariantContainerBase & params)
+        {
+            if (signal_name == "NameOwnerChanged")
+            {
+                Glib::Variant<std::string> to, from, name;
+                params.get_child(name, 0);
+                params.get_child(to, 1);
+                params.get_child(from, 2);
+                if (name.get().substr(0, 23) == "org.mpris.MediaPlayer2.")
+                {
+                    if (to.get() == "")
+                    {
+                        add_client(name.get());
+                    } else if (from.get() == "")
+                    {
+                        rem_client(name.get());
+                    }
+                }
+            }
+        });
+    });
+}
+
+void WayfireLockerMPRISPlugin::deinit()
+{
+    if (signal)
+    {
+        signal.disconnect();
+    }
+
+    manager_proxy = nullptr;
+}
+
+void WayfireLockerMPRISPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    grid->remove(*widgets[id]);
+    widgets.erase(id);
+}
+
+void WayfireLockerMPRISPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.emplace(id, new WayfireLockerMPRISCollective());
+
+    auto collective = widgets[id];
+    for (auto & it : clients)
+    {
+        collective->add_child(it.first, it.second);
+    }
+
+    grid->attach(*collective, position);
+}
+
+std::string substitute_string(const std::string from, const std::string to, const std::string in)
+{
+    std::string output = in;
+    std::string::size_type position;
+    while ((position = output.find(from)) != std::string::npos)
+    {
+        output.replace(position, from.length(), to);
+    }
+
+    return output;
+}
+
+std::string substitute_strings(const std::vector<std::tuple<std::string, std::string>> pairs,
+    const std::string in)
+{
+    std::string output = in;
+    for (auto & it : pairs)
+    {
+        const auto [from, to] = it;
+        output = substitute_string(from, to, output);
+    }
+
+    return output;
+}
+
+void WayfireLockerMPRISPlugin::add_client(std::string path)
+{
+    Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType::SESSION,
+        path,
+        "/org/mpris/MediaPlayer2",
+        "org.mpris.MediaPlayer2.Player",
+        [this, path] (const Glib::RefPtr<Gio::AsyncResult> & result)
+    {
+        auto proxy = Gio::DBus::Proxy::create_finish(result);
+        clients.emplace(path, proxy);
+        for (auto & it : widgets)
+        {
+            it.second->add_child(path, proxy);
+        }
+    });
+}
+
+void WayfireLockerMPRISPlugin::rem_client(std::string path)
+{
+    clients.erase(path);
+    for (auto & it : widgets)
+    {
+        it.second->rem_child(path);
+    }
+}
+
+void WayfireLockerMPRISCollective::activity()
+{
+    set_reveal_child(true);
+    for (auto & it : children)
+    {
+        it.second->activity();
+    }
+}
diff --git a/src/locker/plugin/mpris.hpp b/src/locker/plugin/mpris.hpp
new file mode 100644
index 00000000..fe8bad31
--- /dev/null
+++ b/src/locker/plugin/mpris.hpp
@@ -0,0 +1,88 @@
+#pragma once
+#include <gtkmm/label.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/image.h>
+#include <gtkmm/revealer.h>
+#include <giomm.h>
+#include <sigc++/connection.h>
+
+#include "glib.h"
+#include "glibmm/main.h"
+#include "plugin.hpp"
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+
+
+std::string substitute_string(const std::string from, const std::string to, const std::string in);
+std::string substitute_strings(const std::vector<std::tuple<std::string, std::string>> pairs,
+    const std::string in);
+
+class WayfireLockerMPRISWidget : public WayfireLockerTimedRevealer
+{
+  private:
+    Glib::RefPtr<Gio::DBus::Proxy> proxy;
+    std::string name;
+    void playbackstatus(std::string value);
+    void metadata(std::map<std::string, Glib::VariantBase> value);
+    void cangonext(bool value);
+    void cangoprev(bool value);
+    void cancontrol(bool value);
+    std::vector<sigc::connection> signals;
+
+  public:
+    Gtk::Label label;
+    Gtk::Button next, prev, playpause, kill;
+    Gtk::Box box, controlbox, sidebox;
+    Gtk::Image image;
+    std::string image_path = "";
+
+    WayfireLockerMPRISWidget(std::string name, Glib::RefPtr<Gio::DBus::Proxy> proxy);
+    ~WayfireLockerMPRISWidget();
+};
+
+class WayfireLockerMPRISCollective : public WayfireLockerTimedRevealer
+{
+  private:
+    std::map<std::string, Glib::RefPtr<WayfireLockerMPRISWidget>> children;
+    Gtk::Box box;
+
+  public:
+    void add_child(std::string name, Glib::RefPtr<Gio::DBus::Proxy> proxy);
+    void rem_child(std::string name);
+    WayfireLockerMPRISCollective() :
+        WayfireLockerTimedRevealer("locker/mpris_always")
+    {
+        /* At next chance, force visibility */
+        Glib::signal_idle().connect([this] ()
+        {
+            set_reveal_child(true);
+            return G_SOURCE_REMOVE;
+        });
+        set_child(box);
+        box.set_orientation(Gtk::Orientation::VERTICAL);
+    }
+
+    void activity() override;
+};
+
+class WayfireLockerMPRISPlugin : public WayfireLockerPlugin
+{
+  private:
+    Glib::RefPtr<Gio::DBus::Proxy> manager_proxy;
+    std::map<std::string, Glib::RefPtr<Gio::DBus::Proxy>> clients;
+    std::map<int, Glib::RefPtr<WayfireLockerMPRISCollective>> widgets;
+    sigc::connection signal;
+
+  public:
+    WayfireLockerMPRISPlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+
+    void add_client(std::string client);
+    void rem_client(std::string client);
+
+    gulong hook_play, hook_pause, hook_stop, hook_metadata;
+};
diff --git a/src/locker/plugin/network.cpp b/src/locker/plugin/network.cpp
new file mode 100644
index 00000000..5d396fdc
--- /dev/null
+++ b/src/locker/plugin/network.cpp
@@ -0,0 +1,394 @@
+#include "network.hpp"
+#include "giomm/dbusconnection.h"
+#include "giomm/dbusproxy.h"
+#include "gtkmm/enums.h"
+#include "lockergrid.hpp"
+#include "plugin.hpp"
+#include "timedrevealer.hpp"
+#include <memory>
+#include <iostream>
+
+#define NM_DBUS_NAME "org.freedesktop.NetworkManager"
+#define ACTIVE_CONNECTION "PrimaryConnection"
+#define STRENGTH "Strength"
+
+/* Connection types */
+struct NoConnectionInfo : public WfPluginNetworkConnectionInfo
+{
+    std::string get_icon_name(WfPluginConnectionState state)
+    {
+        return "network-offline-symbolic";
+    }
+
+    int get_connection_strength()
+    {
+        return 0;
+    }
+
+    std::string get_strength_str()
+    {
+        return "none";
+    }
+
+    std::string get_ip()
+    {
+        return "127.0.0.1";
+    }
+
+    virtual ~NoConnectionInfo()
+    {}
+};
+
+struct VPNPluginConnectionInfo : public WfPluginNetworkConnectionInfo
+{
+    VPNPluginConnectionInfo(const std::shared_ptr<Gio::DBus::Connection>& connection, std::string path)
+    {}
+    virtual std::string get_icon_name(WfPluginConnectionState state) override
+    {
+        return "network-vpn-symbolic";
+    }
+
+    int get_connection_strength() override
+    {
+        return 0;
+    }
+
+    std::string get_strength_str() override
+    {
+        return "excellent";
+    }
+
+    std::string get_ip() override
+    {
+        return "0.0.0.0";
+    }
+
+    virtual ~VPNPluginConnectionInfo()
+    {}
+};
+
+
+struct WifiPluginConnectionInfo : public WfPluginNetworkConnectionInfo
+{
+    WayfireLockerNetworkPlugin *plugin;
+    std::shared_ptr<Gio::DBus::Proxy> ap;
+    sigc::connection ap_sig;
+
+    WifiPluginConnectionInfo(const std::shared_ptr<Gio::DBus::Connection>& connection, std::string path,
+        WayfireLockerNetworkPlugin *plugin)
+    {
+        this->plugin = plugin;
+
+        ap = Gio::DBus::Proxy::create_sync(connection, NM_DBUS_NAME, path,
+            "org.freedesktop.NetworkManager.AccessPoint");
+
+        if (ap)
+        {
+            ap_sig = ap->signal_properties_changed().connect(
+                sigc::mem_fun(*this, &WifiPluginConnectionInfo::on_properties_changed));
+        }
+    }
+
+    void on_properties_changed(const Gio::DBus::Proxy::MapChangedProperties& changed,
+        const std::vector<Glib::ustring>& invalid)
+    {
+        bool needs_refresh = false;
+        for (auto& prop : changed)
+        {
+            if (prop.first == STRENGTH)
+            {
+                needs_refresh = true;
+            }
+        }
+
+        if (needs_refresh)
+        {
+            plugin->set_state();
+        }
+    }
+
+    int get_strength()
+    {
+        assert(ap);
+
+        Glib::Variant<guchar> vstr;
+        ap->get_cached_property(vstr, STRENGTH);
+
+        return vstr.get();
+    }
+
+    std::string get_strength_str()
+    {
+        int value = get_strength();
+
+        if (value > 80)
+        {
+            return "excellent";
+        }
+
+        if (value > 55)
+        {
+            return "good";
+        }
+
+        if (value > 30)
+        {
+            return "ok";
+        }
+
+        if (value > 5)
+        {
+            return "weak";
+        }
+
+        return "none";
+    }
+
+    virtual std::string get_icon_name(WfPluginConnectionState state)
+    {
+        if ((state <= CSTATE_ACTIVATING) || (state == CSTATE_DEACTIVATING))
+        {
+            return "network-wireless-acquiring-symbolic";
+        }
+
+        if (state == CSTATE_DEACTIVATED)
+        {
+            return "network-wireless-disconnected-symbolic";
+        }
+
+        if (ap)
+        {
+            return "network-wireless-signal-" + get_strength_str() + "-symbolic";
+        } else
+        {
+            return "network-wireless-no-route-symbolic";
+        }
+    }
+
+    virtual int get_connection_strength()
+    {
+        if (ap)
+        {
+            return get_strength();
+        } else
+        {
+            return 100;
+        }
+    }
+
+    virtual std::string get_ip()
+    {
+        return "0.0.0.0";
+    }
+
+    virtual ~WifiPluginConnectionInfo()
+    {}
+};
+
+struct EthernetPluginConnectionInfo : public WfPluginNetworkConnectionInfo
+{
+    std::shared_ptr<Gio::DBus::Proxy> ap;
+    EthernetPluginConnectionInfo(const std::shared_ptr<Gio::DBus::Connection>& connection, std::string path)
+    {}
+
+    virtual std::string get_icon_name(WfPluginConnectionState state)
+    {
+        if ((state <= CSTATE_ACTIVATING) || (state == CSTATE_DEACTIVATING))
+        {
+            return "network-wired-acquiring-symbolic";
+        }
+
+        if (state == CSTATE_DEACTIVATED)
+        {
+            return "network-wired-disconnected-symbolic";
+        }
+
+        return "network-wired-symbolic";
+    }
+
+    std::string get_connection_name()
+    {
+        return "Ethernet - " + connection_name;
+    }
+
+    std::string get_strength_str()
+    {
+        return "excellent";
+    }
+
+    virtual int get_connection_strength()
+    {
+        return 100;
+    }
+
+    virtual std::string get_ip()
+    {
+        return "0.0.0.0";
+    }
+
+    virtual ~EthernetPluginConnectionInfo()
+    {}
+};
+
+/* Main plugin */
+
+WayfireLockerNetworkPluginWidget::WayfireLockerNetworkPluginWidget(std::string image_contents,
+    std::string label_contents,
+    std::string css_contents) :
+    WayfireLockerTimedRevealer("locker/network_always")
+{
+    box.add_css_class("network");
+    box.append(image);
+    box.append(label);
+    image.set_from_icon_name(image_contents);
+    label.set_label(label_contents);
+    label.add_css_class(css_contents);
+    box.set_orientation(Gtk::Orientation::HORIZONTAL);
+    set_child(box);
+}
+
+WayfireLockerNetworkPlugin::WayfireLockerNetworkPlugin() :
+    WayfireLockerPlugin("locker/network")
+{}
+
+void WayfireLockerNetworkPlugin::init()
+{
+    setup_dbus();
+}
+
+void WayfireLockerNetworkPlugin::deinit()
+{}
+
+void WayfireLockerNetworkPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.emplace(id, new WayfireLockerNetworkPluginWidget(image_contents, label_contents, css_contents));
+    auto widget = widgets[id];
+    /* Add to window */
+    grid->attach(*widget, position);
+    update_active_connection();
+}
+
+void WayfireLockerNetworkPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.erase(id);
+}
+
+bool WayfireLockerNetworkPlugin::setup_dbus()
+{
+    auto cancellable = Gio::Cancellable::create();
+    connection = Gio::DBus::Connection::get_sync(Gio::DBus::BusType::SYSTEM, cancellable);
+    if (!connection)
+    {
+        std::cerr << "Failed to connect to dbus" << std::endl;
+        return false;
+    }
+
+    nm_proxy = Gio::DBus::Proxy::create_sync(connection, NM_DBUS_NAME,
+        "/org/freedesktop/NetworkManager",
+        "org.freedesktop.NetworkManager");
+    if (!nm_proxy)
+    {
+        std::cerr << "Failed to connect to network manager, " <<
+            "are you sure it is running?" << std::endl;
+        return false;
+    }
+
+    signals.push_back(nm_proxy->signal_properties_changed().connect(
+        sigc::mem_fun(*this, &WayfireLockerNetworkPlugin::on_nm_properties_changed)));
+
+    return true;
+}
+
+void WayfireLockerNetworkPlugin::on_nm_properties_changed(
+    const Gio::DBus::Proxy::MapChangedProperties& properties,
+    const std::vector<Glib::ustring>& invalidated)
+{
+    for (auto & prop : properties)
+    {
+        if (prop.first == ACTIVE_CONNECTION)
+        {
+            update_active_connection();
+        }
+    }
+}
+
+void WayfireLockerNetworkPlugin::update_active_connection()
+{
+    std::cout << "Updating connection " << std::endl;
+    Glib::Variant<Glib::ustring> active_conn_path;
+    nm_proxy->get_cached_property(active_conn_path, ACTIVE_CONNECTION);
+
+    if (active_conn_path && (active_conn_path.get() != "/"))
+    {
+        active_connection_proxy = Gio::DBus::Proxy::create_sync(
+            connection, NM_DBUS_NAME, active_conn_path.get(),
+            "org.freedesktop.NetworkManager.Connection.Active");
+    } else
+    {
+        active_connection_proxy = nullptr;
+    }
+
+    if (!active_connection_proxy)
+    {
+        info = std::make_unique<NoConnectionInfo>();
+        set_state();
+        return;
+    }
+
+    Glib::Variant<Glib::ustring> vtype, vobject;
+    active_connection_proxy->get_cached_property(vtype, "Type");
+    active_connection_proxy->get_cached_property(vobject, "SpecificObject");
+    auto type   = vtype.get();
+    auto object = vobject.get();
+
+    if (type.find("wireless") != type.npos)
+    {
+        info = std::make_unique<WifiPluginConnectionInfo>(
+            connection, object, this);
+    } else if (type.find("ethernet") != type.npos)
+    {
+        info = std::make_unique<EthernetPluginConnectionInfo>(connection, object);
+    } else if (type == "vpn")
+    {
+        info = std::make_unique<VPNPluginConnectionInfo>(connection, object);
+    } else
+    {
+        info = std::make_unique<NoConnectionInfo>();
+    }
+
+    Glib::Variant<Glib::ustring> vname;
+    active_connection_proxy->get_cached_property(vname, "Id");
+    info->connection_name = vname.get();
+    set_state();
+}
+
+static WfPluginConnectionState get_connection_state(std::shared_ptr<Gio::DBus::Proxy> connection)
+{
+    if (!connection)
+    {
+        return CSTATE_DEACTIVATED;
+    }
+
+    Glib::Variant<guint32> state;
+    connection->get_cached_property(state, "State");
+    return (WfPluginConnectionState)state.get();
+}
+
+void WayfireLockerNetworkPlugin::set_state()
+{
+    label_contents = info->get_connection_name();
+    image_contents = info->get_icon_name(get_connection_state(active_connection_proxy));
+    css_contents   = info->get_strength_str();
+    std::cout << label_contents << " " << image_contents << std::endl;
+
+    for (auto & it : widgets)
+    {
+        it.second->label.remove_css_class("excellent");
+        it.second->label.remove_css_class("good");
+        it.second->label.remove_css_class("weak");
+        it.second->label.remove_css_class("none");
+        it.second->label.set_label(label_contents);
+        it.second->image.set_from_icon_name(image_contents);
+        it.second->label.add_css_class(css_contents);
+    }
+}
diff --git a/src/locker/plugin/network.hpp b/src/locker/plugin/network.hpp
new file mode 100644
index 00000000..747953e4
--- /dev/null
+++ b/src/locker/plugin/network.hpp
@@ -0,0 +1,73 @@
+#pragma once
+#include <gtkmm/label.h>
+#include <gtkmm/image.h>
+#include <gtkmm/box.h>
+#include <memory>
+#include "giomm/dbusconnection.h"
+#include "giomm/dbusproxy.h"
+#include "lockergrid.hpp"
+#include "plugin.hpp"
+
+
+enum WfPluginConnectionState // NmActiveConnectionState
+{
+    CSTATE_UNKNOWN      = 0,
+    CSTATE_ACTIVATING   = 1,
+    CSTATE_ACTIVATED    = 2,
+    CSTATE_DEACTIVATING = 3,
+    CSTATE_DEACTIVATED  = 4,
+};
+
+struct WfPluginNetworkConnectionInfo
+{
+    std::string connection_name;
+
+    virtual std::string get_connection_name()
+    {
+        return connection_name;
+    }
+
+    virtual std::string get_icon_name(WfPluginConnectionState state) = 0;
+    virtual int get_connection_strength() = 0;
+    virtual std::string get_ip() = 0;
+    virtual std::string get_strength_str() = 0;
+
+    virtual ~WfPluginNetworkConnectionInfo()
+    {}
+};
+
+class WayfireLockerNetworkPluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    WayfireLockerNetworkPluginWidget(std::string image_contents, std::string label_contents,
+        std::string css_contents);
+    Gtk::Label label;
+    Gtk::Image image;
+    Gtk::Box box;
+};
+
+class WayfireLockerNetworkPlugin : public WayfireLockerPlugin
+{
+  private:
+    std::shared_ptr<Gio::DBus::Connection> connection;
+    std::shared_ptr<Gio::DBus::Proxy> nm_proxy, active_connection_proxy;
+    std::vector<sigc::connection> signals;
+    std::unique_ptr<WfPluginNetworkConnectionInfo> info;
+
+  public:
+    WayfireLockerNetworkPlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+
+    bool setup_dbus();
+    void on_nm_properties_changed(const Gio::DBus::Proxy::MapChangedProperties& properties,
+        const std::vector<Glib::ustring>& invalidated);
+    void update_active_connection();
+    void set_state();
+    std::unordered_map<int, std::shared_ptr<WayfireLockerNetworkPluginWidget>> widgets;
+
+    std::string image_contents = "network-error-symbolic", label_contents = "Unknown state",
+        css_contents = "";
+};
diff --git a/src/locker/plugin/password.cpp b/src/locker/plugin/password.cpp
new file mode 100644
index 00000000..c7af4d34
--- /dev/null
+++ b/src/locker/plugin/password.cpp
@@ -0,0 +1,198 @@
+#include <iostream>
+#include <memory>
+#include <glibmm.h>
+#include "gtkmm/entry.h"
+#include "gtkmm/enums.h"
+#include "gtkmm/label.h"
+#include <unistd.h>
+#include <security/_pam_types.h>
+#include <security/pam_appl.h>
+
+#include "locker.hpp"
+#include "lockergrid.hpp"
+#include "plugin.hpp"
+#include "timedrevealer.hpp"
+#include "password.hpp"
+
+WayfireLockerPasswordPluginWidget::~WayfireLockerPasswordPluginWidget()
+{
+    if (entry_updated)
+    {
+        entry_updated.disconnect();
+    }
+
+    if (entry_submitted)
+    {
+        entry_submitted.disconnect();
+    }
+}
+
+void WayfireLockerPasswordPlugin::update_labels(std::string text)
+{
+    for (auto& it : widgets)
+    {
+        it.second->label.set_label(text);
+    }
+
+    label_contents = text;
+}
+
+void WayfireLockerPasswordPlugin::blank_passwords()
+{
+    for (auto& it : widgets)
+    {
+        it.second->entry.set_text("");
+    }
+}
+
+void WayfireLockerPasswordPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.emplace(id, new WayfireLockerPasswordPluginWidget(label_contents));
+
+    /* Share string to every other entry */
+    auto widget = widgets[id];
+    widget->entry_updated = widget->entry.signal_changed().connect(
+        [this, widget] ()
+    {
+        int start, end;
+        widget->entry.get_selection_bounds(start, end);
+        auto password = widget->entry.get_text();
+        for (auto & pair : widgets)
+        {
+            pair.second->entry_updated.block(true);
+            pair.second->entry.set_text(password);
+            pair.second->entry.set_position(start);
+            pair.second->entry_updated.unblock();
+        }
+    }, true);
+
+    /* Set entry callback for return */
+    widget->entry_submitted = widget->entry.signal_activate().connect([this, widget] ()
+    {
+        auto password = widget->entry.get_text();
+        if (password.length() > 0)
+        {
+            submit_user_password(password);
+        }
+    }, true);
+    /* Add to window */
+    grid->attach(*widget, position);
+
+    widget->signal_realize().connect([=] ()
+    {
+        widget->entry.grab_focus();
+    });
+}
+
+WayfireLockerPasswordPluginWidget::WayfireLockerPasswordPluginWidget(std::string label_contents) :
+    WayfireLockerTimedRevealer("locker/password_always")
+{
+    set_child(box);
+    box.add_css_class("password");
+    box.append(entry);
+    box.append(label);
+    box.set_orientation(Gtk::Orientation::VERTICAL);
+    label.add_css_class("password-reply");
+    entry.add_css_class("password-entry");
+    entry.set_placeholder_text("Password");
+    label.set_label(label_contents);
+    entry.set_visibility(false);
+}
+
+void WayfireLockerPasswordPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    grid->remove(*widgets[id]);
+    widgets.erase(id);
+}
+
+WayfireLockerPasswordPlugin::WayfireLockerPasswordPlugin() :
+    WayfireLockerPlugin("locker/password")
+{}
+
+/* PAM password C code... */
+int pam_conversation(int num_mesg, const struct pam_message **mesg, struct pam_response **resp,
+    void *appdata_ptr)
+{
+    std::cout << "PAM convo step ... " << std::endl;
+
+    WayfireLockerPasswordPlugin *pass_plugin = (WayfireLockerPasswordPlugin*)appdata_ptr;
+    *resp = (struct pam_response*)calloc(num_mesg, sizeof(struct pam_response));
+    if (*resp == NULL)
+    {
+        std::cerr << "PAM reply allocation failed" << std::endl;
+        return PAM_ABORT;
+    }
+
+    for (int count = 0; count < num_mesg; count++)
+    {
+        std::cout << "PAM msg : " << mesg[count]->msg << std::endl;
+        resp[count]->resp_retcode = 0;
+        /* Echo OFF prompt should be user password. */
+        if (mesg[count]->msg_style == PAM_PROMPT_ECHO_OFF)
+        {
+            resp[count]->resp = strdup(pass_plugin->submitted_password.c_str());
+        } else if (mesg[count]->msg_style == PAM_ERROR_MSG)
+        {
+            pass_plugin->update_labels(mesg[count]->msg);
+        } else if (mesg[count]->msg_style == PAM_TEXT_INFO)
+        {
+            pass_plugin->update_labels(mesg[count]->msg);
+        }
+    }
+
+    return PAM_SUCCESS;
+}
+
+void WayfireLockerPasswordPlugin::submit_user_password(std::string password)
+{
+    submitted_password = password;
+    blank_passwords();
+    std::cout << "Unlocking ... " << std::endl;
+    /* Get username*/
+    char *username = getlogin();
+    /* Init PAM conversation */
+    const struct pam_conv local_conversation = {
+        pam_conversation, this
+    };
+    pam_handle_t *local_auth_handle = NULL; // this gets set by pam_start
+    int retval;
+    /* Start the password-based conversation */
+    std::cout << "PAM start ... " << std::endl;
+    retval = pam_start("wf-locker-password", username, &local_conversation, &local_auth_handle);
+    if (retval != PAM_SUCCESS)
+    {
+        /* We don't expect to be here. No graceful way out of this. */
+        std::cout << "PAM start returned " << retval << std::endl;
+        update_labels("pam_start failure");
+        exit(retval);
+    }
+
+    std::cout << "PAM auth ... " << std::endl;
+    /* Request authenticate */
+    retval = pam_authenticate(local_auth_handle, 0);
+    bool unlock = false;
+    if (retval != PAM_SUCCESS)
+    {
+        if (retval == PAM_AUTH_ERR)
+        {
+            std::cout << "Authentication failure." << std::endl;
+            update_labels("Authentication failure.");
+        }
+    } else
+    {
+        std::cout << "Authenticate success." << std::endl;
+        unlock = true;
+    }
+
+    retval = pam_end(local_auth_handle, retval);
+    if (unlock)
+    {
+        WayfireLockerApp::get().perform_unlock("PAM Password authenticated");
+    }
+}
+
+void WayfireLockerPasswordPlugin::init()
+{}
+
+void WayfireLockerPasswordPlugin::deinit()
+{}
diff --git a/src/locker/plugin/password.hpp b/src/locker/plugin/password.hpp
new file mode 100644
index 00000000..54b6a698
--- /dev/null
+++ b/src/locker/plugin/password.hpp
@@ -0,0 +1,45 @@
+#pragma once
+#include <sigc++/connection.h>
+#include <gtkmm/label.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/box.h>
+#include <unordered_map>
+
+#include "plugin.hpp"
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+
+int pam_conversation(int num_msg, const struct pam_message **msg, struct pam_response **resp,
+    void *appdata_ptr);
+
+class WayfireLockerPasswordPluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    ~WayfireLockerPasswordPluginWidget();
+    Gtk::Box box;
+    Gtk::Entry entry;
+    Gtk::Label label;
+    WayfireLockerPasswordPluginWidget(std::string label_contents);
+
+    sigc::connection entry_updated, entry_submitted;
+};
+
+class WayfireLockerPasswordPlugin : public WayfireLockerPlugin
+{
+  public:
+    WayfireLockerPasswordPlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+    void submit_user_password(std::string password);
+    void blank_passwords();
+    void update_passwords(std::string password);
+
+    sigc::connection timeout;
+    void update_labels(std::string text);
+
+    std::unordered_map<int, std::shared_ptr<WayfireLockerPasswordPluginWidget>> widgets;
+    std::string label_contents     = "";
+    std::string submitted_password = "";
+};
diff --git a/src/locker/plugin/pin.cpp b/src/locker/plugin/pin.cpp
new file mode 100644
index 00000000..1b6e0d97
--- /dev/null
+++ b/src/locker/plugin/pin.cpp
@@ -0,0 +1,242 @@
+#include <iomanip>
+#include <sstream>
+#include <fstream>
+#include <string>
+#include <iostream>
+#include <memory>
+#include <gtkmm/grid.h>
+#include <gtkmm/box.h>
+#include <openssl/crypto.h>
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+
+
+#include "plugin.hpp"
+#include "locker.hpp"
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+#include "pin.hpp"
+
+
+/*
+ *  To set the PIN Hash required to enable this plugin, try running
+ *  `echo -n "1234" | sha512sum | head -c 128 > ~/.config/wf-locker.hash`
+ *
+ *  Replace the numbers inside the echo quote. There must be one or more digits,
+ *  and any non-digit will render it impossible to unlock.
+ */
+
+WayfireLockerPinPluginWidget::WayfireLockerPinPluginWidget() :
+    WayfireLockerTimedRevealer("locker/pin_always")
+{
+    for (int count = 0; count < 10; count++)
+    {
+        std::string number = std::to_string(count);
+        numbers[count].add_css_class("pinpad-number");
+        numbers[count].add_css_class("pinpad-button");
+        numbers[count].set_label(number);
+        numbers[count].signal_clicked().connect(
+            [number] ()
+        {
+            auto plugin = WayfireLockerApp::get().get_plugin("pin");
+            auto plugin_cast = std::dynamic_pointer_cast<WayfireLockerPinPlugin>(plugin);
+            plugin_cast->add_digit(number);
+        });
+    }
+
+    bcan.set_label("❌");
+    bcan.add_css_class("pinpad-cancel");
+    bcan.add_css_class("pinpad-button");
+    bcan.signal_clicked().connect(
+        [] ()
+    {
+        auto plugin = WayfireLockerApp::get().get_plugin("pin");
+        auto plugin_cast = std::dynamic_pointer_cast<WayfireLockerPinPlugin>(plugin);
+        plugin_cast->reset_pin();
+    });
+    label.add_css_class("pinpad-current");
+}
+
+WayfireLockerPinPluginWidget::~WayfireLockerPinPluginWidget()
+{}
+
+void WayfireLockerPinPluginWidget::init(std::string label_text)
+{
+    set_child(grid);
+    grid.add_css_class("pinpad");
+    grid.attach(label, 0, 0, 3);
+    grid.attach(numbers[1], 0, 1);
+    grid.attach(numbers[2], 1, 1);
+    grid.attach(numbers[3], 2, 1);
+    grid.attach(numbers[4], 0, 2);
+    grid.attach(numbers[5], 1, 2);
+    grid.attach(numbers[6], 2, 2);
+    grid.attach(numbers[7], 0, 3);
+    grid.attach(numbers[8], 1, 3);
+    grid.attach(numbers[9], 2, 3);
+    grid.attach(numbers[0], 1, 4);
+    grid.attach(bcan, 0, 4);
+    grid.set_vexpand(true);
+    grid.set_column_homogeneous(true);
+    grid.set_row_homogeneous(true);
+    label.set_text(label_text);
+}
+
+WayfireLockerPinPlugin::WayfireLockerPinPlugin() :
+    WayfireLockerPlugin("locker/pin")
+{
+    /* TODO Watch for file changes and update in-memory hash */
+    if (!enable)
+    {
+        return;
+    }
+
+    std::string config_dir;
+
+    char *config_home = getenv("XDG_CONFIG_HOME");
+    if (config_home == NULL)
+    {
+        config_dir = std::string(getenv("HOME")) + "/.config";
+    } else
+    {
+        config_dir = std::string(config_home);
+    }
+
+    std::ifstream f(config_dir + "/wf-locker.hash");
+    if (!f.is_open())
+    {
+        std::cerr << "No PIN hash set" << std::endl;
+        disabled = true;
+        return;
+    }
+
+    std::string s;
+    if (!getline(f, s))
+    {
+        std::cerr << "No PIN hash set" << std::endl;
+        disabled = true;
+        return;
+    }
+
+    if (s.length() != 128)
+    {
+        std::cerr << "Invalid PIN hash" << std::endl;
+        disabled = true;
+        return;
+    }
+
+    pinhash = s;
+}
+
+void WayfireLockerPinPlugin::init()
+{}
+
+void WayfireLockerPinPlugin::deinit()
+{}
+
+void WayfireLockerPinPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    if (disabled)
+    {
+        return;
+    }
+
+    pinpads.emplace(id, new WayfireLockerPinPluginWidget());
+    auto pinpad = pinpads[id];
+    std::string asterisks(pin.length(), '*');
+    pinpad->init(asterisks);
+    grid->attach(*pinpad, position);
+}
+
+void WayfireLockerPinPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    if (disabled)
+    {
+        return;
+    }
+
+    grid->remove(*pinpads[id]);
+    pinpads.erase(id);
+}
+
+void WayfireLockerPinPlugin::add_digit(std::string digit)
+{
+    if (pin.length() >= 20)
+    {
+        return;
+    }
+
+    pin = pin + digit;
+    update_labels();
+
+    submit_pin();
+}
+
+void WayfireLockerPinPlugin::reset_pin()
+{
+    if (pin.length() > 0)
+    {
+        WayfireLockerApp::get().recieved_bad_auth();
+    }
+
+    pin = "";
+    update_labels();
+}
+
+void WayfireLockerPinPlugin::update_labels()
+{
+    std::string asterisks(pin.length(), '*');
+    for (auto& it : pinpads)
+    {
+        it.second->label.set_label(asterisks);
+    }
+}
+
+void WayfireLockerPinPlugin::submit_pin()
+{
+    auto hash = sha512(pin);
+    if (hash == pinhash)
+    {
+        WayfireLockerApp::get().perform_unlock("PIN Authenticated");
+    }
+
+    update_labels();
+}
+
+std::string WayfireLockerPinPlugin::sha512(const std::string input)
+{
+    unsigned char hash[EVP_MAX_MD_SIZE];
+    unsigned int hash_length = 0;
+    EVP_MD_CTX *mdctx = EVP_MD_CTX_create();
+    EVP_DigestInit(mdctx, EVP_sha512());
+    EVP_DigestUpdate(mdctx, input.c_str(), input.size());
+    EVP_DigestFinal(mdctx, hash, &hash_length);
+    EVP_MD_CTX_free(mdctx);
+
+    std::stringstream ss;
+
+    for (int i = 0; i < SHA512_DIGEST_LENGTH; i++)
+    {
+        ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(hash[i]);
+    }
+
+    return ss.str();
+}
+
+void WayfireLockerPinPluginWidget::lockout_changed(bool lockout)
+{
+    for (int i = 0; i < 10; i++)
+    {
+        numbers[i].set_sensitive(!lockout);
+    }
+
+    bcan.set_sensitive(!lockout);
+}
+
+void WayfireLockerPinPlugin::lockout_changed(bool lockout)
+{
+    for (auto & it : pinpads)
+    {
+        it.second->lockout_changed(lockout);
+    }
+}
diff --git a/src/locker/plugin/pin.hpp b/src/locker/plugin/pin.hpp
new file mode 100644
index 00000000..5b2bb4c8
--- /dev/null
+++ b/src/locker/plugin/pin.hpp
@@ -0,0 +1,47 @@
+#pragma once
+#include <unordered_map>
+#include <gtkmm/label.h>
+#include <gtkmm/button.h>
+#include <gtkmm/grid.h>
+#include <glibmm/refptr.h>
+
+#include "../plugin.hpp"
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+
+class WayfireLockerPinPluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    WayfireLockerPinPluginWidget();
+    ~WayfireLockerPinPluginWidget();
+    void lockout_changed(bool lockout);
+    Gtk::Grid grid;
+    Gtk::Button bcan;
+    Gtk::Label label;
+    void init(std::string label);
+    void check();
+    Gtk::Button numbers[10];
+};
+
+class WayfireLockerPinPlugin : public WayfireLockerPlugin
+{
+  public:
+    WayfireLockerPinPlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+    void lockout_changed(bool lockout) override;
+    bool disabled = false;
+
+    void update_labels();
+    void submit_pin();
+    void reset_pin();
+    void add_digit(std::string digit);
+    std::string sha512(const std::string input);
+
+    std::unordered_map<int, Glib::RefPtr<WayfireLockerPinPluginWidget>> pinpads;
+
+    std::string pin     = "";
+    std::string pinhash = "nope";
+};
diff --git a/src/locker/plugin/user.cpp b/src/locker/plugin/user.cpp
new file mode 100644
index 00000000..12e859a0
--- /dev/null
+++ b/src/locker/plugin/user.cpp
@@ -0,0 +1,88 @@
+#include <iostream>
+
+#include "lockergrid.hpp"
+#include "plugin.hpp"
+#include "timedrevealer.hpp"
+#include "user.hpp"
+
+WayfireLockerUserPlugin::WayfireLockerUserPlugin() :
+    WayfireLockerPlugin("locker/user")
+{}
+
+void WayfireLockerUserPlugin::init()
+{
+    char *home = getenv("HOME");
+    if (home == NULL)
+    {
+        std::cout << "No user home, skipping finding image" << std::endl;
+        return;
+    }
+
+    std::string home_path = home;
+
+    std::vector<std::string> paths = {
+        ".face",
+        ".face.png",
+        ".face.jpg",
+        ".face.jpeg",
+        ".face.svg",
+        ".face.icon",
+    };
+
+    for (auto path : paths)
+    {
+        auto home_path_file = home_path + "/" + path;
+        struct stat sb;
+        if ((stat(home_path_file.c_str(), &sb) == 0) && !(sb.st_mode & S_IFDIR))
+        {
+            std::cout << "Chosen image " << home_path_file << std::endl;
+            image_path = home_path_file;
+            return;
+        }
+    }
+
+    std::cout << "No user image .face... no image in lockscreen" << std::endl;
+}
+
+void WayfireLockerUserPlugin::deinit()
+{
+    image_path = "";
+}
+
+WayfireLockerUserPluginWidget::WayfireLockerUserPluginWidget(std::string image_path) :
+    WayfireLockerTimedRevealer("locker/user_always")
+{
+    set_child(box);
+    box.add_css_class("user");
+    box.set_orientation(Gtk::Orientation::VERTICAL);
+    image.set_halign(Gtk::Align::CENTER);
+    image.set_valign(Gtk::Align::END);
+    label.set_halign(Gtk::Align::CENTER);
+    label.set_valign(Gtk::Align::START);
+    label.set_justify(Gtk::Justification::CENTER);
+    std::string username = getlogin();
+    label.set_label(username);
+    if (image_path == "")
+    {
+        image.hide();
+    } else
+    {
+        image.set(image_path);
+    }
+
+    box.append(image);
+    box.append(label);
+}
+
+void WayfireLockerUserPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.emplace(id, new WayfireLockerUserPluginWidget(image_path));
+    auto widget = widgets[id];
+    grid->attach(*widget, position);
+}
+
+void WayfireLockerUserPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    grid->remove(*widgets[id]);
+    widgets.erase(id);
+}
diff --git a/src/locker/plugin/user.hpp b/src/locker/plugin/user.hpp
new file mode 100644
index 00000000..dead236a
--- /dev/null
+++ b/src/locker/plugin/user.hpp
@@ -0,0 +1,30 @@
+#pragma once
+#include <gtkmm/label.h>
+#include <gtkmm/image.h>
+
+#include "plugin.hpp"
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+
+class WayfireLockerUserPluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    Gtk::Box box;
+    Gtk::Image image;
+    Gtk::Label label;
+    WayfireLockerUserPluginWidget(std::string image_path);
+};
+
+class WayfireLockerUserPlugin : public WayfireLockerPlugin
+{
+  public:
+    WayfireLockerUserPlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+
+    std::map<int, Glib::RefPtr<WayfireLockerUserPluginWidget>> widgets;
+
+    std::string image_path = "";
+};
diff --git a/src/locker/plugin/volume.cpp b/src/locker/plugin/volume.cpp
new file mode 100644
index 00000000..783e971c
--- /dev/null
+++ b/src/locker/plugin/volume.cpp
@@ -0,0 +1,189 @@
+#include <memory>
+#include <glibmm.h>
+#include <gtkmm/box.h>
+
+#include "lockergrid.hpp"
+#include "volume.hpp"
+#include "plugin.hpp"
+#include "timedrevealer.hpp"
+
+static void default_sink_changed(GvcMixerControl *gvc_control,
+    guint id, gpointer user_data)
+{
+    WayfireLockerVolumePlugin *plugin = (WayfireLockerVolumePlugin*)user_data;
+    plugin->on_default_sink_changed();
+}
+
+static void default_source_changed(GvcMixerControl *gvc_control,
+    guint id, gpointer user_data)
+{
+    WayfireLockerVolumePlugin *plugin = (WayfireLockerVolumePlugin*)user_data;
+    plugin->on_default_source_changed();
+}
+
+static void notify_sink_muted(GvcMixerControl *gvc_control,
+    guint id, gpointer user_data)
+{
+    WayfireLockerVolumePlugin *plugin = (WayfireLockerVolumePlugin*)user_data;
+    plugin->update_button_images();
+}
+
+static void notify_source_muted(GvcMixerControl *gvc_control,
+    guint id, gpointer user_data)
+{
+    WayfireLockerVolumePlugin *plugin = (WayfireLockerVolumePlugin*)user_data;
+    plugin->update_button_images();
+}
+
+void WayfireLockerVolumePlugin::update_button_images()
+{
+    for (auto & it : widgets)
+    {
+        if (gvc_sink_stream)
+        {
+            it.second->sink_button.set_icon_name(gvc_mixer_stream_get_is_muted(
+                gvc_sink_stream) ? "audio-volume-muted-symbolic" : "audio-volume-high-symbolic");
+        }
+
+        if (gvc_source_stream)
+        {
+            it.second->source_button.set_icon_name(gvc_mixer_stream_get_is_muted(
+                gvc_source_stream) ? "microphone-sensitivity-muted-symbolic" : "microphone-sensitivity-high-symbolic");
+        }
+    }
+}
+
+WayfireLockerVolumePlugin::WayfireLockerVolumePlugin() :
+    WayfireLockerPlugin("locker/volume")
+{}
+
+WayfireLockerVolumePluginWidget::WayfireLockerVolumePluginWidget() :
+    WayfireLockerTimedRevealer("locker/volume_always")
+{
+    set_child(box);
+    sink_button.add_css_class("volume-button");
+    source_button.add_css_class("mic-button");
+
+    box.append(source_button);
+    box.append(sink_button);
+}
+
+void WayfireLockerVolumePlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    widgets.emplace(id, new WayfireLockerVolumePluginWidget());
+    auto widget = widgets[id];
+    grid->attach(*widget, position);
+
+    widget->sink_button.signal_clicked().connect(
+        [=] ()
+    {
+        if (!gvc_sink_stream)
+        {
+            return;
+        }
+
+        bool muted = gvc_mixer_stream_get_is_muted(gvc_sink_stream);
+        gvc_mixer_stream_change_is_muted(gvc_sink_stream, !muted);
+        gvc_mixer_stream_push_volume(gvc_sink_stream);
+    });
+    widget->source_button.signal_clicked().connect(
+        [=] ()
+    {
+        if (!gvc_source_stream)
+        {
+            return;
+        }
+
+        bool muted = gvc_mixer_stream_get_is_muted(gvc_source_stream);
+        gvc_mixer_stream_change_is_muted(gvc_source_stream, !muted);
+        gvc_mixer_stream_push_volume(gvc_source_stream);
+    });
+    update_button_images();
+}
+
+void WayfireLockerVolumePlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    grid->remove(*widgets[id]);
+    widgets.erase(id);
+}
+
+void WayfireLockerVolumePlugin::init()
+{
+    /* Setup gvc control */
+    gvc_control = gvc_mixer_control_new("Wayfire Volume Control");
+    notify_sink_changed = g_signal_connect(gvc_control,
+        "default-sink-changed", G_CALLBACK(default_sink_changed), this);
+    notify_source_changed = g_signal_connect(gvc_control,
+        "default-source-changed", G_CALLBACK(default_source_changed), this);
+    gvc_mixer_control_open(gvc_control);
+}
+
+void WayfireLockerVolumePlugin::deinit()
+{
+    disconnect_gvc_stream_sink_signals();
+    disconnect_gvc_stream_source_signals();
+    if (notify_sink_muted_signal)
+    {
+        g_signal_handler_disconnect(gvc_sink_stream, notify_sink_muted_signal);
+    }
+
+    notify_sink_changed = 0;
+    if (notify_sink_muted_signal)
+    {
+        g_signal_handler_disconnect(gvc_sink_stream, notify_sink_muted_signal);
+    }
+
+    notify_source_changed = 0;
+}
+
+void WayfireLockerVolumePlugin::disconnect_gvc_stream_sink_signals()
+{
+    if (notify_sink_muted_signal)
+    {
+        g_signal_handler_disconnect(gvc_sink_stream, notify_sink_muted_signal);
+    }
+
+    notify_sink_muted_signal = 0;
+}
+
+void WayfireLockerVolumePlugin::disconnect_gvc_stream_source_signals()
+{
+    if (notify_source_muted_signal)
+    {
+        g_signal_handler_disconnect(gvc_source_stream, notify_source_muted_signal);
+    }
+
+    notify_source_muted_signal = 0;
+}
+
+void WayfireLockerVolumePlugin::on_default_sink_changed()
+{
+    gvc_sink_stream = gvc_mixer_control_get_default_sink(gvc_control);
+    if (!gvc_sink_stream)
+    {
+        printf("GVC: Failed to get default sink\n");
+        return;
+    }
+
+    /* Reconnect signals to new sink */
+    disconnect_gvc_stream_sink_signals();
+    notify_sink_muted_signal = g_signal_connect(gvc_sink_stream, "notify::is-muted",
+        G_CALLBACK(notify_sink_muted), this);
+    update_button_images();
+}
+
+void WayfireLockerVolumePlugin::on_default_source_changed()
+{
+    gvc_source_stream = gvc_mixer_control_get_default_source(gvc_control);
+    if (!gvc_source_stream)
+    {
+        printf("GVC: Failed to get default source\n");
+        return;
+    }
+
+    /* Reconnect signals to new source */
+    disconnect_gvc_stream_source_signals();
+    notify_source_muted_signal = g_signal_connect(gvc_source_stream, "notify::is-muted",
+        G_CALLBACK(notify_source_muted), this);
+    update_button_images();
+}
diff --git a/src/locker/plugin/volume.hpp b/src/locker/plugin/volume.hpp
new file mode 100644
index 00000000..5d254bd9
--- /dev/null
+++ b/src/locker/plugin/volume.hpp
@@ -0,0 +1,48 @@
+#pragma once
+#include <memory>
+#include <gtkmm/button.h>
+#include <gtkmm/popover.h>
+#include <gtkmm/scale.h>
+#include <pulse/pulseaudio.h>
+
+#include "gvc-mixer-control.h"
+#include "plugin.hpp"
+#include "lockergrid.hpp"
+#include "timedrevealer.hpp"
+
+class WayfireLockerVolumePluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    Gtk::Box box;
+    Gtk::Button sink_button;
+    Gtk::Button source_button;
+    WayfireLockerVolumePluginWidget();
+};
+
+class WayfireLockerVolumePlugin : public WayfireLockerPlugin
+{
+  private:
+    GvcMixerControl *gvc_control;
+    GvcMixerStream *gvc_sink_stream   = NULL;
+    GvcMixerStream *gvc_source_stream = NULL;
+    gulong notify_sink_muted_signal   = 0;
+    gulong notify_source_muted_signal = 0;
+    gulong notify_sink_changed   = 0;
+    gulong notify_source_changed = 0;
+    void disconnect_gvc_stream_sink_signals();
+    void disconnect_gvc_stream_source_signals();
+
+  public:
+    WayfireLockerVolumePlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+    void update_button_images();
+
+    /** Called when the default sink changes */
+    void on_default_sink_changed();
+    void on_default_source_changed();
+
+    std::map<int, std::shared_ptr<WayfireLockerVolumePluginWidget>> widgets;
+};
diff --git a/src/locker/plugin/weather.cpp b/src/locker/plugin/weather.cpp
new file mode 100644
index 00000000..73b8afd8
--- /dev/null
+++ b/src/locker/plugin/weather.cpp
@@ -0,0 +1,149 @@
+#include <memory>
+#include <fstream>
+#include <iostream>
+#include <glibmm.h>
+
+#include "gtkmm/enums.h"
+#include "lockergrid.hpp"
+#include "weather.hpp"
+#include "timedrevealer.hpp"
+#include "wayfire/nonstd/json.hpp"
+
+
+void WayfireLockerWeatherPlugin::update_labels(std::string text)
+{
+    for (auto& it : weather_widgets)
+    {
+        it.second->label.set_markup(text);
+    }
+
+    label_contents = text;
+}
+
+void WayfireLockerWeatherPlugin::update_icons(std::string path)
+{
+    for (auto& it : weather_widgets)
+    {
+        it.second->image.set(path);
+    }
+
+    icon_path = path;
+}
+
+WayfireLockerWeatherPluginWidget::WayfireLockerWeatherPluginWidget(std::string contents,
+    std::string icon_path) :
+    WayfireLockerTimedRevealer("locker/weather_always")
+{
+    set_child(box);
+    label.add_css_class("weather");
+    label.set_markup(contents);
+    label.set_justify(Gtk::Justification::CENTER);
+    box.prepend(label);
+
+    image.add_css_class("weather");
+    image.set(icon_path);
+    box.append(image);
+}
+
+void WayfireLockerWeatherPlugin::add_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    weather_widgets.emplace(id, new WayfireLockerWeatherPluginWidget(label_contents, icon_path));
+
+    auto weather_widget = weather_widgets[id];
+    if (!shown)
+    {
+        weather_widget->hide();
+    }
+
+    grid->attach(*weather_widget, position);
+}
+
+void WayfireLockerWeatherPlugin::remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid)
+{
+    grid->remove(*weather_widgets[id]);
+    weather_widgets.erase(id);
+}
+
+void WayfireLockerWeatherPlugin::update_weather()
+{
+    std::string weather_data_dir;
+
+    weather_data_dir = std::string(getenv("HOME")) + "/.local/share/owf/data";
+
+    std::string file_path = weather_data_dir + "/data.json";
+
+    std::ifstream input_file(file_path);
+
+    if (!input_file)
+    {
+        std::cerr << "Error reading json file " << file_path << std::endl;
+        hide();
+        return;
+    }
+
+    std::stringstream buf;
+    buf << input_file.rdbuf();
+
+    wf::json_t json_data;
+
+    auto err = wf::json_t::parse_string(buf.str(), json_data);
+
+    if (err.has_value())
+    {
+        std::cerr << "Error parsing json data " << file_path << ": " << *err << std::endl;
+        hide();
+        return;
+    }
+
+    if (!json_data.has_member("temp") || !json_data.has_member("icon"))
+    {
+        std::cerr << "Unexpected weather json data in " << file_path << std::endl;
+        hide();
+        return;
+    }
+
+    update_labels(json_data["temp"]);
+    update_icons(json_data["icon"]);
+
+    show();
+}
+
+WayfireLockerWeatherPlugin::WayfireLockerWeatherPlugin() :
+    WayfireLockerPlugin("locker/weather")
+{}
+
+void WayfireLockerWeatherPlugin::init()
+{
+    update_weather();
+    timeout = Glib::signal_timeout().connect_seconds(
+        [this] ()
+    {
+        this->update_weather();
+        return G_SOURCE_CONTINUE;
+    }, 600);
+}
+
+void WayfireLockerWeatherPlugin::deinit()
+{
+    timeout.disconnect();
+}
+
+void WayfireLockerWeatherPlugin::hide()
+{
+    for (auto& it : weather_widgets)
+    {
+        it.second->hide();
+    }
+
+    shown = false;
+}
+
+void WayfireLockerWeatherPlugin::show()
+{
+    for (auto& it : weather_widgets)
+    {
+        it.second->show();
+    }
+
+    shown = true;
+}
diff --git a/src/locker/plugin/weather.hpp b/src/locker/plugin/weather.hpp
new file mode 100644
index 00000000..45831ce9
--- /dev/null
+++ b/src/locker/plugin/weather.hpp
@@ -0,0 +1,42 @@
+#pragma once
+#include <gtkmm/label.h>
+#include <gtkmm/box.h>
+#include <gtkmm/image.h>
+#include <unordered_map>
+
+#include "plugin.hpp"
+#include "timedrevealer.hpp"
+#include "wf-option-wrap.hpp"
+#include "lockergrid.hpp"
+
+class WayfireLockerWeatherPluginWidget : public WayfireLockerTimedRevealer
+{
+  public:
+    Gtk::Box box;
+    Gtk::Label label;
+    Gtk::Image image;
+    WayfireLockerWeatherPluginWidget(std::string contents, std::string icon_path);
+};
+
+class WayfireLockerWeatherPlugin : public WayfireLockerPlugin
+{
+  public:
+    WayfireLockerWeatherPlugin();
+    void add_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void remove_output(int id, std::shared_ptr<WayfireLockerGrid> grid) override;
+    void init() override;
+    void deinit() override;
+
+    sigc::connection timeout;
+    void update_labels(std::string text);
+    void update_icons(std::string path);
+    void update_weather();
+
+    void hide();
+    void show();
+
+    std::unordered_map<int, std::shared_ptr<WayfireLockerWeatherPluginWidget>> weather_widgets;
+    std::string label_contents = "";
+    std::string icon_path = "";
+    bool shown;
+};
diff --git a/src/locker/timedrevealer.cpp b/src/locker/timedrevealer.cpp
new file mode 100644
index 00000000..9d9b42e6
--- /dev/null
+++ b/src/locker/timedrevealer.cpp
@@ -0,0 +1,109 @@
+#include <glibmm/main.h>
+#include "timedrevealer.hpp"
+#include "glib.h"
+
+WayfireLockerTimedRevealer::WayfireLockerTimedRevealer(std::string always_option) :
+    always_show(WfOption<bool>{always_option})
+{
+    if ((hide_timeout > 0) && !always_show)
+    {
+        set_reveal_child(false);
+    } else
+    {
+        set_transition_duration(0);
+        set_reveal_child(true);
+    }
+
+    auto hide_callback = [this] ()
+    {
+        Gtk::RevealerTransitionType type = Gtk::RevealerTransitionType::NONE;
+        switch (hide_animation)
+        {
+          case 1:
+            type = Gtk::RevealerTransitionType::CROSSFADE;
+            break;
+
+          case 2:
+            type = Gtk::RevealerTransitionType::SLIDE_DOWN;
+            break;
+
+          case 3:
+            type = Gtk::RevealerTransitionType::SLIDE_LEFT;
+            break;
+
+          case 4:
+            type = Gtk::RevealerTransitionType::SLIDE_RIGHT;
+            break;
+
+          case 5:
+            type = Gtk::RevealerTransitionType::SLIDE_UP;
+            break;
+
+          case 6:
+            type = Gtk::RevealerTransitionType::SWING_DOWN;
+            break;
+
+          case 7:
+            type = Gtk::RevealerTransitionType::SWING_LEFT;
+            break;
+
+          case 8:
+            type = Gtk::RevealerTransitionType::SWING_RIGHT;
+            break;
+
+          case 9:
+            type = Gtk::RevealerTransitionType::SWING_UP;
+            break;
+
+          default:
+            type = Gtk::RevealerTransitionType::NONE;
+            break;
+        }
+
+        set_transition_type(type);
+    };
+
+    hide_callback();
+    hide_animation.set_callback(hide_callback);
+
+    auto hide_duration_callback = [this] ()
+    {
+        set_transition_duration(hide_animation_duration * 1000);
+        return G_SOURCE_REMOVE;
+    };
+
+
+
+    hide_duration_callback();
+    hide_animation_duration.set_callback(hide_duration_callback);
+}
+
+WayfireLockerTimedRevealer::~WayfireLockerTimedRevealer()
+{
+    if (signal)
+    {
+        signal.disconnect();
+    }
+}
+
+void WayfireLockerTimedRevealer::activity()
+{
+    if (signal)
+    {
+        signal.disconnect();
+    }
+
+    set_reveal_child(true);
+    if (always_show || (hide_timeout == 0))
+    {
+        return;
+    }
+
+    signal = Glib::signal_timeout().connect(
+        [this] ()
+    {
+        set_reveal_child(false);
+        return G_SOURCE_REMOVE;
+    },
+        hide_timeout * 1000);
+}
diff --git a/src/locker/timedrevealer.hpp b/src/locker/timedrevealer.hpp
new file mode 100644
index 00000000..837dca81
--- /dev/null
+++ b/src/locker/timedrevealer.hpp
@@ -0,0 +1,20 @@
+#pragma once
+#include <gtkmm/revealer.h>
+#include "wf-option-wrap.hpp"
+#include <sigc++/connection.h>
+
+class WayfireLockerTimedRevealer : public Gtk::Revealer
+{
+  private:
+    sigc::connection signal;
+
+  public:
+    WayfireLockerTimedRevealer(std::string always_option);
+    ~WayfireLockerTimedRevealer();
+    WfOption<bool> always_show;
+    WfOption<double> hide_timeout{"locker/hide_time"};
+    WfOption<int> hide_animation{"locker/hide_anim"};
+    WfOption<double> hide_animation_duration{"locker/hide_anim_dur"};
+
+    virtual void activity(); /* Allow plugins to have their own logic if more intricate */
+};
diff --git a/src/meson.build b/src/meson.build
index e8931648..a2fe8f19 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -2,6 +2,8 @@ subdir('util')
 subdir('panel')
 subdir('background')
 subdir('dock')
+subdir('locker')
+subdir('locker-pin')
 
 pkgconfig = import('pkgconfig')
 pkgconfig.generate(
diff --git a/src/panel/panel.cpp b/src/panel/panel.cpp
index 80673018..6805924e 100644
--- a/src/panel/panel.cpp
+++ b/src/panel/panel.cpp
@@ -439,9 +439,20 @@ void WayfirePanelApp::create(int argc, char **argv)
     }
 
     instance = std::unique_ptr<WayfireShellApp>(new WayfirePanelApp{});
+    instance->init_app();
     instance->run(argc, argv);
 }
 
+std::string WayfirePanelApp::get_application_name()
+{
+    return "org.wayfire.panel";
+}
+
+Gio::Application::Flags WayfirePanelApp::get_extra_application_flags()
+{
+    return Gio::Application::Flags::NON_UNIQUE;
+}
+
 WayfirePanelApp::~WayfirePanelApp() = default;
 WayfirePanelApp::WayfirePanelApp() : WayfireShellApp(), priv(new impl())
 {}
diff --git a/src/panel/panel.hpp b/src/panel/panel.hpp
index fd5dd5d6..bfa0ecef 100644
--- a/src/panel/panel.hpp
+++ b/src/panel/panel.hpp
@@ -5,6 +5,7 @@
 #include <gtkmm/window.h>
 #include <gtkmm/cssprovider.h>
 
+#include "giomm/application.h"
 #include "css-config.hpp"
 #include "wf-shell-app.hpp"
 
@@ -27,6 +28,8 @@ class WayfirePanelApp : public WayfireShellApp
   public:
     WayfirePanel *panel_for_wl_output(wl_output *output);
     static WayfirePanelApp& get();
+    std::string get_application_name() override;
+    Gio::Application::Flags get_extra_application_flags() override;
 
     /* Starts the program. get() is valid afterward the first (and the only)
      * call to create() */
diff --git a/src/panel/widgets/network.cpp b/src/panel/widgets/network.cpp
index 468910c7..5d0078ab 100644
--- a/src/panel/widgets/network.cpp
+++ b/src/panel/widgets/network.cpp
@@ -50,6 +50,34 @@ struct NoConnectionInfo : public WfNetworkConnectionInfo
     {}
 };
 
+struct VPNConnectionInfo : public WfNetworkConnectionInfo
+{
+    VPNConnectionInfo(const std::shared_ptr<Gio::DBus::Connection>& connection, std::string path)
+    {}
+    virtual std::string get_icon_name(WfConnectionState state) override
+    {
+        return "network-vpn-symbolic";
+    }
+
+    int get_connection_strength() override
+    {
+        return 0;
+    }
+
+    std::string get_strength_str() override
+    {
+        return "excellent";
+    }
+
+    std::string get_ip() override
+    {
+        return "0.0.0.0";
+    }
+
+    virtual ~VPNConnectionInfo()
+    {}
+};
+
 struct WifiConnectionInfo : public WfNetworkConnectionInfo
 {
     WayfireNetworkInfo *widget;
@@ -304,11 +332,15 @@ void WayfireNetworkInfo::update_active_connection()
         {
             info = std::unique_ptr<WfNetworkConnectionInfo>(
                 new EthernetConnectionInfo(connection, object));
-        } else if (type.find("bluetooth"))
+        } else if (type.find("bluetooth") != type.npos)
         {
             std::cout << "Unimplemented: bluetooth connection" << std::endl;
             set_no_connection();
             // TODO
+        } else if (type.find("vpn") != type.npos)
+        {
+            info = std::unique_ptr<WfNetworkConnectionInfo>(
+                new VPNConnectionInfo(connection, object));
         } else
         {
             std::cout << "Unimplemented: unknown connection type" << std::endl;
diff --git a/src/panel/widgets/volume.hpp b/src/panel/widgets/volume.hpp
index c93f919c..80425cb8 100644
--- a/src/panel/widgets/volume.hpp
+++ b/src/panel/widgets/volume.hpp
@@ -1,6 +1,8 @@
 #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>
diff --git a/src/util/background-gl.cpp b/src/util/background-gl.cpp
new file mode 100644
index 00000000..54b7a84f
--- /dev/null
+++ b/src/util/background-gl.cpp
@@ -0,0 +1,407 @@
+#include <memory>
+
+#include "background-gl.hpp"
+#include "gdkmm/pixbuf.h"
+#include "glib.h"
+#include "glibmm/main.h"
+#include "glibmm/refptr.h"
+
+static const char *vertex_shader =
+    R"(
+attribute vec2 in_position;
+
+//uniform mat4 matrix;
+attribute highp vec2 uvpos;
+varying vec2 uv;
+
+void main() {
+    uv = uvpos;
+    gl_Position = vec4(in_position, 0.0, 1.0);
+}
+)";
+
+static const char *fragment_shader =
+    R"(
+precision highp float;
+uniform sampler2D bg_texture_from;
+uniform sampler2D bg_texture_to;
+uniform float progress;
+uniform vec4 from_adj;
+uniform vec4 to_adj;
+
+varying vec2 uv;
+
+void main() {
+    vec2 from_uv = vec2((uv.x * from_adj.z) - from_adj.x, (uv.y * from_adj.w) - from_adj.y);
+    vec2 to_uv = vec2((uv.x * to_adj.z) - to_adj.x, (uv.y * to_adj.w) - to_adj.y);
+    vec4 from = texture2D(bg_texture_from, from_uv);
+    vec4 to = texture2D(bg_texture_to, to_uv);
+    vec3 color = mix(from.rgb, to.rgb, progress);
+    gl_FragColor = vec4(color, 1.0);
+}
+)";
+
+/* Create and compile a shader */
+static GLuint create_shader(int type, const char *src)
+{
+    GLuint shader;
+    int status;
+
+    shader = glCreateShader(type);
+    glShaderSource(shader, 1, &src, NULL);
+    glCompileShader(shader);
+
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
+    if (status == GL_FALSE)
+    {
+        int log_len;
+        char *buffer;
+
+        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_len);
+
+        buffer = (char*)g_malloc(log_len + 1);
+        glGetShaderInfoLog(shader, log_len, NULL, buffer);
+
+        printf("Compile failure in %s shader:\n%s",
+            type == GL_VERTEX_SHADER ? "vertex" : "fragment",
+            buffer);
+
+        g_free(buffer);
+
+        glDeleteShader(shader);
+
+        return 0;
+    }
+
+    return shader;
+}
+
+/* Initialize the shaders and link them into a program */
+static GLuint init_shaders()
+{
+    GLuint vertex, fragment;
+    GLuint program = 0;
+    int status;
+
+    vertex = create_shader(GL_VERTEX_SHADER, vertex_shader);
+
+    if (vertex == 0)
+    {
+        return 0;
+    }
+
+    fragment = create_shader(GL_FRAGMENT_SHADER, fragment_shader);
+
+    if (fragment == 0)
+    {
+        glDeleteShader(vertex);
+        return 0;
+    }
+
+    program = glCreateProgram();
+    glAttachShader(program, vertex);
+    glAttachShader(program, fragment);
+
+    glLinkProgram(program);
+
+    glGetProgramiv(program, GL_LINK_STATUS, &status);
+    if (status == GL_FALSE)
+    {
+        int log_len;
+        char *buffer;
+
+        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_len);
+
+        buffer = (char*)g_malloc(log_len + 1);
+        glGetProgramInfoLog(program, log_len, NULL, buffer);
+
+        g_warning("Linking failure:\n%s", buffer);
+
+        g_free(buffer);
+
+        glDeleteProgram(program);
+        program = 0;
+
+        goto out;
+    }
+
+    glDetachShader(program, vertex);
+    glDetachShader(program, fragment);
+
+out:
+    glDeleteShader(vertex);
+    glDeleteShader(fragment);
+
+    return program;
+}
+
+void BackgroundImage::generate_adjustments(int width, int height)
+{
+    // Sanity checks
+    if ((width == 0) ||
+        (height == 0) ||
+        (source == nullptr) ||
+        (source->get_width() == 0) ||
+        (source->get_height() == 0))
+    {
+        return;
+    }
+
+    double screen_width  = (double)width;
+    double screen_height = (double)height;
+    double source_width  = (double)source->get_width();
+    double source_height = (double)source->get_height();
+
+    adjustments = Glib::RefPtr<BackgroundImageAdjustments>(new BackgroundImageAdjustments());
+    std::string fill_and_crop_string = "fill_and_crop";
+    std::string stretch_string = "stretch";
+    if (!stretch_string.compare(fill_type))
+    {
+        adjustments->x = 0.0;
+        adjustments->y = 0.0;
+        adjustments->scale_x = 1.0;
+        adjustments->scale_y = 1.0;
+    } else if (!fill_and_crop_string.compare(fill_type))
+    {
+        auto width_difference  = screen_width - source_width;
+        auto height_difference = screen_height - source_height;
+        if (width_difference > height_difference)
+        {
+            adjustments->scale_x = 1.0;
+            adjustments->scale_y = (screen_height / screen_width) * (source_width / source_height);
+            adjustments->x = 0.0;
+            adjustments->y = (screen_height - source_height * (screen_width / source_width)) *
+                adjustments->scale_y * 0.5 * (1.0 / screen_height);
+        } else
+        {
+            adjustments->scale_x = (screen_width / screen_height) * (source_height / source_width);
+            adjustments->scale_y = 1.0;
+            adjustments->x = (screen_width - source_width * (screen_height / source_height)) *
+                adjustments->scale_x * 0.5 * (1.0 / screen_width);
+            adjustments->y = 0.0;
+        }
+    } else /* "preserve_aspect" */
+    {
+        auto width_difference  = screen_width / source_width;
+        auto height_difference = screen_height / source_height;
+        if (width_difference > height_difference)
+        {
+            adjustments->scale_x = (screen_width / screen_height) * (source_height / source_width);
+            adjustments->scale_y = 1.0;
+            adjustments->x = (screen_width - source_width * (screen_height / source_height)) *
+                adjustments->scale_x * 0.5 * (1.0 / screen_width);
+            adjustments->y = 0.0;
+        } else
+        {
+            adjustments->scale_x = 1.0;
+            adjustments->scale_y = (screen_height / screen_width) * (source_width / source_height);
+            adjustments->x = 0.0;
+            adjustments->y = (screen_height - source_height * (screen_width / source_width)) *
+                adjustments->scale_y * 0.5 * (1.0 / screen_height);
+        }
+    }
+}
+
+bool BackgroundGLArea::show_image(std::string path)
+{
+    std::shared_ptr<BackgroundImage> image = std::make_shared<BackgroundImage>();
+    std::string fill_mode = WfOption<std::string>{"background/fill_mode"};
+
+    image->fill_type = fill_mode;
+
+    try {
+        image->source = Gdk::Pixbuf::create_from_file(path);
+    } catch (...)
+    {
+        return false;
+    }
+
+    if (image->source == nullptr)
+    {
+        return false;
+    }
+
+    show_image(image);
+    return true;
+}
+
+void BackgroundGLArea::show_image(std::shared_ptr<BackgroundImage> next_image)
+{
+    int window_width = get_width(), window_height = get_height();
+    if (!next_image || !next_image->source)
+    {
+        to_image   = nullptr;
+        from_image = nullptr;
+        return;
+    }
+
+    if ((window_width <= 0) || (window_height <= 0))
+    {
+        /* Retry momentarily */
+        Glib::signal_idle().connect([this, next_image]
+            ()
+        {
+            show_image(next_image);
+            return G_SOURCE_REMOVE;
+        });
+        return;
+    }
+
+    if (to_image)
+    {
+        from_image = to_image;
+    }
+
+    to_image = next_image;
+
+    int width, height;
+
+    to_image->generate_adjustments(window_width, window_height);
+    width  = to_image->source->get_width();
+    height = to_image->source->get_height();
+    glBindTexture(GL_TEXTURE_2D, to_image->tex_id);
+    auto format = to_image->source->get_has_alpha() ? GL_RGBA : GL_RGB;
+    glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE,
+        to_image->source->get_pixels());
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    fade = {
+        WfOption<int>{"background/fade_duration"},
+        wf::animation::smoothing::sigmoid
+    };
+    fade.animate(0.0, 1.0);
+
+    this->queue_draw();
+}
+
+static GLuint create_texture()
+{
+    GLuint tex;
+
+    glGenTextures(1, &tex);
+    glBindTexture(GL_TEXTURE_2D, tex);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    return tex;
+}
+
+BackgroundImage::BackgroundImage()
+{
+    tex_id = create_texture();
+}
+
+BackgroundImage::~BackgroundImage()
+{
+    glDeleteTextures(1, &tex_id);
+}
+
+BackgroundGLArea::BackgroundGLArea()
+{
+    signal_realize().connect(sigc::mem_fun(*this, &BackgroundGLArea::realize));
+    signal_render().connect(sigc::mem_fun(*this, &BackgroundGLArea::render), false);
+    signal_resize().connect(
+        [this] (int width, int height)
+    {
+        if (to_image)
+        {
+            int window_width = get_width(), window_height = get_height();
+            to_image->generate_adjustments(window_width, window_height);
+            queue_draw();
+        }
+    });
+}
+
+void BackgroundGLArea::realize()
+{
+    this->make_current();
+    program = init_shaders();
+}
+
+bool BackgroundGLArea::render(const Glib::RefPtr<Gdk::GLContext>& context)
+{
+    if (!to_image)
+    {
+        return true;
+    }
+
+    static const float vertices[] = {
+        1.0f, 1.0f,
+        -1.0f, 1.0f,
+        -1.0f, -1.0f,
+        1.0f, -1.0f,
+    };
+    static const float uv_coords[] = {
+        1.0f, 0.0f,
+        0.0f, 0.0f,
+        0.0f, 1.0f,
+        1.0f, 1.0f,
+    };
+    static float from_adj[4] = {0.0, 0.0, 1.0, 1.0};
+    if (from_image)
+    {
+        from_adj[0] = from_image->adjustments->x;
+        from_adj[1] = from_image->adjustments->y;
+        from_adj[2] = from_image->adjustments->scale_x;
+        from_adj[3] = from_image->adjustments->scale_y;
+    }
+
+    static float to_adj[4] = {0.0, 0.0, 1.0, 1.0};
+    if (to_image)
+    {
+        to_adj[0] = to_image->adjustments->x;
+        to_adj[1] = to_image->adjustments->y;
+        to_adj[2] = to_image->adjustments->scale_x;
+        to_adj[3] = to_image->adjustments->scale_y;
+    }
+
+    glClearColor(0.0, 0.0, 0.0, 1.0);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glUseProgram(program);
+    if (from_image)
+    {
+        glActiveTexture(GL_TEXTURE0);
+        glBindTexture(GL_TEXTURE_2D, from_image->tex_id);
+        GLuint from_tex_uniform = glGetUniformLocation(program, "bg_texture_from");
+        glUniform1i(from_tex_uniform, 0);
+    }
+
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, to_image->tex_id);
+    GLuint to_tex_uniform = glGetUniformLocation(program, "bg_texture_to");
+    glUniform1i(to_tex_uniform, 1);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices);
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, uv_coords);
+    GLuint progress = glGetUniformLocation(program, "progress");
+    glUniform1f(progress, fade);
+    GLuint from_adj_loc = glGetUniformLocation(program, "from_adj");
+    glUniform4fv(from_adj_loc, 1, from_adj);
+    GLuint to_adj_loc = glGetUniformLocation(program, "to_adj");
+    glUniform4fv(to_adj_loc, 1, to_adj);
+
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glDisableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
+    glUseProgram(0);
+
+    if (fade.running())
+    {
+        Glib::signal_idle().connect([=] ()
+        {
+            this->queue_draw();
+            return false;
+        });
+    }
+
+    return true;
+}
diff --git a/src/util/background-gl.hpp b/src/util/background-gl.hpp
new file mode 100644
index 00000000..d8c7512a
--- /dev/null
+++ b/src/util/background-gl.hpp
@@ -0,0 +1,55 @@
+#pragma once
+#include <glibmm.h>
+#include <epoxy/gl.h>
+#include <gtkmm.h>
+#include <gdkmm.h>
+#include <memory>
+#include <wf-option-wrap.hpp>
+#include <wayfire/util/duration.hpp>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+
+class BackgroundImageAdjustments
+{
+  public:
+    GLfloat scale_x = -1, scale_y = -1;
+    GLfloat x, y;
+};
+
+class BackgroundImage
+{
+  public:
+    BackgroundImage();
+    ~BackgroundImage();
+    Glib::RefPtr<Gdk::Pixbuf> source;
+    std::string fill_type;
+    Glib::RefPtr<BackgroundImageAdjustments> adjustments;
+    void generate_adjustments(int width, int height);
+    GLuint tex_id = 0;
+};
+
+class BackgroundGLArea : public Gtk::GLArea
+{
+    GLuint program = 0;
+    wf::animation::simple_animation_t fade;
+
+    /* These two pixbufs are used for fading one background
+     * image to the next when changing backgrounds or when
+     * automatically cycling through a directory of images.
+     * pbuf is the current image to which we are fading and
+     * pbuf2 is the image from which we are fading. x and y
+     * are used as offsets when preserve aspect is set. */
+    std::shared_ptr<BackgroundImage> to_image, from_image;
+    void show_image(std::shared_ptr<BackgroundImage> image);
+
+  public:
+    BackgroundGLArea();
+    void realize();
+    bool render(const Glib::RefPtr<Gdk::GLContext>& context);
+    bool show_image(std::string path);
+
+    std::shared_ptr<BackgroundImage> get_current_image()
+    {
+        return to_image;
+    }
+};
diff --git a/src/util/css-config.cpp b/src/util/css-config.cpp
index c1bf40cf..3019aec9 100644
--- a/src/util/css-config.cpp
+++ b/src/util/css-config.cpp
@@ -1,8 +1,8 @@
 #include <css-config.hpp>
-#include <wf-option-wrap.hpp>
 #include <sstream>
 #include <iostream>
 #include <regex>
+#include <string>
 
 void CssFromConfig::add_provider()
 {
@@ -15,14 +15,32 @@ void CssFromConfig::remove_provider()
     Gtk::StyleContext::remove_provider_for_display(Gdk::Display::get_default(), provider);
 }
 
+CssFromConfigDouble::CssFromConfigDouble(std::string option_name, std::string before, std::string after) :
+    option_value{option_name}
+{
+    provider = Gtk::CssProvider::create();
+    auto cb = [=]
+    {
+        std::stringstream ss;
+        ss << before << std::to_string(option_value.value()) << after;
+        std::cout << ss.str() << std::endl;
+        provider->load_from_string(ss.str());
+    };
+    option_value.set_callback(cb);
+    cb();
+    add_provider();
+}
+
 CssFromConfigBool::CssFromConfigBool(std::string option_name, std::string css_true, std::string css_false) :
     option_value{option_name}
 {
     provider = Gtk::CssProvider::create();
-    option_value.set_callback([=]
+    auto cb = [=]
     {
         provider->load_from_string(option_value ? css_true : css_false);
-    });
+    };
+    option_value.set_callback(cb);
+    cb();
 
     add_provider();
 }
@@ -33,13 +51,15 @@ CssFromConfigInt::CssFromConfigInt(std::string option_name, std::string css_befo
     provider = Gtk::CssProvider::create();
     option_value.set_callback([=]
     {
+        int value = option_value;
         // TODO When we go up to c++20 use std::format
         std::stringstream ss;
-        ss << css_before << option_value << css_after;
+        ss << css_before << std::to_string(value) << css_after;
         provider->load_from_string(ss.str());
     });
+    int value = option_value;
     std::stringstream ss;
-    ss << css_before << option_value << css_after;
+    ss << css_before << std::to_string(value) << css_after;
     provider->load_from_string(ss.str());
 
     add_provider();
diff --git a/src/util/css-config.hpp b/src/util/css-config.hpp
index fb6c07a0..9471a770 100644
--- a/src/util/css-config.hpp
+++ b/src/util/css-config.hpp
@@ -3,7 +3,7 @@
 #include <string>
 #include <glibmm.h>
 #include <gtkmm.h>
-#include <wf-option-wrap.hpp>
+#include "wf-option-wrap.hpp"
 
 class CssFromConfig
 {
@@ -14,6 +14,14 @@ class CssFromConfig
     void remove_provider();
 };
 
+class CssFromConfigDouble : public CssFromConfig
+{
+    WfOption<double> option_value;
+
+  public:
+    CssFromConfigDouble(std::string config_opt, std::string css_before, std::string css_after);
+};
+
 class CssFromConfigBool : public CssFromConfig
 {
     WfOption<bool> option_value;
diff --git a/src/util/meson.build b/src/util/meson.build
index 5621206e..f50eb58f 100644
--- a/src/util/meson.build
+++ b/src/util/meson.build
@@ -8,6 +8,7 @@ util = static_library(
         'css-config.cpp',
         'wf-ipc.cpp',
         'animated-scale.cpp',
+        'background-gl.cpp',
     ],
     dependencies: [wf_protos, gtklayershell, wayland_client, gtkmm, wfconfig, libinotify, json],
 )
diff --git a/src/util/wf-shell-app.cpp b/src/util/wf-shell-app.cpp
index b740d864..191bceda 100644
--- a/src/util/wf-shell-app.cpp
+++ b/src/util/wf-shell-app.cpp
@@ -187,6 +187,12 @@ static struct wl_registry_listener registry_listener =
 
 void WayfireShellApp::on_activate()
 {
+    if (activated)
+    {
+        return;
+    }
+
+    activated = true;
     app->hold();
 
     // load wf-shell if available
@@ -222,17 +228,20 @@ void WayfireShellApp::on_activate()
         sigc::bind<0>(&handle_css_inotify_event, this),
         inotify_css_fd, Glib::IOCondition::IO_IN | Glib::IOCondition::IO_HUP);
 
-    // Hook up monitor tracking
-    auto display  = Gdk::Display::get_default();
-    auto monitors = display->get_monitors();
-    monitors->signal_items_changed().connect(sigc::mem_fun(*this, &WayfireShellApp::output_list_updated));
-
-    // initial monitors
-    int num_monitors = monitors->get_n_items();
-    for (int i = 0; i < num_monitors; i++)
+    if (!alternative_monitors)
     {
-        auto obj = std::dynamic_pointer_cast<Gdk::Monitor>(monitors->get_object(i));
-        add_output(obj);
+        // Hook up monitor tracking
+        auto display  = Gdk::Display::get_default();
+        auto monitors = display->get_monitors();
+        monitors->signal_items_changed().connect(sigc::mem_fun(*this, &WayfireShellApp::output_list_updated));
+
+        // initial monitors
+        int num_monitors = monitors->get_n_items();
+        for (int i = 0; i < num_monitors; i++)
+        {
+            auto obj = std::dynamic_pointer_cast<Gdk::Monitor>(monitors->get_object(i));
+            add_output(obj);
+        }
     }
 }
 
@@ -281,10 +290,19 @@ void WayfireShellApp::rem_output(GMonitor monitor)
     }
 }
 
+Gio::Application::Flags WayfireShellApp::get_extra_application_flags()
+{
+    return Gio::Application::Flags::NONE;
+}
+
 WayfireShellApp::WayfireShellApp()
+{}
+
+void WayfireShellApp::init_app()
 {
     std::cout << "setting up" << std::endl;
-    app = Gtk::Application::create("", Gio::Application::Flags::HANDLES_COMMAND_LINE);
+    app = Gtk::Application::create(
+        this->get_application_name(), Gio::Application::Flags::NONE | this->get_extra_application_flags());
     app->signal_activate().connect(
         sigc::mem_fun(*this, &WayfireShellApp::on_activate));
     app->add_main_option_entry(
@@ -293,7 +311,7 @@ WayfireShellApp::WayfireShellApp()
     app->add_main_option_entry(
         sigc::mem_fun(*this, &WayfireShellApp::parse_cssfile),
         "css", 's', "css style directory to use", "directory");
-
+    this->command_line();
     // Activate app after parsing command line
     app->signal_command_line().connect_notify([=] (auto&)
     {
diff --git a/src/util/wf-shell-app.hpp b/src/util/wf-shell-app.hpp
index cc95c2ba..e582fb06 100644
--- a/src/util/wf-shell-app.hpp
+++ b/src/util/wf-shell-app.hpp
@@ -42,11 +42,13 @@ class WayfireShellApp
   protected:
     /** 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;
     std::optional<std::string> cmdline_css;
 
     Glib::RefPtr<Gtk::Application> app;
+    bool activated = false;
 
     void output_list_updated(int pos, int rem, int add);
     virtual void add_output(GMonitor monitor);
@@ -72,17 +74,21 @@ class WayfireShellApp
 
     WayfireShellApp();
     virtual ~WayfireShellApp();
+    void init_app();
 
     virtual std::string get_config_file();
     virtual std::string get_css_config_dir();
     virtual void run(int argc, char **argv);
+    virtual void command_line()
+    {}
 
     virtual void on_config_reload()
     {}
     void on_css_reload();
     void clear_css_rules();
     void add_css_file(std::string file, int priority);
-
+    virtual Gio::Application::Flags get_extra_application_flags();
+    virtual std::string get_application_name() = 0;
 
     /**
      * WayfireShellApp is a singleton class.
diff --git a/subprojects/.wraplock b/subprojects/.wraplock
new file mode 100644
index 00000000..e69de29b