wanda: restructure source directory

35 files changed, 2632 insertions, 0 deletions

diff --git a/source/.clang-format b/source/.clang-format
new file mode 100644
index 0000000..b99e359
--- /dev/null
+++ b/source/.clang-format
@@ -0,0 +1,68 @@
+---
+AccessModifierOffset: '-2'
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: 'false'
+AlignConsecutiveDeclarations: 'false'
+AlignEscapedNewlines: Left
+AlignOperands: 'true'
+AlignTrailingComments: 'false'
+AllowAllParametersOfDeclarationOnNextLine: 'true'
+AllowShortBlocksOnASingleLine: 'false'
+AllowShortCaseLabelsOnASingleLine: 'false'
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: 'false'
+AllowShortLoopsOnASingleLine: 'false'
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakTemplateDeclarations: 'true'
+BinPackArguments: 'true'
+BinPackParameters: 'true'
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterClass: 'true'
+  AfterControlStatement: 'true'
+  AfterEnum: 'true'
+  AfterFunction: 'true'
+  AfterNamespace: 'true'
+  AfterStruct: 'true'
+  AfterUnion: 'true'
+  AfterExternBlock: 'true'
+  BeforeCatch: 'true'
+  BeforeElse: 'true'
+  IndentBraces: 'false'
+BreakBeforeInheritanceComma: 'false'
+BreakConstructorInitializers: BeforeComma
+BreakStringLiterals: 'true'
+ColumnLimit: '0'
+CompactNamespaces: 'false'
+Cpp11BracedListStyle: 'true'
+DerivePointerAlignment: 'false'
+FixNamespaceComments: 'true'
+IncludeBlocks: Preserve
+IndentCaseLabels: 'true'
+IndentPPDirectives: None
+IndentWidth: '2'
+KeepEmptyLinesAtTheStartOfBlocks: 'false'
+Language: Cpp
+MaxEmptyLinesToKeep: '1'
+NamespaceIndentation: All
+PointerAlignment: Middle
+ReflowComments: 'true'
+SortIncludes: 'true'
+SortUsingDeclarations: 'true'
+SpaceAfterCStyleCast: 'false'
+SpaceAfterTemplateKeyword: 'false'
+SpaceBeforeAssignmentOperators: 'true'
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: 'false'
+SpacesBeforeTrailingComments: '2'
+SpacesInAngles: 'false'
+SpacesInCStyleCastParentheses: 'false'
+SpacesInContainerLiterals: 'false'
+SpacesInParentheses: 'false'
+SpacesInSquareBrackets: 'false'
+Standard: Cpp11
+TabWidth: '2'
+UseTab: Never
+
+...
diff --git a/source/.gitignore b/source/.gitignore
new file mode 100644
index 0000000..0c2999d
--- /dev/null
+++ b/source/.gitignore
@@ -0,0 +1 @@
+/CMakeUserPresets.json
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
new file mode 100644
index 0000000..6d1ec20
--- /dev/null
+++ b/source/CMakeLists.txt
@@ -0,0 +1,130 @@
+cmake_minimum_required(VERSION 3.24)
+
+project("wanda"
+  LANGUAGES CXX
+  VERSION "1.0.0"
+)
+
+set(CMAKE_THREAD_PREFER_PTHREAD ON)
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+
+find_package("asio")
+find_package("Boost")
+find_package("JPEG")
+find_package("PNG")
+find_package("lyra")
+find_package("spdlog")
+find_package("Threads")
+
+find_package("PkgConfig" REQUIRED)
+
+pkg_check_modules("GIO"
+  REQUIRED
+  IMPORTED_TARGET
+  GLOBAL
+  "gio-2.0"
+)
+
+pkg_check_modules("libmagic"
+  REQUIRED
+  IMPORTED_TARGET
+  GLOBAL
+  "libmagic"
+)
+
+# Core Library
+
+add_library("${PROJECT_NAME}" STATIC
+  "${PROJECT_SOURCE_DIR}/src/wanda/command.cpp"
+  "${PROJECT_SOURCE_DIR}/src/wanda/control_connection.cpp"
+  "${PROJECT_SOURCE_DIR}/src/wanda/environment.cpp"
+  "${PROJECT_SOURCE_DIR}/src/wanda/logging.cpp"
+  "${PROJECT_SOURCE_DIR}/src/wanda/message.cpp"
+  "${PROJECT_SOURCE_DIR}/src/wanda/xdg.cpp"
+
+  "${PROJECT_SOURCE_DIR}/include/wanda/command.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/control_connection.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/deferred_failure.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/environment.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/expected.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/keyed.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/logging.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/message.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/optional.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/type_wrapper.hpp"
+  "${PROJECT_SOURCE_DIR}/include/wanda/xdg.hpp"
+)
+
+target_compile_features("${PROJECT_NAME}" PUBLIC
+  "cxx_std_20"
+)
+
+target_link_libraries("${PROJECT_NAME}" PUBLIC
+  "asio::asio"
+  "spdlog::spdlog"
+  "Threads::Threads"
+)
+
+target_include_directories("${PROJECT_NAME}" SYSTEM
+  PUBLIC "${PROJECT_SOURCE_DIR}/include"
+)
+
+set_target_properties("${PROJECT_NAME}" PROPERTIES
+  CXX_STANDARD_REQUIRED YES
+  CXX_EXTENSIONS OFF
+)
+
+# Core Executables
+
+add_executable("${PROJECT_NAME}d"
+  "${PROJECT_SOURCE_DIR}/src/${PROJECT_NAME}/control_interface.cpp"
+  "${PROJECT_SOURCE_DIR}/src/${PROJECT_NAME}/filesystem.cpp"
+  "${PROJECT_SOURCE_DIR}/src/${PROJECT_NAME}/setting.cpp"
+  "${PROJECT_SOURCE_DIR}/src/${PROJECT_NAME}/wallpaper.cpp"
+  "${PROJECT_SOURCE_DIR}/src/${PROJECT_NAME}/wandad.cpp"
+
+  "${PROJECT_SOURCE_DIR}/include/${PROJECT_NAME}/control_interface.hpp"
+  "${PROJECT_SOURCE_DIR}/include/${PROJECT_NAME}/filesystem.hpp"
+  "${PROJECT_SOURCE_DIR}/include/${PROJECT_NAME}/setting.hpp"
+  "${PROJECT_SOURCE_DIR}/include/${PROJECT_NAME}/wallpaper.hpp"
+)
+
+target_link_libraries("${PROJECT_NAME}d" PRIVATE
+  "${PROJECT_NAME}"
+  "bfg::lyra"
+  "boost::boost"
+  "JPEG::JPEG"
+  "PkgConfig::GIO"
+  "PkgConfig::libmagic"
+  "PNG::PNG"
+)
+
+set_target_properties("${PROJECT_NAME}d" PROPERTIES
+  CXX_STANDARD_REQUIRED YES
+  CXX_EXTENSIONS OFF
+)
+
+add_executable("${PROJECT_NAME}c"
+  "${PROJECT_SOURCE_DIR}/src/${PROJECT_NAME}/commander.cpp"
+  "${PROJECT_SOURCE_DIR}/src/${PROJECT_NAME}/wandac.cpp"
+
+  "${PROJECT_SOURCE_DIR}/include/${PROJECT_NAME}/commander.hpp"
+)
+
+target_link_libraries("${PROJECT_NAME}c" PRIVATE
+  "${PROJECT_NAME}"
+  "bfg::lyra"
+)
+
+set_target_properties("${PROJECT_NAME}c" PROPERTIES
+  CXX_STANDARD_REQUIRED YES
+  CXX_EXTENSIONS OFF
+)
+
+# Install Targets
+
+install(TARGETS
+  "${PROJECT_NAME}"
+  "${PROJECT_NAME}c"
+  "${PROJECT_NAME}d"
+)
diff --git a/source/include/wanda/command.hpp b/source/include/wanda/command.hpp
new file mode 100644
index 0000000..5ea1a08
--- /dev/null
+++ b/source/include/wanda/command.hpp
@@ -0,0 +1,46 @@
+#ifndef WANDA_COMMAND_HPP
+#define WANDA_COMMAND_HPP
+
+#include <wanda/message.hpp>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace wanda
+{
+  /**
+   * @brief An enum to describe different command IDs
+   */
+  enum struct command_id : char
+  {
+    change,  //< Change the wallpaper
+  };
+
+  /**
+   * @brief A simple type to represent commands transported through the control connection
+   */
+  struct command
+  {
+    command_id const id;
+    std::vector<std::string> const arguments;
+
+    /**
+     * @brief Convert the command to a message for transmission to a remote endpoint
+     */
+    std::optional<wanda::message> message() const;
+  };
+
+  /**
+   * @brief Extract a command from a message
+   */
+  std::optional<command> make_command(message message);
+
+  /**
+   * @brief A simple factory to create a "Change wallpaper" command
+   */
+  command make_change_command();
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/commander.hpp b/source/include/wanda/commander.hpp
new file mode 100644
index 0000000..1c76c6d
--- /dev/null
+++ b/source/include/wanda/commander.hpp
@@ -0,0 +1,66 @@
+#ifndef WANDA_COMMANDER_HPP
+#define WANDA_COMMANDER_HPP
+
+#include <wanda/command.hpp>
+#include <wanda/control_connection.hpp>
+#include <wanda/message.hpp>
+
+#include <asio.hpp>
+
+#include <filesystem>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace wanda
+{
+  /**
+   * @brief The remote control client
+   * 
+   */
+  struct commander : wanda::control_connection::listener
+  {
+    /**
+     * @brief The interface to be implemented by remote control listeners
+     */
+    struct listener
+    {
+      virtual void on_connected(commander & commander){};
+      virtual void on_response(commander & commander, std::string response){};
+      virtual void on_error(commander & commander, std::string error){};
+    };
+
+    /**
+     * @brief Construct a new commander
+     */
+    commander(asio::io_service & service, std::filesystem::path socket, listener & listener);
+
+    /**
+     * @brief Start communication with the remote daemon endpoint
+     */
+    void start();
+
+    /**
+     * @brief Stop communication with the remote daemon endpoint
+     */
+    void stop();
+
+    /**
+     * @brief Send a command to the remote daemon endpoint
+     */
+    void send(command command);
+
+    void on_error(control_connection::pointer connection, std::error_code error) override;
+    void on_received(control_connection::pointer connection, message message) override;
+
+  private:
+    asio::io_service & m_service;
+    wanda::control_connection::protocol::endpoint m_endpoint;
+    wanda::control_connection::protocol::socket m_socket;
+    wanda::control_connection::pointer m_connection;
+    listener & m_listener;
+  };
+
+}  // namespace wanda
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/control_connection.hpp b/source/include/wanda/control_connection.hpp
new file mode 100644
index 0000000..b692d37
--- /dev/null
+++ b/source/include/wanda/control_connection.hpp
@@ -0,0 +1,114 @@
+#ifndef WANDA_CONTROL_CONNECTION_HPP
+#define WANDA_CONTROL_CONNECTION_HPP
+
+#include <wanda/keyed.hpp>
+#include <wanda/message.hpp>
+
+#include <asio.hpp>
+
+#include <istream>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <string>
+#include <system_error>
+
+namespace wanda
+{
+  /**
+   * @brief A connection to a remote control endpoint
+   */
+  struct control_connection : keyed<control_connection>, std::enable_shared_from_this<control_connection>
+  {
+    using protocol = asio::local::stream_protocol;
+    using pointer = std::shared_ptr<control_connection>;
+
+    /**
+     * @brief The interface to be implemented by the control interface listener
+     */
+    struct listener
+    {
+      virtual void on_close(pointer connection) {}
+      virtual void on_received(pointer connection, message message) {}
+      virtual void on_error(pointer connection, std::error_code) {}
+    };
+
+    /**
+     * @brief A enum to describe different connection states
+     */
+    enum struct state : std::underlying_type_t<std::byte>
+    {
+      unknown,  //< Connection is in an unknown state
+      fresh,  //< Connection is freshly created but not established
+      established,  //< Connection has been established
+    };
+
+    /**
+     * @internal
+     * @brief Construct a new control connection object
+     * 
+     * @note This constructor is keyed on a private key type so it can only be constructed using the #wanda::make_connection factory
+     */
+    control_connection(key, protocol::socket socket);
+
+    /**
+     * @brief Add the given listener to this control connection's listener set
+     * 
+     * @returns <code>true</code> iff. the listener was not already in the listener set
+     */
+    bool add(listener * listener);
+
+    /**
+     * @brief Remove the given listener from this control connection's listener set
+     * 
+     * @return <code>true</code> iff. the listener was previously registered with this control connection
+     */
+    bool remove(listener * listener);
+
+    /**
+     * @brief Start I/O processing for this control connection
+     */
+    void start();
+
+    /**
+     * @brief Close this control connection
+     */
+    void close();
+
+    /**
+     * @brief Send the given message to the remote endpoint
+     */
+    void send(message message);
+
+    /**
+     * @brief Set the connection state to the provided state
+     */
+    void update(state state);
+
+    /**
+     * @brief Get the current connection state
+     */
+    state current_state() const;
+
+  private:
+    friend pointer make_control_connection(protocol::socket && socket);
+
+    void perform_read();
+
+    protocol::socket m_socket;
+    asio::streambuf m_in{};
+    asio::streambuf m_out{};
+    std::istream m_input{&m_in};
+    std::ostream m_output{&m_out};
+    std::set<listener *> m_listeners{};
+    state m_state{};
+  };
+
+  /**
+   * @brief Create a new control connection
+   */
+  control_connection::pointer make_control_connection(control_connection::protocol::socket && socket);
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/control_interface.hpp b/source/include/wanda/control_interface.hpp
new file mode 100644
index 0000000..73ef2cf
--- /dev/null
+++ b/source/include/wanda/control_interface.hpp
@@ -0,0 +1,96 @@
+/**
+ * @file   environment.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_CONTROL_INTERFACE_HPP
+#define WANDA_CONTROL_INTERFACE_HPP
+
+#include <wanda/command.hpp>
+#include <wanda/control_connection.hpp>
+#include <wanda/keyed.hpp>
+
+#include <asio.hpp>
+#include <spdlog/spdlog.h>
+
+#include <cstddef>
+#include <filesystem>
+#include <istream>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <type_traits>
+
+namespace wanda
+{
+  /**
+   * @brief An RAII type to delete a socket file upon destruction
+   */
+  struct socket_deleter
+  {
+    ~socket_deleter();
+
+    std::filesystem::path path;
+  };
+
+  /**
+   * @brief The daemon control interface
+   */
+  struct control_interface : control_connection::listener, keyed<control_interface>, std::enable_shared_from_this<control_interface>
+  {
+    using protocol = asio::local::stream_protocol;
+    using pointer = std::shared_ptr<control_interface>;
+
+    /**
+     * @brief The interface to be implemented by the control interface listener
+     */
+    struct listener
+    {
+      virtual void on_received(control_interface & interface, command command){};
+    };
+
+    /**
+     * @internal
+     * @brief Construct a new control interface object
+     * 
+     * @note This constructor is keyed on a private key type so it can only be constructed using the #wanda::make_interface factory
+     */
+    control_interface(key, asio::io_service & service, protocol::endpoint endpoint, listener & listener);
+
+    /**
+     * @brief Start handling of controller connections
+     */
+    std::error_code start();
+
+    /**
+     * @brief Stop the control interface
+     */
+    std::error_code shutdown();
+
+    void on_close(control_connection::pointer connection) override;
+    void on_received(control_connection::pointer connection, message message) override;
+
+  private:
+    void perform_accept();
+
+    friend pointer make_interface(asio::io_service & service, std::filesystem::path file, control_interface::listener & listener);
+
+    asio::io_service & m_service;
+    protocol::endpoint m_endpoint;
+    protocol::socket m_socket;
+    protocol::acceptor m_acceptor;
+    listener & m_listener;
+    socket_deleter m_deleter{m_endpoint.path()};
+    std::set<control_connection::pointer> m_connections;
+  };
+
+  /**
+   * @brief A factory to create new #control_interface instances
+   */
+  control_interface::pointer make_interface(asio::io_service & service, std::filesystem::path socket, control_interface::listener & listener);
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/deferred_failure.hpp b/source/include/wanda/deferred_failure.hpp
new file mode 100644
index 0000000..5db26f6
--- /dev/null
+++ b/source/include/wanda/deferred_failure.hpp
@@ -0,0 +1,21 @@
+/**
+ * @file   deferred_failure.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_DEFERRED_FAILURE_HPP
+#define WANDA_DEFERRED_FAILURE_HPP
+
+#include <type_traits>
+
+namespace
+{
+  /**
+   * @brief A helper type to defer static_assert failures
+   */
+  template<typename...>
+  using deferred_failure = std::false_type;
+}  // namespace
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/environment.hpp b/source/include/wanda/environment.hpp
new file mode 100644
index 0000000..5a702a8
--- /dev/null
+++ b/source/include/wanda/environment.hpp
@@ -0,0 +1,61 @@
+/**
+ * @file   environment.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_ENVIRONMENT_HPP
+#define WANDA_ENVIRONMENT_HPP
+
+#include <unistd.h>
+
+#include <map>
+#include <string>
+
+namespace wanda
+{
+  /**
+   * @brief A type to provide access to the runtime environment
+   */
+  struct environment
+  {
+    using map_type = std::map<std::string, std::string>;
+    using iterator = map_type::iterator;
+    using const_iterator = map_type::const_iterator;
+    using reference = map_type::reference;
+    using const_reference = map_type::const_reference;
+
+    /**
+     * @brief Construct a new environment from the given string array
+     */
+    explicit environment(char const * const * env = ::environ);
+
+    /**
+     * @brief Get the value of the given variable
+     * 
+     * @return A mutable reference to the value of the given environment variable
+     */
+    std::string & operator[](std::string const & variable);
+
+    /**
+     * @brief Get the value of the given variable
+     * 
+     * @return An immutable reference to the value of the given environment variable
+     */
+    std::string const & operator[](std::string const & variable) const;
+
+    iterator begin();
+    const_iterator begin() const;
+    const_iterator cbegin() const;
+
+    iterator end();
+    const_iterator end() const;
+    const_iterator cend() const;
+
+  private:
+    map_type m_cache{};
+  };
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/expected.hpp b/source/include/wanda/expected.hpp
new file mode 100644
index 0000000..fff0d81
--- /dev/null
+++ b/source/include/wanda/expected.hpp
@@ -0,0 +1,256 @@
+/**
+ * @file   expected.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_EXPECTED_HPP
+#define WANDA_EXPECTED_HPP
+
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+namespace wanda
+{
+  /**
+    * @brief A type to represent the error case of a computation based on #wanda::expected
+    */
+  template<typename ErrorType>
+  struct unexpected
+  {
+    static_assert(!std::is_same_v<ErrorType, void>, "ErrorType can not be 'void'!");
+    static_assert(!std::is_array_v<ErrorType>, "ErrorType can not be an array type!");
+
+    /**
+     * @brief Copy construct a new @p unexpected from another @p unexpected
+     */
+    constexpr unexpected(unexpected const &) = default;
+
+    /**
+     * @brief Move construct a new @p unexpected from another @p unexpected
+     */
+    constexpr unexpected(unexpected &&) = default;
+
+    /**
+     * @brief Construct a new @p unexpected by direct initializing the error object from @p args
+     */
+    template<typename... Args>
+    constexpr explicit unexpected(std::in_place_t, Args &&... args)
+        : m_error(std::forward<Args>(args)...)
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by direct initializing the error object from @p il and @p args
+     */
+    template<
+        typename U,
+        typename... Args,
+        std::enable_if_t<std::is_constructible_v<ErrorType, std::initializer_list<U>, Args...>> * = nullptr>
+    constexpr explicit unexpected(std::in_place_t, std::initializer_list<U> il, Args &&... args)
+        : m_error(il, std::forward<Args>(args)...)
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by direct initializing the error object from @p error
+     */
+    template<
+        typename Err = ErrorType,
+        std::enable_if_t<std::is_constructible_v<ErrorType, Err> &&
+                         !std::is_same_v<std::remove_cv_t<std::remove_reference_t<Err>>, std::in_place_t> &&
+                         !std::is_same_v<std::remove_cv_t<std::remove_reference_t<Err>>, unexpected>> * = nullptr>
+    constexpr explicit unexpected(Err && error)
+        : m_error(std::forward<Err>(error))
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by copying the value of another @p unexpected of different error type
+     */
+    template<
+        typename Err,
+        std::enable_if_t<!(
+            std::is_constructible_v<ErrorType, Err> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err>> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const> &&
+            !std::is_convertible_v<unexpected<Err> &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err>, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const, ErrorType>)> * = nullptr,
+        std::enable_if_t<!std::is_convertible_v<Err, ErrorType>> * = nullptr>
+    constexpr explicit unexpected(unexpected<Err> const & error)
+        : m_error(error.m_error)
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by copying the value of another @p unexpected of different error type
+     */
+    template<
+        typename Err,
+        std::enable_if_t<!(
+            std::is_constructible_v<ErrorType, Err> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err>> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const> &&
+            !std::is_convertible_v<unexpected<Err> &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err>, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const, ErrorType>)> * = nullptr,
+        std::enable_if_t<std::is_convertible_v<Err, ErrorType>> * = nullptr>
+    constexpr unexpected(unexpected<Err> const & error)
+        : m_error(error.m_error)
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by moving the value of another @p unexpected of different error type
+     */
+    template<
+        typename Err,
+        std::enable_if_t<!(
+            std::is_constructible_v<ErrorType, Err> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err>> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const> &&
+            !std::is_convertible_v<unexpected<Err> &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err>, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const, ErrorType>)> * = nullptr,
+        std::enable_if_t<!std::is_convertible_v<Err, ErrorType>> * = nullptr>
+    constexpr explicit unexpected(unexpected<Err> && error)
+        : m_error(std::move(error.m_error))
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by moving the value of another @p unexpected of different error type
+     */
+    template<
+        typename Err,
+        std::enable_if_t<!(
+            std::is_constructible_v<ErrorType, Err> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err>> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const> &&
+            !std::is_convertible_v<unexpected<Err> &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err>, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const, ErrorType>)> * = nullptr,
+        std::enable_if_t<std::is_convertible_v<Err, ErrorType>> * = nullptr>
+    constexpr unexpected(unexpected<Err> && error)
+        : m_error(std::move(error.m_error))
+    {
+    }
+
+    /**
+     * @brief Get the error value contained in this @p unexpected instance
+     */
+    constexpr ErrorType const & value() const &
+    {
+      return m_error;
+    }
+
+    /**
+     * @brief Get the error value contained in this @p unexpected instance
+     */
+    constexpr ErrorType & value() &
+    {
+      return m_error;
+    }
+
+    /**
+     * @brief Get the error value contained in this @p unexpected instance
+     */
+    constexpr ErrorType && value() &&
+    {
+      return std::move(m_error);
+    }
+
+    /**
+     * @brief Get the error value contained in this @p unexpected instance
+     */
+    constexpr ErrorType const && value() const &&
+    {
+      return std::move(m_error);
+    }
+
+    /**
+     * @brief Swap the error value of this @p unexpected instance with the one of @p other
+     */
+    void swap(unexpected & other) noexcept(std::is_nothrow_swappable_v<ErrorType>)
+    {
+      using std::swap;
+      swap(m_error, other.m_error);
+    }
+
+    template<typename ErrorType1, typename ErrorType2>
+    friend constexpr bool operator==(unexpected<ErrorType1> const & lhs, unexpected<ErrorType2> const & rhs);
+
+    template<typename ErrorType1, typename ErrorType2>
+    friend constexpr bool operator!=(unexpected<ErrorType1> const & lhs, unexpected<ErrorType2> const & rhs);
+
+    template<
+        typename Err,
+        std::enable_if_t<std::is_swappable_v<Err>> *>
+    friend void swap(unexpected<Err> & lhs, unexpected<Err> & rhs);
+
+  private:
+    ErrorType m_error;
+  };
+
+  template<typename ErrorType>
+  unexpected(ErrorType)->unexpected<ErrorType>;
+
+  /**
+ * @brief Compare two @p unexpected instances for equality
+ */
+  template<typename ErrorType1, typename ErrorType2>
+  constexpr bool operator==(unexpected<ErrorType1> const & lhs, unexpected<ErrorType2> const & rhs)
+  {
+    return lhs.m_error == rhs.m_error;
+  }
+
+  /**
+ * @brief Compare two @p unexpected instances for inequality
+ */
+  template<typename ErrorType1, typename ErrorType2>
+  constexpr bool operator!=(unexpected<ErrorType1> const & lhs, unexpected<ErrorType2> const & rhs)
+  {
+    return lhs.m_error != rhs.m_error;
+  }
+
+  /**
+ * @brief Swap the error values of two @p unexpected instances
+ */
+  template<
+      typename Err,
+      std::enable_if_t<std::is_swappable_v<Err>> * = nullptr>
+  void swap(unexpected<Err> & lhs, unexpected<Err> & rhs)
+  {
+    lhs.swap(rhs);
+  }
+
+  /**
+ * @brief A tag type for @p unexpected
+ */
+  struct unexpect_t
+  {
+    explicit unexpect_t() = default;
+  };
+
+  /**
+ * @brief A tap for @p unexpected
+ */
+  inline constexpr unexpect_t unexpect{};
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/filesystem.hpp b/source/include/wanda/filesystem.hpp
new file mode 100644
index 0000000..1975bc5
--- /dev/null
+++ b/source/include/wanda/filesystem.hpp
@@ -0,0 +1,39 @@
+/**
+ * @file   filesystem.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_FILESYSTEM_HPP
+#define WANDA_FILESYSTEM_HPP
+
+#include <filesystem>
+#include <optional>
+#include <vector>
+
+namespace wanda
+{
+  /**
+   * @brief Covenience alias for path lists
+   */
+  using path_list = std::vector<std::filesystem::path>;
+
+  /**
+   * @brief The default scan filter, allowing only regular files to pass
+   */
+  constexpr inline auto default_filter = [](std::filesystem::path const & path) {
+    return is_regular_file(path);
+  };
+
+  /**
+   * @brief Scan the given folder for files
+   */
+  std::optional<path_list> scan(std::filesystem::path folder, bool(filter)(std::filesystem::path const &) = default_filter);
+
+  /**
+   * @brief Pick a random path from the given list
+   */
+  std::filesystem::path random_pick(path_list const & paths);
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/keyed.hpp b/source/include/wanda/keyed.hpp
new file mode 100644
index 0000000..58f17ad
--- /dev/null
+++ b/source/include/wanda/keyed.hpp
@@ -0,0 +1,28 @@
+/**
+ * @file   keyed.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_KEYED_HPP
+#define WANDA_KEYED_HPP
+
+namespace wanda
+{
+  /**
+   * @brief A tag type to prevent construction of a type without a factory
+   */
+  template<typename Derived>
+  struct keyed
+  {
+  protected:
+    struct key
+    {
+    };
+
+    explicit keyed(key) {}
+  };
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/logging.hpp b/source/include/wanda/logging.hpp
new file mode 100644
index 0000000..b3c1665
--- /dev/null
+++ b/source/include/wanda/logging.hpp
@@ -0,0 +1,35 @@
+/**
+ * @file   logging.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_LOGGING_HPP
+#define WANDA_LOGGING_HPP
+
+#include <spdlog/sinks/null_sink.h>
+#include <spdlog/spdlog.h>
+
+#include <memory>
+
+namespace wanda
+{
+  /**
+   * @brief A covenience alias to represent a handle for a logger
+   */
+  using logger_ptr = std::shared_ptr<spdlog::logger>;
+
+  /**
+   * @brief Initialize the shared logger
+   * 
+   * @note The logger will only ever be initialized once, even if this function is called multiple times
+   */
+  void initialize_logger(spdlog::sink_ptr sink = std::make_shared<spdlog::sinks::null_sink_st>());
+
+  /**
+   * @brief Get the shared logger
+   */
+  logger_ptr get_logger();
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/magic.hpp b/source/include/wanda/magic.hpp
new file mode 100644
index 0000000..fcb153e
--- /dev/null
+++ b/source/include/wanda/magic.hpp
@@ -0,0 +1,58 @@
+#ifndef WANDA_MAGIC_HPP
+#define WANDA_MAGIC_HPP
+
+#include <magic.h>
+
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <type_traits>
+
+namespace wanda
+{
+  struct magic
+  {
+    struct closer
+    {
+      auto operator()(magic_t handle) const noexcept -> void
+      {
+        magic_close(handle);
+      }
+    };
+
+    enum struct mime_type
+    {
+      unknown,
+      image_jpeg,
+      image_png,
+    };
+
+    magic()
+        : m_handle{magic_open(MAGIC_MIME_TYPE)}
+    {
+      magic_load(m_handle.get(), nullptr);
+    }
+
+    auto type(std::filesystem::path path) -> mime_type
+    {
+      auto magic_type = std::string{magic_file(m_handle.get(), path.native().c_str())};
+
+      if (magic_type == "image/jpeg")
+      {
+        return mime_type::image_jpeg;
+      }
+      else if (magic_type == "image/png")
+      {
+        return mime_type::image_png;
+      }
+
+      return mime_type::unknown;
+    }
+
+  private:
+    std::unique_ptr<std::remove_pointer_t<magic_t>, closer> m_handle;
+  };
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/message.hpp b/source/include/wanda/message.hpp
new file mode 100644
index 0000000..866408f
--- /dev/null
+++ b/source/include/wanda/message.hpp
@@ -0,0 +1,83 @@
+/**
+ * @file   message.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_MESSAGE_HPP
+#define WANDA_MESSAGE_HPP
+
+#include <cstddef>
+#include <istream>
+#include <optional>
+#include <string>
+
+namespace wanda
+{
+  inline namespace v1
+  {
+    /**
+     * @brief The version argument for the hello message reflecting the current version
+     */
+    auto constexpr message_argument_hello = "1.0.0";
+  }  // namespace v1
+
+  /**
+   * @brief A tag to mark messages originating from the controller
+   */
+  auto constexpr message_source_controller = "C";
+
+  /**
+   * @brief A tag to mark messages originating from the daemon
+   */
+  auto constexpr message_source_daemon = "D";
+
+  /**
+   * @brief The command of the hello message
+   */
+  auto constexpr message_command_hello = "HELLO";
+
+  /**
+   * @brief A control protocol message, consisting of a @p source, @p command, and @p arguments
+   */
+  struct message
+  {
+    /**
+     * @brief Serialize this message into a string
+     */
+    explicit operator std::string() const;
+
+    /**
+     * @brief Get the size of the message as if it was serialized
+     */
+    std::size_t size() const;
+
+    /**
+     * @brief The source of the message
+     */
+    std::string source;
+
+    /**
+     * @brief The command of the message
+     */
+    std::string command;
+
+    /**
+     * @brief The arguments of the message command
+     */
+    std::optional<std::string> argument;
+  };
+
+  /**
+   * @brief Deserialize a message from the given stream
+   */
+  std::istream & operator>>(std::istream & in, message & message);
+
+  /**
+   * @brief Serialize a message to the given stream
+   */
+  std::ostream & operator<<(std::ostream & out, message const & message);
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/optional.hpp b/source/include/wanda/optional.hpp
new file mode 100644
index 0000000..da3774c
--- /dev/null
+++ b/source/include/wanda/optional.hpp
@@ -0,0 +1,65 @@
+/**
+ * @file   optional.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_OPTIONAL_HPP
+#define WANDA_OPTIONAL_HPP
+
+#include <optional>
+
+namespace wanda::std_ext
+{
+  /**
+   * @brief A type to represent a computation that could fail
+   */
+  struct failable
+  {
+    /**
+     * @brief A factory to create a successful computation
+     */
+    constexpr static auto success() { return failable{false}; }
+
+    /**
+     * @brief A factory to create a failed computation
+     */
+    constexpr static auto failure() { return failable{true}; }
+
+    /**
+     * @brief Execute the given handler if the computation failed
+     */
+    template<typename Handler>
+    constexpr void operator||(Handler handler) const
+    {
+      if (m_failed)
+      {
+        handler();
+      }
+    }
+
+  private:
+    constexpr explicit failable(bool failed)
+        : m_failed{failed} {};
+    bool const m_failed;
+  };
+
+  /**
+   * @brief Unwrap the given optional object, if present, and pass it to the handler
+   * 
+   * @return A successful computation iff. the object was present, a failed computation otherwise.
+   */
+  template<typename ObjectType, typename HandlerType>
+  auto with(std::optional<ObjectType> && object, HandlerType handler)
+  {
+    if (object)
+    {
+      handler(object.value());
+      return failable::success();
+    }
+    return failable::failure();
+  }
+
+}  // namespace wanda::std_ext
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/setting.hpp b/source/include/wanda/setting.hpp
new file mode 100644
index 0000000..1721651
--- /dev/null
+++ b/source/include/wanda/setting.hpp
@@ -0,0 +1,156 @@
+/**
+ * @file    setting.hpp
+ * @author  Felix Morgner (felix.morgner@gmail.com)
+ * @since   1.0.0
+ */
+
+#ifndef WANDA_setting_HPP
+#define WANDA_setting_HPP
+
+#include <wanda/deferred_failure.hpp>
+#include <wanda/type_wrapper.hpp>
+
+#include <gio/gio.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace wanda
+{
+  struct setting;
+
+  /**
+   * @brief A convenience type to represent setting keys
+   */
+  using key = type_wrapper<std::string, struct KeyTag>;
+
+  namespace literals
+  {
+    /**
+     * @brief UDL to create setting keys
+     */
+    key operator""_key(char const * str, std::size_t len);
+
+    /**
+     * @brief UDL to create setting schemas
+     */
+    std::optional<setting> operator""_setting(char const * str, std::size_t lent);
+  }  // namespace literals
+
+  /**
+   * @brief A simple wrapper for GSettings Schemas
+   */
+  struct setting
+  {
+    struct entry
+    {
+      using value_type = std::variant<std::monostate, bool, std::int32_t, std::int64_t, std::uint32_t, std::uint64_t, double, std::string, std::vector<std::string>>;
+
+      /**
+       * @brief Get the value of the settings entry
+       */
+      value_type operator*() const;
+
+      /**
+       * @brief Assign the given @p value to the settings entry
+       * 
+       * @returns @p true iff. the value could be successfully assigned
+       */
+      template<typename Type>
+      bool operator=(Type value)
+      {
+        struct setting_applier
+        {
+          setting_applier(GSettings * setting, gchar const * key, Type value) noexcept
+              : m_result{[&] {
+                if constexpr (std::is_same_v<Type, bool>)
+                {
+                  return g_settings_set_boolean(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::int32_t>)
+                {
+                  return g_settings_set_int(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::int64_t>)
+                {
+                  return g_settings_set_int64(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::uint32_t>)
+                {
+                  return g_settings_set_uint(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::uint64_t>)
+                {
+                  return g_settings_set_uint64(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, double>)
+                {
+                  return g_settings_set_double(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::string>)
+                {
+                  return g_settings_set_string(setting, key, value.c_str());
+                }
+                else if constexpr (std::is_same_v<Type, std::vector<std::string>>)
+                {
+                  auto temp = std::vector<gchar const *>{value.size() + 1};
+                  std::transform(value.begin(), value.end(), temp.begin(), [](auto const & str) { return str.c_str(); });
+                  return g_settings_set_strv(setting, key, temp.data());
+                }
+              }()}
+          {
+          }
+
+          ~setting_applier()
+          {
+            g_settings_sync();
+          }
+
+          operator bool() const
+          {
+            return m_result;
+          }
+
+        private:
+          gboolean const m_result;
+        };
+
+        return setting_applier{m_settings.get(), m_key.get().c_str(), value};
+      }
+
+    private:
+      entry(setting const & schema, key key);
+
+      std::unique_ptr<GSettings, decltype(&g_object_unref)> m_settings;
+
+      key m_key;
+
+      friend setting;
+    };
+
+    /**
+     * @brief Get the entry for the given key
+     * 
+     * @return An <code>std::optional</code> wrapping the entry associated with
+     * the given key, or an empty <code>std::optional</code> if the desired key
+     * does not exist in the setting's schema.
+     */
+    std::optional<entry> operator[](key key) const;
+
+  private:
+    explicit setting(GSettingsSchema * schema);
+
+    std::unique_ptr<GSettingsSchema, decltype(&g_settings_schema_unref)> m_schema;
+
+    friend std::optional<setting> literals::operator""_setting(char const *, std::size_t);
+  };
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/type_wrapper.hpp b/source/include/wanda/type_wrapper.hpp
new file mode 100644
index 0000000..12684cb
--- /dev/null
+++ b/source/include/wanda/type_wrapper.hpp
@@ -0,0 +1,47 @@
+/**
+ * @file   type_wrapper.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_TYPE_WRAPPER_HPP
+#define WANDA_TYPE_WRAPPER_HPP
+
+#include <utility>
+
+namespace wanda
+{
+  /**
+   * @brief A type to create a distinct type based on an existing type
+   * 
+   * @tparam InnerType The type to wrap
+   * @tparam TagType   A tag type to identify the distinct type
+   */
+  template<typename InnerType, typename TagType>
+  struct type_wrapper
+  {
+    /**
+     * @brief Construct a new type wrapper object
+     */
+    explicit type_wrapper(InnerType value)
+        : m_value{std::move(value)}
+    {
+    }
+
+    /**
+     * @brief Retrieve the wrapped value with its original type
+     */
+    constexpr explicit operator InnerType const &() const { return get(); }
+
+    /**
+     * @brief Retrieve the wrapped value with its original type
+     */
+    constexpr InnerType const & get() const { return m_value; }
+
+  private:
+    InnerType m_value;
+  };
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/wallpaper.hpp b/source/include/wanda/wallpaper.hpp
new file mode 100644
index 0000000..0cad473
--- /dev/null
+++ b/source/include/wanda/wallpaper.hpp
@@ -0,0 +1,24 @@
+/**
+ * @file   wallpaper.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_WALLPAPER_HPP
+#define WANDA_WALLPAPER_HPP
+
+#include <spdlog/sinks/null_sink.h>
+#include <spdlog/spdlog.h>
+
+#include <filesystem>
+#include <memory>
+
+namespace wanda
+{
+  /**
+   * @brief Set the wallpaper to the file specified by the given path
+   */
+  void set_wallpaper(std::filesystem::path wallpaper);
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/include/wanda/xdg.hpp b/source/include/wanda/xdg.hpp
new file mode 100644
index 0000000..bc138fa
--- /dev/null
+++ b/source/include/wanda/xdg.hpp
@@ -0,0 +1,40 @@
+/**
+ * @file   xdg.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_XDG_HPP
+#define WANDA_XDG_HPP
+
+#include <wanda/environment.hpp>
+
+#include <cstddef>
+#include <filesystem>
+#include <type_traits>
+
+namespace wanda
+{
+  /**
+   * @brief An @p enum to represet the standardized XDG directories
+   */
+  enum struct xdg_directory : std::underlying_type_t<std::byte>
+  {
+    data_home,
+    config_home,
+    cache_home,
+    runtime_dir,
+  };
+
+  /**
+   * @brief Get the name of the environment variable associated with the given XDG directory
+   */
+  std::string xdg_variable(xdg_directory directory);
+
+  /**
+   * @brief Get the path to the given @p directory given the provided @p environment
+   */
+  std::filesystem::path xdg_path_for(xdg_directory directory, environment const & environment);
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/source/src/wanda/command.cpp b/source/src/wanda/command.cpp
new file mode 100644
index 0000000..960c52b
--- /dev/null
+++ b/source/src/wanda/command.cpp
@@ -0,0 +1,47 @@
+#include <wanda/command.hpp>
+
+namespace wanda
+{
+  std::optional<message> command::message() const
+  {
+    using namespace std::string_literals;
+    auto const command = [this] {
+      switch (id)
+      {
+        case command_id::change:
+          return "CHANGE"s;
+        default:
+          return ""s;
+      }
+    }();
+
+    auto argument_string = std::string{};
+    for (int index = 0ul; index < arguments.size(); ++index)
+    {
+      argument_string += (index) ? "," + arguments[index] : arguments[index];
+    }
+
+    if (command.empty())
+    {
+      return std::nullopt;
+    }
+
+    return wanda::message{"C", command, argument_string};
+  }
+
+  std::optional<command> make_command(message message)
+  {
+    if (message.command == "CHANGE")
+    {
+      return {{command_id::change}};
+    }
+
+    return std::nullopt;
+  }
+
+  command make_change_command()
+  {
+    return {command_id::change};
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/commander.cpp b/source/src/wanda/commander.cpp
new file mode 100644
index 0000000..85fc68a
--- /dev/null
+++ b/source/src/wanda/commander.cpp
@@ -0,0 +1,77 @@
+#include <wanda/commander.hpp>
+#include <wanda/logging.hpp>
+#include <wanda/message.hpp>
+#include <wanda/optional.hpp>
+
+#include <spdlog/fmt/ostr.h>
+
+namespace wanda
+{
+  commander::commander(asio::io_service & service, std::filesystem::path socket, listener & listener)
+      : m_service{service}
+      , m_endpoint{socket.string()}
+      , m_socket{service}
+      , m_listener{listener}
+  {
+  }
+
+  void commander::start()
+  {
+    m_socket.async_connect(m_endpoint, [&](auto const & error) {
+      if (error)
+      {
+        get_logger()->error("error while connecting to control interface: '{}'", error.message());
+      }
+      else
+      {
+        get_logger()->info("establishing connection to wanda deamon");
+        m_connection = wanda::make_control_connection(std::move(m_socket));
+        m_connection->add(this);
+        m_connection->start();
+        m_connection->send({message_source_controller, message_command_hello, message_argument_hello});
+      }
+    });
+  }
+
+  void commander::stop()
+  {
+    get_logger()->info("closing control connection");
+    m_connection->close();
+  }
+
+  void commander::send(command command)
+  {
+    using namespace wanda::std_ext;
+
+    if (!m_connection || m_connection->current_state() != control_connection::state::established)
+    {
+      get_logger()->error("tried to send command without an established connection");
+      m_listener.on_error(*this, "tried to send command without an established connection");
+      return;
+    }
+
+    with(command.message(), [&](auto const & message) { m_connection->send(message); }) ||
+        [&] { get_logger()->error("unknown command"); };
+  }
+
+  void commander::on_error(control_connection::pointer connection, std::error_code error)
+  {
+    get_logger()->error("control interface communication error: '{}'", error.message());
+  }
+
+  void commander::on_received(wanda::control_connection::pointer connection, message message)
+  {
+    if (auto state = connection->current_state(); message.command == "HELLO" && state == control_connection::state::fresh)
+    {
+      get_logger()->info("connection to wanda deamon successfully established");
+      connection->update(control_connection::state::established);
+      m_listener.on_connected(*this);
+    }
+    else
+    {
+      get_logger()->error("unexpected message: '{}'", message);
+      m_listener.on_error(*this, "unexpected message '" + static_cast<std::string>(message) + '\'');
+    }
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/control_connection.cpp b/source/src/wanda/control_connection.cpp
new file mode 100644
index 0000000..40e29f3
--- /dev/null
+++ b/source/src/wanda/control_connection.cpp
@@ -0,0 +1,120 @@
+#include <wanda/control_connection.hpp>
+
+#include <limits>
+
+namespace wanda
+{
+  control_connection::pointer make_control_connection(control_connection::protocol::socket && socket)
+  {
+    return std::make_shared<control_connection>(control_connection::key{}, std::move(socket));
+  }
+
+  control_connection::control_connection(control_connection::key key, control_connection::protocol::socket socket)
+      : keyed{key}
+      , m_socket{std::move(socket)}
+  {
+  }
+
+  bool control_connection::add(listener * listener)
+  {
+    auto [_, inserted] = m_listeners.insert(listener);
+    return inserted;
+  }
+
+  bool control_connection::remove(listener * listener)
+  {
+    return m_listeners.erase(listener);
+  }
+
+  void control_connection::start()
+  {
+    if (m_state == state::unknown)
+    {
+      m_state = state::fresh;
+      perform_read();
+    }
+  }
+
+  void control_connection::send(message message)
+  {
+    m_output << message << '\n';
+    asio::async_write(m_socket, m_out, asio::transfer_exactly(message.size() + 1), [that = shared_from_this(), this](auto const & error, auto const length) {
+      if (error)
+      {
+        // TODO: Handle error
+      }
+      else
+      {
+        m_out.consume(length);
+      }
+    });
+  }
+
+  void control_connection::close()
+  {
+    if (auto error = std::error_code{}; m_socket.cancel(error))
+    {
+      for (auto & listener : m_listeners)
+      {
+        listener->on_error(shared_from_this(), error);
+      }
+    }
+
+    if (auto error = std::error_code{}; m_socket.close(error))
+    {
+      for (auto & listener : m_listeners)
+      {
+        listener->on_error(shared_from_this(), error);
+      }
+    }
+
+    for (auto & listener : m_listeners)
+    {
+      listener->on_close(shared_from_this());
+    }
+    m_listeners.clear();
+  }
+
+  void control_connection::update(state state)
+  {
+    m_state = state;
+  }
+
+  control_connection::state control_connection::current_state() const
+  {
+    return m_state;
+  }
+
+  void control_connection::perform_read()
+  {
+    asio::async_read_until(m_socket, m_in, '\n', [that = shared_from_this(), this](auto const & error, auto const length) {
+      if (error)
+      {
+        for (auto & listener : m_listeners)
+        {
+          listener->on_error(shared_from_this(), error);
+        }
+        close();
+      }
+      else
+      {
+        auto msg = message{};
+        m_input >> msg;
+        if (!m_input)
+        {
+          m_input.ignore(std::numeric_limits<std::streamsize>::max());
+          m_input.clear();
+        }
+        else
+        {
+          for (auto & listener : m_listeners)
+          {
+            listener->on_received(shared_from_this(), msg);
+          }
+        }
+        perform_read();
+      }
+    });
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/control_interface.cpp b/source/src/wanda/control_interface.cpp
new file mode 100644
index 0000000..c008920
--- /dev/null
+++ b/source/src/wanda/control_interface.cpp
@@ -0,0 +1,154 @@
+#include <wanda/control_interface.hpp>
+#include <wanda/logging.hpp>
+#include <wanda/optional.hpp>
+
+#include <spdlog/fmt/ostr.h>
+
+#include <unistd.h>
+
+#include <algorithm>
+#include <iterator>
+#include <string>
+#include <system_error>
+#include <utility>
+
+namespace wanda
+{
+  // 'socket_deleter' implementation
+
+  socket_deleter::~socket_deleter()
+  {
+    if (std::filesystem::exists(path))
+    {
+      std::filesystem::remove(path);
+    }
+  }
+
+  // 'control_interface' implementation
+
+  control_interface::control_interface(control_interface::key key, asio::io_service & service, control_interface::protocol::endpoint endpoint, listener & listener)
+      : keyed{key}
+      , m_service{service}
+      , m_endpoint{std::move(endpoint)}
+      , m_socket{m_service}
+      , m_acceptor{m_service}
+      , m_listener{listener}
+  {
+  }
+
+  std::error_code control_interface::start()
+  {
+    if (auto error = std::error_code{}; m_acceptor.open(m_endpoint.protocol(), error))
+    {
+      return error;
+    }
+
+    if (auto error = std::error_code{}; m_acceptor.bind(m_endpoint, error))
+    {
+      return error;
+    }
+
+    if (auto error = std::error_code{}; m_acceptor.listen(128, error))
+    {
+      return error;
+    }
+    else
+    {
+      perform_accept();
+      return error;
+    }
+  }
+
+  std::error_code control_interface::shutdown()
+  {
+    for (auto & connection : m_connections)
+    {
+      connection->close();
+    }
+
+    auto error = std::error_code{};
+    return m_acceptor.close(error);
+  }
+
+  void control_interface::perform_accept()
+  {
+    m_acceptor.async_accept(m_socket, [that = shared_from_this(), this](auto const & error) {
+      if (error && error != asio::error::operation_aborted)
+      {
+        get_logger()->error("failed to accept connection because '{}'", error);
+      }
+      else
+      {
+        get_logger()->info("new incoming controller connection");
+        auto [connection, inserted] = m_connections.insert(make_control_connection(std::move(m_socket)));
+        if (inserted)
+        {
+          (*connection)->add(this);
+          (*connection)->start();
+        }
+        perform_accept();
+      }
+    });
+  }
+
+  void control_interface::on_close(control_connection::pointer connection)
+  {
+    if (static_cast<char>(connection->current_state()) >= static_cast<char>(control_connection::state::established))
+    {
+      get_logger()->info("controller connection closed");
+    }
+    else
+    {
+      get_logger()->info("controller connection aborted before it could be established");
+    }
+    m_connections.erase(connection);
+  }
+
+  void control_interface::on_received(control_connection::pointer connection, message message)
+  {
+    using namespace wanda::std_ext;
+
+    if (m_connections.find(connection) == m_connections.cend())
+    {
+      get_logger()->error("received message from an unknown connection");
+      return;
+    }
+
+    if (message.source != message_source_controller)
+    {
+      get_logger()->error("received a deamon message");
+      return;
+    }
+
+    if (auto state = connection->current_state(); message.command == message_command_hello && state == control_connection::state::fresh)
+    {
+      get_logger()->info("controller connection established");
+      if (message.argument.has_value())
+      {
+        get_logger()->info("remote controller version '{}'", *message.argument);
+      }
+      connection->send({message_source_daemon, message_command_hello, message_argument_hello});
+      connection->update(control_connection::state::established);
+    }
+    else
+    {
+      with(make_command(message), [&](auto const & command) {
+        m_listener.on_received(*this, command);
+      }) ||
+          [&] { get_logger()->warn("ignoring unknown message '{}'", message); };
+    }
+  }
+
+  control_interface::pointer make_interface(asio::io_service & service, std::filesystem::path socket, control_interface::listener & listener)
+  {
+    if (std::filesystem::exists(socket))
+    {
+      get_logger()->error("socket '{}' exists", socket.native());
+      return {};
+    }
+
+    control_interface::protocol::endpoint endpoint{socket.string()};
+    return std::make_shared<control_interface>(control_interface::key{}, service, std::move(endpoint), listener);
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/environment.cpp b/source/src/wanda/environment.cpp
new file mode 100644
index 0000000..533a5f5
--- /dev/null
+++ b/source/src/wanda/environment.cpp
@@ -0,0 +1,71 @@
+#include <wanda/environment.hpp>
+
+#include <string>
+
+namespace wanda
+{
+  environment::environment(char const * const * env)
+  {
+    if (!env)
+    {
+      return;
+    }
+
+    std::string buffer{};
+    for (; *env != nullptr; ++env)
+    {
+      buffer = *env;
+      int split_point = buffer.find('=');
+      if (split_point != std::string::npos)
+      {
+        m_cache[buffer.substr(0, split_point)] = buffer.substr(split_point + 1);
+      }
+    }
+  }
+
+  std::string & environment::operator[](std::string const & variable)
+  {
+    return m_cache[variable];
+  }
+
+  std::string const & environment::operator[](std::string const & variable) const
+  {
+    static std::string const empty{};
+    if (auto needle = m_cache.find(variable); needle != cend())
+    {
+      return needle->second;
+    }
+    return empty;
+  }
+
+  environment::iterator environment::begin()
+  {
+    return m_cache.begin();
+  }
+
+  environment::const_iterator environment::begin() const
+  {
+    return m_cache.begin();
+  }
+
+  environment::const_iterator environment::cbegin() const
+  {
+    return m_cache.cbegin();
+  }
+
+  environment::iterator environment::end()
+  {
+    return m_cache.end();
+  }
+
+  environment::const_iterator environment::end() const
+  {
+    return m_cache.end();
+  }
+
+  environment::const_iterator environment::cend() const
+  {
+    return m_cache.cend();
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/filesystem.cpp b/source/src/wanda/filesystem.cpp
new file mode 100644
index 0000000..4da30b1
--- /dev/null
+++ b/source/src/wanda/filesystem.cpp
@@ -0,0 +1,31 @@
+#include <wanda/filesystem.hpp>
+
+#include <random>
+#include <ranges>
+
+namespace wanda
+{
+  std::optional<path_list> scan(std::filesystem::path source, bool(filter)(std::filesystem::path const &))
+  {
+    if (!std::filesystem::is_directory(source))
+    {
+      return std::nullopt;
+    }
+    auto entries = std::filesystem::recursive_directory_iterator{source};
+    auto result = path_list{};
+    for (auto & entry : entries | std::views::filter(filter))
+    {
+      result.push_back(entry.path());
+    }
+    return result;
+  }
+
+  std::filesystem::path random_pick(path_list const & paths)
+  {
+    static auto generator = std::mt19937{std::random_device{}()};
+    auto distribution = std::uniform_int_distribution<std::size_t>{0, paths.size() - 1};
+
+    return paths[distribution(generator)];
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/logging.cpp b/source/src/wanda/logging.cpp
new file mode 100644
index 0000000..8c61953
--- /dev/null
+++ b/source/src/wanda/logging.cpp
@@ -0,0 +1,21 @@
+#include <wanda/logging.hpp>
+
+namespace wanda
+{
+  std::function<void(spdlog::sink_ptr)> initializer = [](spdlog::sink_ptr sink) {
+    spdlog::register_logger(std::make_shared<spdlog::logger>("wanda", sink));
+    initializer = [](auto) {};
+  };
+
+  void initialize_logger(spdlog::sink_ptr sink)
+  {
+    initializer(sink);
+  }
+
+  logger_ptr get_logger()
+  {
+    initialize_logger();
+    return spdlog::get("wanda");
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/message.cpp b/source/src/wanda/message.cpp
new file mode 100644
index 0000000..978b7c4
--- /dev/null
+++ b/source/src/wanda/message.cpp
@@ -0,0 +1,75 @@
+#include <wanda/message.hpp>
+
+#include <ios>
+#include <iterator>
+#include <sstream>
+
+namespace wanda
+{
+  message::operator std::string() const
+  {
+    std::ostringstream buffer{};
+    buffer << source
+           << ':'
+           << command;
+    if (argument.has_value())
+    {
+      buffer << ':' << *argument;
+    }
+    return buffer.str();
+  }
+
+  std::size_t message::size() const
+  {
+    return static_cast<std::string>(*this).size();
+  }
+
+  template<typename InputIt, typename OutputIt, typename UnaryPredicate>
+  OutputIt copy_until(InputIt first, InputIt last, OutputIt out, UnaryPredicate predicate)
+  {
+    while (first != last && !predicate(*first))
+    {
+      *out++ = *first++;
+    }
+    return out;
+  }
+
+  std::istream & operator>>(std::istream & in, message & message)
+  {
+    auto pos = std::istream_iterator<char>{in};
+    auto end = std::istream_iterator<char>{};
+    auto buffer = std::string{};
+
+    copy_until(pos, end, std::back_inserter(buffer), [](auto const & c) { return c == ':'; });
+    if (in.eof() || buffer.size() != 1)
+    {
+      in.setstate(std::ios_base::failbit);
+      return in;
+    }
+    message.source = buffer;
+
+    buffer.clear();
+    copy_until(++pos, end, std::back_inserter(buffer), [](auto const & c) { return c == ':'; });
+    if (in.eof())
+    {
+      in.setstate(std::ios_base::failbit);
+    }
+    message.command = buffer;
+
+    buffer.clear();
+    copy(++pos, end, std::back_inserter(buffer));
+    if (buffer.size())
+    {
+      message.argument = std::optional{std::move(buffer)};
+    }
+
+    in.clear(in.rdstate() ^ std::ios_base::failbit);
+    return in;
+  }
+
+  std::ostream & operator<<(std::ostream & out, message const & message)
+  {
+    return out << static_cast<std::string>(message);
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/setting.cpp b/source/src/wanda/setting.cpp
new file mode 100644
index 0000000..f0cf7a7
--- /dev/null
+++ b/source/src/wanda/setting.cpp
@@ -0,0 +1,102 @@
+#include <wanda/setting.hpp>
+
+#include <algorithm>
+#include <type_traits>
+
+namespace wanda
+{
+  // UDL implementations
+
+  key literals::operator""_key(char const * str, std::size_t len)
+  {
+    return key{{str, len}};
+  }
+
+  std::optional<setting> literals::operator""_setting(char const * str, std::size_t len)
+  {
+    auto source = g_settings_schema_source_get_default();
+    if (!source)
+    {
+      return std::nullopt;
+    }
+
+    auto schema = g_settings_schema_source_lookup(source, str, true);
+    if (!schema)
+    {
+      return std::nullopt;
+    }
+
+    return setting{schema};
+  }
+
+  // 'setting' implementation
+
+  setting::setting(GSettingsSchema * schema)
+      : m_schema{schema, &g_settings_schema_unref}
+  {
+  }
+
+  std::optional<setting::entry> setting::operator[](key key) const
+  {
+    if (!g_settings_schema_has_key(m_schema.get(), key.get().c_str()))
+    {
+      return std::nullopt;
+    }
+
+    return setting::entry{*this, std::move(key)};
+  }
+
+  // 'setting::entry' implementation
+
+  setting::entry::entry(setting const & setting, key key)
+      : m_settings{g_settings_new(g_settings_schema_get_id(setting.m_schema.get())), &g_object_unref}
+      , m_key{key.get()}
+  {
+  }
+
+  setting::entry::value_type setting::entry::operator*() const
+  {
+    auto value = std::unique_ptr<GVariant, decltype(&g_variant_unref)>{g_settings_get_value(m_settings.get(), m_key.get().c_str()), &g_variant_unref};
+    auto raw = value.get();
+
+    if (g_variant_is_of_type(raw, G_VARIANT_TYPE_BOOLEAN))
+    {
+      return static_cast<bool>(g_variant_get_boolean(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_INT32))
+    {
+      return static_cast<std::int32_t>(g_variant_get_int32(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_INT64))
+    {
+      return static_cast<std::int64_t>(g_variant_get_int64(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_UINT32))
+    {
+      return static_cast<std::uint32_t>(g_variant_get_uint32(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_UINT64))
+    {
+      return static_cast<std::uint64_t>(g_variant_get_uint64(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_DOUBLE))
+    {
+      return static_cast<double>(g_variant_get_double(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_STRING))
+    {
+      auto size = gsize{};
+      auto string = g_variant_get_string(raw, &size);
+      return std::string{string, size};
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_STRING_ARRAY))
+    {
+      auto length = gsize{};
+      auto data = g_variant_get_strv(raw, &length);
+      return std::vector<std::string>{data, data + length};
+    }
+
+    return {};
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/wallpaper.cpp b/source/src/wanda/wallpaper.cpp
new file mode 100644
index 0000000..7d4c7d5
--- /dev/null
+++ b/source/src/wanda/wallpaper.cpp
@@ -0,0 +1,95 @@
+#include <wanda/logging.hpp>
+#include <wanda/magic.hpp>
+#include <wanda/optional.hpp>
+#include <wanda/setting.hpp>
+#include <wanda/wallpaper.hpp>
+
+#include <boost/gil.hpp>
+#include <boost/gil/extension/io/jpeg.hpp>
+#include <boost/gil/extension/io/png.hpp>
+#include <boost/gil/extension/numeric/resample.hpp>
+#include <boost/gil/extension/numeric/sampler.hpp>
+
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+
+namespace wanda
+{
+  namespace
+  {
+    auto magic_instance = magic{};
+
+    auto load_image(std::filesystem::path wallpaper)
+    {
+      auto image = boost::gil::rgb8_image_t{};
+
+      switch (magic_instance.type(wallpaper))
+      {
+        case magic::mime_type::image_jpeg:
+          boost::gil::read_and_convert_image(wallpaper.native(), image, boost::gil::jpeg_tag{});
+          break;
+        case magic::mime_type::image_png:
+          boost::gil::read_and_convert_image(wallpaper.native(), image, boost::gil::png_tag{});
+          break;
+      }
+
+      return image;
+
+      // // auto source_view = ;
+
+      // return fmt::format("#{:02X}{:02X}{:02X}",
+      //                    static_cast<uint8_t>(std::sqrt((at_c<0>(pixel64) / image.size()))),
+      //                    static_cast<uint8_t>(std::sqrt((at_c<1>(pixel64) / image.size()))),
+      //                    static_cast<uint8_t>(std::sqrt((at_c<2>(pixel64) / image.size()))));
+    }
+
+    auto average_colors(boost::gil::rgb8_image_t image)
+    {
+      auto accumulator = boost::gil::rgb64f_pixel_t{};
+      auto view = const_view(image);
+
+      std::ranges::for_each(view, [&](auto const & source_pixel) {
+        at_c<0>(accumulator) += std::pow(boost::gil::at_c<0>(source_pixel), 2);
+        at_c<1>(accumulator) += std::pow(boost::gil::at_c<1>(source_pixel), 2);
+        at_c<2>(accumulator) += std::pow(boost::gil::at_c<2>(source_pixel), 2);
+      });
+
+      at_c<0>(accumulator) = std::sqrt(at_c<0>(accumulator) / view.size());
+      at_c<1>(accumulator) = std::sqrt(at_c<1>(accumulator) / view.size());
+      at_c<2>(accumulator) = std::sqrt(at_c<2>(accumulator) / view.size());
+
+      return accumulator;
+    }
+
+    //
+  }  // namespace
+
+  void set_wallpaper(std::filesystem::path wallpaper)
+  {
+    using namespace wanda::literals;
+    using namespace wanda::std_ext;
+    using namespace std::string_literals;
+
+    auto image = load_image(wallpaper);
+    auto color = average_colors(std::move(image));
+    auto hexstring = fmt::format("#{:02X}{:02X}{:02X}",
+                                 static_cast<std::uint8_t>(at_c<0>(color)),
+                                 static_cast<std::uint8_t>(at_c<1>(color)),
+                                 static_cast<std::uint8_t>(at_c<2>(color)));
+
+    with("org.gnome.desktop.background"_setting, [&](auto & setting) {
+      with(setting["primary-color"_key], [&](auto & value) {
+        value = hexstring;
+      });
+      with(setting["picture-uri"_key], [&](auto & value) {
+        value = "file://" + wallpaper.native();
+      }) ||
+          [&] { get_logger()->error("invalid settings key"); };
+    }) ||
+        [&] { get_logger()->error("invalid setting"); };
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/src/wanda/wandac.cpp b/source/src/wanda/wandac.cpp
new file mode 100644
index 0000000..1873ef4
--- /dev/null
+++ b/source/src/wanda/wandac.cpp
@@ -0,0 +1,94 @@
+#include <wanda/command.hpp>
+#include <wanda/commander.hpp>
+#include <wanda/environment.hpp>
+#include <wanda/logging.hpp>
+#include <wanda/xdg.hpp>
+
+#include <asio.hpp>
+#include <lyra/lyra.hpp>
+#include <spdlog/sinks/stdout_color_sinks.h>
+#include <spdlog/spdlog.h>
+
+#include <cstdlib>
+#include <filesystem>
+#include <iostream>
+#include <memory>
+
+struct cli
+{
+  std::string command{};
+  bool help{};
+
+  lyra::cli_parser parser{};
+
+  auto parse(int argc, char const * const * argv, std::ostream & error)
+  {
+    parser |= lyra::arg{command, "command"}("The command to send to the deamon").required() |
+              lyra::help(help);
+
+    auto result = parser.parse({argc, argv});
+
+    if (!result)
+    {
+      error << "Error while processing command line arguments: "
+            << result.message()
+            << '\n'
+            << parser
+            << '\n';
+      return false;
+    }
+
+    return true;
+  }
+};
+
+struct listener : wanda::commander::listener
+{
+  listener(::cli & cli, asio::io_service & service)
+      : m_cli{cli}
+      , m_service{service}
+  {
+  }
+
+  void on_connected(wanda::commander & commander) override
+  {
+    if (m_cli.command == "change")
+    {
+      commander.send(wanda::make_change_command());
+      m_service.post([&]{
+        commander.stop();
+      });
+    }
+  }
+
+private:
+  ::cli & m_cli;
+  asio::io_service & m_service;
+};
+
+int main(int argc, char const * const * argv)
+{
+  auto cli = ::cli{};
+  if (!cli.parse(argc, argv, std::cerr))
+  {
+    return EXIT_FAILURE;
+  }
+  else if (cli.help)
+  {
+    std::cout << cli.parser << '\n';
+    return EXIT_SUCCESS;
+  }
+
+  wanda::initialize_logger(std::make_shared<spdlog::sinks::stderr_color_sink_st>());
+
+  auto interface = wanda::xdg_path_for(wanda::xdg_directory::runtime_dir, wanda::environment{}) / ".wanda_interface";
+  auto service = asio::io_service{};
+  auto listener = ::listener{cli, service};
+
+  auto commander = wanda::commander{service, interface, listener};
+
+  wanda::get_logger()->info("trying to connect to wanda control interface on '{}'", interface.native());
+  commander.start();
+
+  service.run();
+}
diff --git a/source/src/wanda/wandad.cpp b/source/src/wanda/wandad.cpp
new file mode 100644
index 0000000..8579a83
--- /dev/null
+++ b/source/src/wanda/wandad.cpp
@@ -0,0 +1,146 @@
+#include <wanda/command.hpp>
+#include <wanda/control_interface.hpp>
+#include <wanda/environment.hpp>
+#include <wanda/filesystem.hpp>
+#include <wanda/logging.hpp>
+#include <wanda/optional.hpp>
+#include <wanda/setting.hpp>
+#include <wanda/wallpaper.hpp>
+#include <wanda/xdg.hpp>
+
+#include <asio.hpp>
+#include <lyra/lyra.hpp>
+#include <spdlog/sinks/stdout_color_sinks.h>
+
+#include <csignal>
+#include <cstdlib>
+#include <iostream>
+#include <set>
+#include <string>
+
+namespace
+{
+  constexpr auto image_filter = [](auto const & path) {
+    static auto const extensions = std::set<std::filesystem::path>{
+        std::filesystem::path{".jpg"},
+        std::filesystem::path{".png"},
+    };
+
+    if (!std::filesystem::is_regular_file(path))
+    {
+      return false;
+    }
+
+    return extensions.find(path.extension()) != extensions.cend();
+  };
+
+  struct cli
+  {
+    std::string wallpaper_directory{};
+    bool help{};
+
+    lyra::cli_parser parser{};
+
+    auto parse(int argc, char const * const * argv, std::ostream & error)
+    {
+      parser |= lyra::arg{wallpaper_directory, "directory"}("The wallpaper source directory").required() |
+                lyra::help(help);
+
+      auto result = parser.parse({argc, argv});
+
+      if (!result)
+      {
+        error << "Error while processing command line arguments: "
+              << result.message()
+              << '\n'
+              << parser
+              << '\n';
+        return false;
+      }
+
+      return true;
+    }
+  };
+
+  struct listener : wanda::control_interface::listener
+  {
+    listener(std::vector<std::filesystem::path> const & wallpapers)
+        : m_wallpapers{wallpapers}
+    {
+    }
+
+    void on_received(wanda::control_interface & interface, wanda::command command) override
+    {
+      switch (command.id)
+      {
+        case wanda::command_id::change: {
+          auto wallpaper = wanda::random_pick(m_wallpapers);
+          wanda::get_logger()->info("changing wallpaper to '{}'", wallpaper.native());
+          wanda::set_wallpaper(wallpaper);
+          break;
+        }
+        default:
+          wanda::get_logger()->error("received unknown command '{}'", static_cast<int>(command.id));
+      }
+    }
+
+  private:
+    std::vector<std::filesystem::path> const & m_wallpapers;
+  };
+
+}  // namespace
+
+int main(int argc, char const * const * argv)
+{
+  using namespace wanda::std_ext;
+
+  auto cli = ::cli{};
+  if (!cli.parse(argc, argv, std::cerr))
+  {
+    return EXIT_FAILURE;
+  }
+  else if (cli.help)
+  {
+    std::cout << cli.parser << '\n';
+    return EXIT_SUCCESS;
+  }
+
+  wanda::initialize_logger(std::make_shared<spdlog::sinks::stdout_color_sink_st>());
+  wanda::get_logger()->info("wanda is starting up");
+
+  with(wanda::scan({cli.wallpaper_directory}, image_filter), [&](auto const & list) {
+    auto service = asio::io_service{};
+    auto socket_path = wanda::xdg_path_for(wanda::xdg_directory::runtime_dir, wanda::environment{}) / ".wanda_interface";
+
+    wanda::get_logger()->info("starting control interface on '{}'", socket_path.native());
+    auto listener = ::listener{list};
+    auto interface = wanda::make_interface(service, socket_path, listener);
+
+    if (!interface)
+    {
+      wanda::get_logger()->error("failed to start control interface");
+      return;
+    }
+
+    if (interface->start())
+    {
+      return;
+    }
+
+    auto signals = asio::signal_set{service, SIGINT, SIGTERM};
+    signals.async_wait([&](auto const & error, auto const signal) {
+      if (!error)
+      {
+        wanda::get_logger()->info("Received signal {}. terminating...", signal);
+        interface->shutdown();
+        service.stop();
+      }
+    });
+
+    auto wallpaper = wanda::random_pick(list);
+    wanda::set_wallpaper(wallpaper);
+
+    service.run();
+  }) ||
+      [&] { wanda::get_logger()->error("wallpaper directory does not exist"); };
+}
diff --git a/source/src/wanda/xdg.cpp b/source/src/wanda/xdg.cpp
new file mode 100644
index 0000000..d49e53f
--- /dev/null
+++ b/source/src/wanda/xdg.cpp
@@ -0,0 +1,46 @@
+#include <wanda/xdg.hpp>
+
+#include <unistd.h>
+
+namespace wanda
+{
+  std::string xdg_variable(xdg_directory directory)
+  {
+    switch (directory)
+    {
+      case xdg_directory::data_home:
+        return "XDG_DATA_HOME";
+      case xdg_directory::config_home:
+        return "XDG_CONFIG_HOME";
+      case xdg_directory::cache_home:
+        return "XDG_CACHE_HOME";
+      case xdg_directory::runtime_dir:
+        return "XDG_RUNTIME_DIR";
+    }
+    return "XDG_INVALID_PATH";
+  }
+
+  std::filesystem::path xdg_path_for(xdg_directory directory, environment const & environment)
+  {
+    if (auto path = environment[xdg_variable(directory)]; !path.empty())
+    {
+      return path;
+    }
+
+    auto home = std::filesystem::path{environment["HOME"]};
+    switch (directory)
+    {
+      case xdg_directory::data_home:
+        return home / ".local/share";
+      case xdg_directory::config_home:
+        return home / ".config";
+      case xdg_directory::cache_home:
+        return home / ".cache";
+      case xdg_directory::runtime_dir:
+        return std::filesystem::path{"/run/user"} / std::to_string(::getuid());
+    }
+
+    return "";
+  }
+
+}  // namespace wanda
\ No newline at end of file
diff --git a/source/tests/wanda/driver.cpp b/source/tests/wanda/driver.cpp
new file mode 100644
index 0000000..e0dd7c8
--- /dev/null
+++ b/source/tests/wanda/driver.cpp
@@ -0,0 +1,23 @@
+#include "cute/cute.h"
+#include "cute/cute_runner.h"
+#include "cute/tap_listener.h"
+
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace wanda::test
+{
+    std::pair<cute::suite, std::string> suite();
+}
+
+int main(int argc, char const *const *argv)
+{
+    auto listener = cute::tap_listener<>{std::cout};
+    auto runner = cute::makeRunner(listener, argc, argv);
+    auto suite = wanda::test::suite();
+    return !runner(suite.first, suite.second.c_str());
+}
\ No newline at end of file
diff --git a/source/tests/wanda/test_suite_xdg.cpp b/source/tests/wanda/test_suite_xdg.cpp
new file mode 100644
index 0000000..70597f7
--- /dev/null
+++ b/source/tests/wanda/test_suite_xdg.cpp
@@ -0,0 +1,96 @@
+#include <wanda/xdg.hpp>
+
+#include <cute/cute.h>
+
+#include <unistd.h>
+
+#include <filesystem>
+#include <string>
+#include <utility>
+
+namespace wanda::test
+{
+
+namespace
+{
+    char const * home_only_environment[2] = {"HOME=/home/cute"};
+    char const * xdg_data_home_environment[2] = {"XDG_DATA_HOME=/home/cute/xdg_data_home"};
+    char const * xdg_config_home_environment[2] = {"XDG_CONFIG_HOME=/home/cute/xdg_config_home"};
+    char const * xdg_cache_home_environment[2] = {"XDG_CACHE_HOME=/home/cute/xdg_cache_home"};
+    char const * xdg_runtime_dir_environment[2] = {"XDG_RUNTIME_DIR=/home/cute/xdg_runtime_dir"};
+}
+
+void test_xdg_variables()
+{
+    ASSERT_EQUAL("XDG_DATA_HOME", xdg_variable(xdg_directory::data_home));
+    ASSERT_EQUAL("XDG_CONFIG_HOME", xdg_variable(xdg_directory::config_home));
+    ASSERT_EQUAL("XDG_CACHE_HOME", xdg_variable(xdg_directory::cache_home));
+    ASSERT_EQUAL("XDG_RUNTIME_DIR", xdg_variable(xdg_directory::runtime_dir));
+}
+
+void test_xdg_path_for_data_home_without_xdg_data_home_in_environment()
+{
+    auto env = environment{home_only_environment};
+    ASSERT_EQUAL("/home/cute/.local/share", xdg_path_for(xdg_directory::data_home, env));
+}
+
+void test_xdg_path_for_data_home_with_xdg_data_home_in_environment()
+{
+    auto env = environment{xdg_data_home_environment};
+    ASSERT_EQUAL("/home/cute/xdg_data_home", xdg_path_for(xdg_directory::data_home, env));
+}
+
+void test_xdg_path_for_config_home_without_xdg_config_home_in_environment()
+{
+    auto env = environment{home_only_environment};
+    ASSERT_EQUAL("/home/cute/.config", xdg_path_for(xdg_directory::config_home, env));
+}
+
+void test_xdg_path_for_config_home_with_xdg_config_home_in_environment()
+{
+    auto env = environment{xdg_config_home_environment};
+    ASSERT_EQUAL("/home/cute/xdg_config_home", xdg_path_for(xdg_directory::config_home, env));
+}
+
+void test_xdg_path_for_cache_home_without_xdg_cache_home_in_environment()
+{
+    auto env = environment{home_only_environment};
+    ASSERT_EQUAL("/home/cute/.cache", xdg_path_for(xdg_directory::cache_home, env));
+}
+
+void test_xdg_path_for_cache_home_with_xdg_cache_home_in_environment()
+{
+    auto env = environment{xdg_cache_home_environment};
+    ASSERT_EQUAL("/home/cute/xdg_cache_home", xdg_path_for(xdg_directory::cache_home, env));
+}
+
+void test_xdg_path_for_runtime_dir_without_xdg_runtime_dir_in_environment()
+{
+    auto env = environment{home_only_environment};
+    auto expected = std::filesystem::path{"/run/user"} / std::to_string(::getuid());
+    ASSERT_EQUAL(expected, xdg_path_for(xdg_directory::runtime_dir, env));
+}
+
+void test_xdg_path_for_runtime_dir_with_xdg_runtime_dir_in_environment()
+{
+    auto env = environment{xdg_runtime_dir_environment};
+    ASSERT_EQUAL("/home/cute/xdg_runtime_dir", xdg_path_for(xdg_directory::runtime_dir, env));
+}
+
+std::pair<cute::suite, std::string> suite()
+{
+    return std::make_pair(cute::suite{
+                              CUTE(test_xdg_variables),
+                              CUTE(test_xdg_path_for_data_home_without_xdg_data_home_in_environment),
+                              CUTE(test_xdg_path_for_data_home_with_xdg_data_home_in_environment),
+                              CUTE(test_xdg_path_for_config_home_without_xdg_config_home_in_environment),
+                              CUTE(test_xdg_path_for_config_home_with_xdg_config_home_in_environment),
+                              CUTE(test_xdg_path_for_cache_home_without_xdg_cache_home_in_environment),
+                              CUTE(test_xdg_path_for_cache_home_with_xdg_cache_home_in_environment),
+                              CUTE(test_xdg_path_for_runtime_dir_without_xdg_runtime_dir_in_environment),
+                              CUTE(test_xdg_path_for_runtime_dir_with_xdg_runtime_dir_in_environment),
+                          },
+                          "XDG Utilities");
+}
+
+} // namespace wanda
\ No newline at end of file