132 files changed, 8109 insertions, 6138 deletions
diff --git a/sway/commands.c b/sway/commands.c
index b09a04c7..8d003dfa 100644
--- a/sway/commands.c
+++ b/sway/commands.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809
 #include <ctype.h>
 #include <stdarg.h>
 #include <stdlib.h>
@@ -46,11 +45,13 @@ static const struct cmd_handler handlers[] = {
        { "assign", cmd_assign },
        { "bar", cmd_bar },
        { "bindcode", cmd_bindcode },
+        { "bindgesture", cmd_bindgesture },
        { "bindswitch", cmd_bindswitch },
        { "bindsym", cmd_bindsym },
        { "client.background", cmd_client_noop },
        { "client.focused", cmd_client_focused },
        { "client.focused_inactive", cmd_client_focused_inactive },
+        { "client.focused_tab_title", cmd_client_focused_tab_title },
        { "client.placeholder", cmd_client_noop },
        { "client.unfocused", cmd_client_unfocused },
        { "client.urgent", cmd_client_urgent },
@@ -91,6 +92,7 @@ static const struct cmd_handler handlers[] = {
        { "titlebar_border_thickness", cmd_titlebar_border_thickness },
        { "titlebar_padding", cmd_titlebar_padding },
        { "unbindcode", cmd_unbindcode },
+        { "unbindgesture", cmd_unbindgesture },
        { "unbindswitch", cmd_unbindswitch },
        { "unbindsym", cmd_unbindsym },
        { "workspace", cmd_workspace },
@@ -101,6 +103,7 @@ static const struct cmd_handler handlers[] = {
 static const struct cmd_handler config_handlers[] = {
        { "default_orientation", cmd_default_orientation },
        { "include", cmd_include },
+        { "primary_selection", cmd_primary_selection },
        { "swaybg_command", cmd_swaybg_command },
        { "swaynag_command", cmd_swaynag_command },
        { "workspace_layout", cmd_workspace_layout },
@@ -144,7 +147,7 @@ static int handler_compare(const void *_a, const void *_b) {
        return strcasecmp(a->command, b->command);
 }
-const struct cmd_handler *find_handler(char *line,
+const struct cmd_handler *find_handler(const char *line,
                const struct cmd_handler *handlers, size_t handlers_size) {
        if (!handlers || !handlers_size) {
                return NULL;
@@ -377,10 +380,13 @@ struct cmd_results *config_command(char *exec, char **new_block) {
        sway_log(SWAY_INFO, "Config command: %s", exec);
        const struct cmd_handler *handler = find_core_handler(argv[0]);
        if (!handler || !handler->handle) {
-                const char *error = handler
+                if (handler) {
-                        ? "Command '%s' is shimmed, but unimplemented"
+                        results = cmd_results_new(CMD_INVALID,
-                        : "Unknown/invalid command '%s'";
+                                "Command '%s' is shimmed, but unimplemented", argv[0]);
-                results = cmd_results_new(CMD_INVALID, error, argv[0]);
+                } else {
+                        results = cmd_results_new(CMD_INVALID,
+                                "Unknown/invalid command '%s'", argv[0]);
+                }
                goto cleanup;
        }
@@ -406,6 +412,7 @@ struct cmd_results *config_command(char *exec, char **new_block) {
                                && handler->handle != cmd_bindsym
                                && handler->handle != cmd_bindcode
                                && handler->handle != cmd_bindswitch
+                                && handler->handle != cmd_bindgesture
                                && handler->handle != cmd_set
                                && handler->handle != cmd_for_window
                                && (*argv[i] == '\"' || *argv[i] == '\'')) {
@@ -465,34 +472,6 @@ struct cmd_results *config_commands_command(char *exec) {
                goto cleanup;
        }
-        enum command_context context = 0;
-        struct {
-                char *name;
-                enum command_context context;
-        } context_names[] = {
-                { "config", CONTEXT_CONFIG },
-                { "binding", CONTEXT_BINDING },
-                { "ipc", CONTEXT_IPC },
-                { "criteria", CONTEXT_CRITERIA },
-                { "all", CONTEXT_ALL },
-        };
-        for (int i = 1; i < argc; ++i) {
-                size_t j;
-                for (j = 0; j < sizeof(context_names) / sizeof(context_names[0]); ++j) {
-                        if (strcmp(context_names[j].name, argv[i]) == 0) {
-                                break;
-                        }
-                }
-                if (j == sizeof(context_names) / sizeof(context_names[0])) {
-                        results = cmd_results_new(CMD_INVALID,
-                                        "Invalid command context %s", argv[i]);
-                        goto cleanup;
-                }
-                context |= context_names[j].context;
-        }
        results = cmd_results_new(CMD_SUCCESS, NULL);
 cleanup:
@@ -509,14 +488,10 @@ struct cmd_results *cmd_results_new(enum cmd_status status,
        }
        results->status = status;
        if (format) {
-                char *error = malloc(256);
                va_list args;
                va_start(args, format);
-                if (error) {
+                results->error = vformat_str(format, args);
-                        vsnprintf(error, 256, format, args);
-                }
                va_end(args);
-                results->error = error;
        } else {
                results->error = NULL;
        }
diff --git a/sway/commands/assign.c b/sway/commands/assign.c
index 976bc3cc..bf95cf00 100644
--- a/sway/commands/assign.c
+++ b/sway/commands/assign.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdio.h>
 #include <string.h>
 #include "sway/commands.h"
@@ -17,7 +16,7 @@ struct cmd_results *cmd_assign(int argc, char **argv) {
        char *err_str = NULL;
        struct criteria *criteria = criteria_parse(argv[0], &err_str);
        if (!criteria) {
-                error = cmd_results_new(CMD_INVALID, err_str);
+                error = cmd_results_new(CMD_INVALID, "%s", err_str);
                free(err_str);
                return error;
        }
diff --git a/sway/commands/bar.c b/sway/commands/bar.c
index 8571d282..635e895b 100644
--- a/sway/commands/bar.c
+++ b/sway/commands/bar.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809
 #include <stdio.h>
 #include <string.h>
 #include <strings.h>
@@ -73,12 +72,10 @@ struct cmd_results *cmd_bar(int argc, char **argv) {
                }
                ++argv; --argc;
        } else if (config->reading && !config->current_bar) {
-                int len = snprintf(NULL, 0, "bar-%d", config->bars->length) + 1;
+                id = format_str("bar-%d", config->bars->length);
-                id = malloc(len * sizeof(char));
                if (!id) {
                        return cmd_results_new(CMD_FAILURE, "Unable to allocate bar id");
                }
-                snprintf(id, len, "bar-%d", config->bars->length);
        } else if (!config->reading && strcmp(argv[0], "mode") != 0 &&
                        strcmp(argv[0], "hidden_state") != 0) {
                if (is_subcommand(argv[0])) {
diff --git a/sway/commands/bar/bind.c b/sway/commands/bar/bind.c
index b4b5bc45..8a837e3f 100644
--- a/sway/commands/bar/bind.c
+++ b/sway/commands/bar/bind.c
@@ -96,7 +96,7 @@ static struct cmd_results *bar_cmd_bind(int argc, char **argv, bool code,
        }
        if (message) {
                free_bar_binding(binding);
-                error = cmd_results_new(CMD_INVALID, message);
+                error = cmd_results_new(CMD_INVALID, "%s", message);
                free(message);
                return error;
        } else if (!binding->button) {
diff --git a/sway/commands/bar/font.c b/sway/commands/bar/font.c
index 891c87af..0c074679 100644
--- a/sway/commands/bar/font.c
+++ b/sway/commands/bar/font.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "log.h"
diff --git a/sway/commands/bar/hidden_state.c b/sway/commands/bar/hidden_state.c
index 1f08a5d2..7b38831e 100644
--- a/sway/commands/bar/hidden_state.c
+++ b/sway/commands/bar/hidden_state.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include <strings.h>
 #include "sway/commands.h"
@@ -54,7 +53,7 @@ struct cmd_results *bar_cmd_hidden_state(int argc, char **argv) {
        }
        const char *state = argv[0];
-        if (config->reading) {
+        if (config->current_bar) {
                error = bar_set_hidden_state(config->current_bar, state);
        } else {
                const char *id = argc == 2 ? argv[1] : NULL;
diff --git a/sway/commands/bar/icon_theme.c b/sway/commands/bar/icon_theme.c
index 6ac07843..fee21709 100644
--- a/sway/commands/bar/icon_theme.c
+++ b/sway/commands/bar/icon_theme.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "config.h"
 #include "sway/commands.h"
diff --git a/sway/commands/bar/id.c b/sway/commands/bar/id.c
index a9a61743..46cf4ca9 100644
--- a/sway/commands/bar/id.c
+++ b/sway/commands/bar/id.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "log.h"
diff --git a/sway/commands/bar/mode.c b/sway/commands/bar/mode.c
index 8b3fb275..d69e910b 100644
--- a/sway/commands/bar/mode.c
+++ b/sway/commands/bar/mode.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include <strings.h>
 #include "sway/commands.h"
@@ -58,7 +57,7 @@ struct cmd_results *bar_cmd_mode(int argc, char **argv) {
        }
        const char *mode = argv[0];
-        if (config->reading) {
+        if (config->current_bar) {
                error = bar_set_mode(config->current_bar, mode);
        } else {
                const char *id = argc == 2 ? argv[1] : NULL;
diff --git a/sway/commands/bar/output.c b/sway/commands/bar/output.c
index cac1d056..51730176 100644
--- a/sway/commands/bar/output.c
+++ b/sway/commands/bar/output.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdbool.h>
 #include <string.h>
 #include "sway/commands.h"
diff --git a/sway/commands/bar/position.c b/sway/commands/bar/position.c
index b207de0b..94f530ec 100644
--- a/sway/commands/bar/position.c
+++ b/sway/commands/bar/position.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include <strings.h>
 #include "sway/commands.h"
diff --git a/sway/commands/bar/separator_symbol.c b/sway/commands/bar/separator_symbol.c
index 6737d4d2..50e9a873 100644
--- a/sway/commands/bar/separator_symbol.c
+++ b/sway/commands/bar/separator_symbol.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "log.h"
diff --git a/sway/commands/bar/tray_bind.c b/sway/commands/bar/tray_bind.c
index 243834ba..3dc9bc4c 100644
--- a/sway/commands/bar/tray_bind.c
+++ b/sway/commands/bar/tray_bind.c
@@ -26,7 +26,7 @@ static struct cmd_results *tray_bind(int argc, char **argv, bool code) {
        }
        if (message) {
                free(binding);
-                error = cmd_results_new(CMD_INVALID, message);
+                error = cmd_results_new(CMD_INVALID, "%s", message);
                free(message);
                return error;
        } else if (!binding->button) {
diff --git a/sway/commands/bar/tray_output.c b/sway/commands/bar/tray_output.c
index eb3b486e..679facf7 100644
--- a/sway/commands/bar/tray_output.c
+++ b/sway/commands/bar/tray_output.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "config.h"
 #include "sway/commands.h"
diff --git a/sway/commands/bind.c b/sway/commands/bind.c
index 4c67b3ce..268f2855 100644
--- a/sway/commands/bind.c
+++ b/sway/commands/bind.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <libevdev/libevdev.h>
 #include <linux/input-event-codes.h>
 #include <string.h>
@@ -47,7 +46,7 @@ static bool binding_switch_compare(struct sway_switch_binding *binding_a,
        if (binding_a->type != binding_b->type) {
                return false;
        }
-        if (binding_a->state != binding_b->state) {
+        if (binding_a->trigger != binding_b->trigger) {
                return false;
        }
        if ((binding_a->flags & BINDING_LOCKED) !=
@@ -127,7 +126,7 @@ static struct cmd_results *identify_key(const char* name, bool first_key,
                if (!button) {
                        if (message) {
                                struct cmd_results *error =
-                                        cmd_results_new(CMD_INVALID, message);
+                                        cmd_results_new(CMD_INVALID, "%s", message);
                                free(message);
                                return error;
                        } else {
@@ -143,7 +142,7 @@ static struct cmd_results *identify_key(const char* name, bool first_key,
                if (!button) {
                        if (message) {
                                struct cmd_results *error =
-                                        cmd_results_new(CMD_INVALID, message);
+                                        cmd_results_new(CMD_INVALID, "%s", message);
                                free(message);
                                return error;
                        } else {
@@ -182,7 +181,7 @@ static struct cmd_results *identify_key(const char* name, bool first_key,
                        uint32_t button = get_mouse_bindsym(name, &message);
                        if (message) {
                                struct cmd_results *error =
-                                        cmd_results_new(CMD_INVALID, message);
+                                        cmd_results_new(CMD_INVALID, "%s", message);
                                free(message);
                                return error;
                        } else if (button) {
@@ -372,6 +371,7 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv,
                                        strlen("--input-device=")) == 0) {
                        free(binding->input);
                        binding->input = strdup(argv[0] + strlen("--input-device="));
+                        strip_quotes(binding->input);
                } else if (strcmp("--no-warn", argv[0]) == 0) {
                        warn = false;
                } else if (strcmp("--no-repeat", argv[0]) == 0) {
@@ -538,7 +538,7 @@ struct cmd_results *cmd_bind_or_unbind_switch(int argc, char **argv,
                free_switch_binding(binding);
                return cmd_results_new(CMD_FAILURE,
                                "Invalid %s command (expected binding with the form "
-                                "<switch>:<state>)", bindtype, argc);
+                                "<switch>:<state>)", bindtype);
        }
        if (strcmp(split->items[0], "tablet") == 0) {
                binding->type = WLR_SWITCH_TYPE_TABLET_MODE;
@@ -548,20 +548,21 @@ struct cmd_results *cmd_bind_or_unbind_switch(int argc, char **argv,
                free_switch_binding(binding);
                return cmd_results_new(CMD_FAILURE,
                                "Invalid %s command (expected switch binding: "
-                                "unknown switch %s)", bindtype, split->items[0]);
+                                "unknown switch %s)", bindtype,
+                                (const char *)split->items[0]);
        }
        if (strcmp(split->items[1], "on") == 0) {
-                binding->state = WLR_SWITCH_STATE_ON;
+                binding->trigger = SWAY_SWITCH_TRIGGER_ON;
        } else if (strcmp(split->items[1], "off") == 0) {
-                binding->state = WLR_SWITCH_STATE_OFF;
+                binding->trigger = SWAY_SWITCH_TRIGGER_OFF;
        } else if (strcmp(split->items[1], "toggle") == 0) {
-                binding->state = WLR_SWITCH_STATE_TOGGLE;
+                binding->trigger = SWAY_SWITCH_TRIGGER_TOGGLE;
        } else {
                free_switch_binding(binding);
                return cmd_results_new(CMD_FAILURE,
                                "Invalid %s command "
-                                "(expected switch state: unknown state %d)",
+                                "(expected switch state: unknown state %s)",
-                                bindtype, split->items[0]);
+                                bindtype, (const char *)split->items[1]);
        }
        list_free_items_and_destroy(split);
diff --git a/sway/commands/client.c b/sway/commands/client.c
index dd0694df..fd2ac7a8 100644
--- a/sway/commands/client.c
+++ b/sway/commands/client.c
@@ -5,9 +5,8 @@
 #include "sway/tree/container.h"
 #include "util.h"
-static void rebuild_textures_iterator(struct sway_container *con, void *data) {
+static void container_update_iterator(struct sway_container *con, void *data) {
-        container_update_marks_textures(con);
+        container_update(con);
-        container_update_title_textures(con);
 }
 static struct cmd_results *handle_command(int argc, char **argv, char *cmd_name,
@@ -18,6 +17,12 @@ static struct cmd_results *handle_command(int argc, char **argv, char *cmd_name,
                return error;
        }
+        if (argc > 3 && strcmp(cmd_name, "client.focused_tab_title") == 0) {
+                sway_log(SWAY_ERROR,
+                                "Warning: indicator and child_border colors have no effect for %s",
+                                cmd_name);
+        }
        struct border_colors colors = {0};
        const char *ind_hex = argc > 3 ? argv[3] : default_indicator;
        const char *child_hex = argc > 4 ? argv[4] : argv[1];  // def to background
@@ -45,12 +50,7 @@ static struct cmd_results *handle_command(int argc, char **argv, char *cmd_name,
        memcpy(class, &colors, sizeof(struct border_colors));
        if (config->active) {
-                root_for_each_container(rebuild_textures_iterator, NULL);
+                root_for_each_container(container_update_iterator, NULL);
-                for (int i = 0; i < root->outputs->length; ++i) {
-                        struct sway_output *output = root->outputs->items[i];
-                        output_damage_whole(output);
-                }
        }
        return cmd_results_new(CMD_SUCCESS, NULL);
@@ -80,3 +80,13 @@ struct cmd_results *cmd_client_noop(int argc, char **argv) {
        sway_log(SWAY_INFO, "Warning: %s is ignored by sway", argv[-1]);
        return cmd_results_new(CMD_SUCCESS, NULL);
 }
+struct cmd_results *cmd_client_focused_tab_title(int argc, char **argv) {
+        struct cmd_results *result =  handle_command(argc, argv,
+                        "client.focused_tab_title",
+                        &config->border_colors.focused_tab_title, "#2e9ef4ff");
+        if (result && result->status == CMD_SUCCESS) {
+                config->has_focused_tab_title = true;
+        }
+        return result;
+}
diff --git a/sway/commands/exec_always.c b/sway/commands/exec_always.c
index fce337d5..8bc1048c 100644
--- a/sway/commands/exec_always.c
+++ b/sway/commands/exec_always.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
@@ -7,6 +6,8 @@
 #include <signal.h>
 #include "sway/commands.h"
 #include "sway/config.h"
+#include "sway/server.h"
+#include "sway/desktop/launcher.h"
 #include "sway/tree/container.h"
 #include "sway/tree/root.h"
 #include "sway/tree/workspace.h"
@@ -24,11 +25,22 @@ struct cmd_results *cmd_exec_validate(int argc, char **argv) {
        return error;
 }
+static void export_xdga_token(struct launcher_ctx *ctx) {
+        const char *token = launcher_ctx_get_token_name(ctx);
+        setenv("XDG_ACTIVATION_TOKEN", token, 1);
+}
+static void export_startup_id(struct launcher_ctx *ctx) {
+        const char *token = launcher_ctx_get_token_name(ctx);
+        setenv("DESKTOP_STARTUP_ID", token, 1);
+}
 struct cmd_results *cmd_exec_process(int argc, char **argv) {
        struct cmd_results *error = NULL;
        char *cmd = NULL;
+        bool no_startup_id = false;
        if (strcmp(argv[0], "--no-startup-id") == 0) {
-                sway_log(SWAY_INFO, "exec switch '--no-startup-id' not supported, ignored.");
+                no_startup_id = true;
                --argc; ++argv;
                if ((error = checkarg(argc, argv[-1], EXPECTED_AT_LEAST, 1))) {
                        return error;
@@ -50,9 +62,11 @@ struct cmd_results *cmd_exec_process(int argc, char **argv) {
        }
        pid_t pid, child;
+        struct launcher_ctx *ctx = launcher_ctx_create_internal();
        // Fork process
        if ((pid = fork()) == 0) {
                // Fork child process again
+                restore_nofile_limit();
                setsid();
                sigset_t set;
                sigemptyset(&set);
@@ -61,6 +75,12 @@ struct cmd_results *cmd_exec_process(int argc, char **argv) {
                close(fd[0]);
                if ((child = fork()) == 0) {
                        close(fd[1]);
+                        if (ctx) {
+                                export_xdga_token(ctx);
+                        }
+                        if (ctx && !no_startup_id) {
+                                export_startup_id(ctx);
+                        }
                        execlp("sh", "sh", "-c", cmd, (void *)NULL);
                        sway_log_errno(SWAY_ERROR, "execlp failed");
                        _exit(1);
@@ -88,8 +108,12 @@ struct cmd_results *cmd_exec_process(int argc, char **argv) {
        waitpid(pid, NULL, 0);
        if (child > 0) {
                sway_log(SWAY_DEBUG, "Child process created with pid %d", child);
-                root_record_workspace_pid(child);
+                if (ctx != NULL) {
+                        sway_log(SWAY_DEBUG, "Recording workspace for process %d", child);
+                        ctx->pid = child;
+                }
        } else {
+                launcher_ctx_destroy(ctx);
                return cmd_results_new(CMD_FAILURE, "Second fork() failed");
        }
diff --git a/sway/commands/floating_minmax_size.c b/sway/commands/floating_minmax_size.c
index 3a1d606a..e8c24ace 100644
--- a/sway/commands/floating_minmax_size.c
+++ b/sway/commands/floating_minmax_size.c
@@ -23,16 +23,16 @@ static struct cmd_results *handle_command(int argc, char **argv, char *cmd_name,
        char *err;
        int width = (int)strtol(argv[0], &err, 10);
        if (*err) {
-                return cmd_results_new(CMD_INVALID, cmd_name, usage);
+                return cmd_results_new(CMD_INVALID, "%s", usage);
        }
        if (strcmp(argv[1], "x") != 0) {
-                return cmd_results_new(CMD_INVALID, cmd_name, usage);
+                return cmd_results_new(CMD_INVALID, "%s", usage);
        }
        int height = (int)strtol(argv[2], &err, 10);
        if (*err) {
-                return cmd_results_new(CMD_INVALID, cmd_name, usage);
+                return cmd_results_new(CMD_INVALID, "%s", usage);
        }
        *config_width = width;
diff --git a/sway/commands/focus.c b/sway/commands/focus.c
index 6771ca2f..facd82de 100644
--- a/sway/commands/focus.c
+++ b/sway/commands/focus.c
@@ -54,7 +54,7 @@ static bool get_direction_from_next_prev(struct sway_container *container,
        } else {
                return false;
        }
-         
        return true;
 }
@@ -267,6 +267,11 @@ static struct cmd_results *focus_mode(struct sway_workspace *ws,
                new_focus = seat_get_focus_inactive_tiling(seat, ws);
        }
        if (new_focus) {
+                struct sway_container *new_focus_view =
+                        seat_get_focus_inactive_view(seat, &new_focus->node);
+                if (new_focus_view) {
+                        new_focus = new_focus_view;
+                }
                seat_set_focus_container(seat, new_focus);
                // If we're on the floating layer and the floating container area
@@ -280,7 +285,7 @@ static struct cmd_results *focus_mode(struct sway_workspace *ws,
                }
        } else {
                return cmd_results_new(CMD_FAILURE,
-                                "Failed to find a %s container in workspace",
+                                "Failed to find a %s container in workspace.",
                                floating ? "floating" : "tiling");
        }
        return cmd_results_new(CMD_SUCCESS, NULL);
@@ -290,7 +295,7 @@ static struct cmd_results *focus_output(struct sway_seat *seat,
                int argc, char **argv) {
        if (!argc) {
                return cmd_results_new(CMD_INVALID,
-                        "Expected 'focus output <direction|name>'");
+                        "Expected 'focus output <direction|name>'.");
        }
        char *identifier = join_args(argv, argc);
        struct sway_output *output = output_by_name_or_id(identifier);
@@ -300,13 +305,13 @@ static struct cmd_results *focus_output(struct sway_seat *seat,
                if (!parse_direction(identifier, &direction)) {
                        free(identifier);
                        return cmd_results_new(CMD_INVALID,
-                                "There is no output with that name");
+                                "There is no output with that name.");
                }
                struct sway_workspace *ws = seat_get_focused_workspace(seat);
                if (!ws) {
                        free(identifier);
                        return cmd_results_new(CMD_FAILURE,
-                                "No focused workspace to base directions off of");
+                                "No focused workspace to base directions off of.");
                }
                output = output_get_in_direction(ws->output, direction);
@@ -370,10 +375,14 @@ struct cmd_results *cmd_focus(int argc, char **argv) {
        struct sway_seat *seat = config->handler_context.seat;
        if (node->type < N_WORKSPACE) {
                return cmd_results_new(CMD_FAILURE,
-                        "Command 'focus' cannot be used above the workspace level");
+                        "Command 'focus' cannot be used above the workspace level.");
        }
-        if (argc == 0 && container) {
+        if (argc == 0) {
+                if (!container) {
+                        return cmd_results_new(CMD_FAILURE, "No container to focus was specified.");
+                }
                if (container_is_scratchpad_hidden_or_child(container)) {
                        root_scratchpad_show(container);
                }
@@ -446,7 +455,8 @@ struct cmd_results *cmd_focus(int argc, char **argv) {
                return cmd_results_new(CMD_FAILURE, "");
        }
        struct sway_node *next_focus = NULL;
-        if (container_is_floating(container)) {
+        if (container_is_floating(container) &&
+                        container->pending.fullscreen_mode == FULLSCREEN_NONE) {
                next_focus = node_get_in_direction_floating(container, seat, direction);
        } else {
                next_focus = node_get_in_direction_tiling(container, seat, direction, descend);
diff --git a/sway/commands/font.c b/sway/commands/font.c
index c54365b5..9920d03e 100644
--- a/sway/commands/font.c
+++ b/sway/commands/font.c
@@ -1,9 +1,9 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "sway/config.h"
 #include "log.h"
 #include "stringop.h"
+#include <pango/pangocairo.h>
 struct cmd_results *cmd_font(int argc, char **argv) {
        struct cmd_results *error = NULL;
@@ -16,12 +16,34 @@ struct cmd_results *cmd_font(int argc, char **argv) {
        if (strncmp(font, "pango:", 6) == 0) {
                config->pango_markup = true;
                config->font = strdup(font + 6);
+                free(font);
        } else {
                config->pango_markup = false;
-                config->font = strdup(font);
+                config->font = font;
        }
-        free(font);
+        // Parse the font early so we can reject it if it's not valid for pango.
-        config_update_font_height(true);
+        // Also avoids re-parsing each time we render text.
+        PangoFontDescription *font_description = pango_font_description_from_string(config->font);
+        const char *family = pango_font_description_get_family(font_description);
+        if (family == NULL) {
+                pango_font_description_free(font_description);
+                return cmd_results_new(CMD_FAILURE, "Invalid font family.");
+        }
+        const gint size = pango_font_description_get_size(font_description);
+        if (size == 0) {
+                pango_font_description_free(font_description);
+                return cmd_results_new(CMD_FAILURE, "Invalid font size.");
+        }
+        if (config->font_description != NULL) {
+                pango_font_description_free(config->font_description);
+        }
+        config->font_description = font_description;
+        config_update_font_height();
        return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/for_window.c b/sway/commands/for_window.c
index ee9f4647..905e6776 100644
--- a/sway/commands/for_window.c
+++ b/sway/commands/for_window.c
@@ -14,7 +14,7 @@ struct cmd_results *cmd_for_window(int argc, char **argv) {
        char *err_str = NULL;
        struct criteria *criteria = criteria_parse(argv[0], &err_str);
        if (!criteria) {
-                error = cmd_results_new(CMD_INVALID, err_str);
+                error = cmd_results_new(CMD_INVALID, "%s", err_str);
                free(err_str);
                return error;
        }
diff --git a/sway/commands/gesture.c b/sway/commands/gesture.c
new file mode 100644
index 00000000..90a20716
--- /dev/null
+++ b/sway/commands/gesture.c
@@ -0,0 +1,165 @@
+#include "sway/config.h"
+#include "gesture.h"
+#include "log.h"
+#include "stringop.h"
+#include "sway/commands.h"
+void free_gesture_binding(struct sway_gesture_binding *binding) {
+        if (!binding) {
+                return;
+        }
+        free(binding->input);
+        free(binding->command);
+        free(binding);
+}
+/**
+ * Returns true if the bindings have the same gesture type, direction, etc
+ */
+static bool binding_gesture_equal(struct sway_gesture_binding *binding_a,
+                                                                  struct sway_gesture_binding *binding_b) {
+        if (strcmp(binding_a->input, binding_b->input) != 0) {
+                return false;
+        }
+        if (!gesture_equal(&binding_a->gesture, &binding_b->gesture)) {
+                return false;
+        }
+        if ((binding_a->flags & BINDING_EXACT) !=
+                (binding_b->flags & BINDING_EXACT)) {
+                return false;
+        }
+        return true;
+}
+/**
+ * Add gesture binding to config
+ */
+static struct cmd_results *gesture_binding_add(
+                struct sway_gesture_binding *binding,
+                const char *gesturecombo, bool warn) {
+        list_t *mode_bindings = config->current_mode->gesture_bindings;
+        // overwrite the binding if it already exists
+        bool overwritten = false;
+        for (int i = 0; i < mode_bindings->length; ++i) {
+                struct sway_gesture_binding *config_binding = mode_bindings->items[i];
+                if (binding_gesture_equal(binding, config_binding)) {
+                        sway_log(SWAY_INFO, "Overwriting binding '%s' to `%s` from `%s`",
+                                        gesturecombo, binding->command, config_binding->command);
+                        if (warn) {
+                                config_add_swaynag_warning("Overwriting binding"
+                                                "'%s' to `%s` from `%s`",
+                                                gesturecombo, binding->command,
+                                                config_binding->command);
+                        }
+                        free_gesture_binding(config_binding);
+                        mode_bindings->items[i] = binding;
+                        overwritten = true;
+                }
+        }
+        if (!overwritten) {
+                list_add(mode_bindings, binding);
+                sway_log(SWAY_DEBUG, "bindgesture - Bound %s to command `%s`",
+                                gesturecombo, binding->command);
+        }
+        return cmd_results_new(CMD_SUCCESS, NULL);
+}
+/**
+ * Remove gesture binding from config
+ */
+static struct cmd_results *gesture_binding_remove(
+                struct sway_gesture_binding *binding, const char *gesturecombo) {
+        list_t *mode_bindings = config->current_mode->gesture_bindings;
+        for (int i = 0; i < mode_bindings->length; ++i) {
+                struct sway_gesture_binding *config_binding = mode_bindings->items[i];
+                if (binding_gesture_equal(binding, config_binding)) {
+                        free_gesture_binding(config_binding);
+                        free_gesture_binding(binding);
+                        list_del(mode_bindings, i);
+                        sway_log(SWAY_DEBUG, "unbindgesture - Unbound %s gesture",
+                                        gesturecombo);
+                        return cmd_results_new(CMD_SUCCESS, NULL);
+                }
+        }
+        free_gesture_binding(binding);
+        return cmd_results_new(CMD_FAILURE, "Could not find gesture binding `%s`",
+                        gesturecombo);
+}
+/**
+ * Parse and execute bindgesture or unbindgesture command.
+ */
+static struct cmd_results *cmd_bind_or_unbind_gesture(int argc, char **argv, bool unbind) {
+        int minargs = 2;
+        char *bindtype = "bindgesture";
+        if (unbind) {
+                minargs--;
+                bindtype = "unbindgesture";
+        }
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, bindtype, EXPECTED_AT_LEAST, minargs))) {
+                return error;
+        }
+        struct sway_gesture_binding *binding = calloc(1, sizeof(struct sway_gesture_binding));
+        if (!binding) {
+                return cmd_results_new(CMD_FAILURE, "Unable to allocate binding");
+        }
+        binding->input = strdup("*");
+        bool warn = true;
+        // Handle flags
+        while (argc > 0) {
+                if (strcmp("--exact", argv[0]) == 0) {
+                        binding->flags |= BINDING_EXACT;
+                } else if (strcmp("--no-warn", argv[0]) == 0) {
+                        warn = false;
+                } else if (strncmp("--input-device=", argv[0],
+                                        strlen("--input-device=")) == 0) {
+                        free(binding->input);
+                        binding->input = strdup(argv[0] + strlen("--input-device="));
+                } else {
+                        break;
+                }
+                argv++;
+                argc--;
+        }
+        if (argc < minargs) {
+                free(binding);
+                return cmd_results_new(CMD_FAILURE,
+                                "Invalid %s command (expected at least %d "
+                                "non-option arguments, got %d)", bindtype, minargs, argc);
+        }
+        char* errmsg = NULL;
+        if ((errmsg = gesture_parse(argv[0], &binding->gesture))) {
+                free(binding);
+                struct cmd_results *final = cmd_results_new(CMD_FAILURE,
+                                "Invalid %s command (%s)",
+                                bindtype, errmsg);
+                free(errmsg);
+                return final;
+        }
+        if (unbind) {
+                return gesture_binding_remove(binding, argv[0]);
+        }
+        binding->command = join_args(argv + 1, argc - 1);
+        return gesture_binding_add(binding, argv[0], warn);
+}
+struct cmd_results *cmd_bindgesture(int argc, char **argv) {
+        return cmd_bind_or_unbind_gesture(argc, argv, false);
+}
+struct cmd_results *cmd_unbindgesture(int argc, char **argv) {
+        return cmd_bind_or_unbind_gesture(argc, argv, true);
+}
diff --git a/sway/commands/hide_edge_borders.c b/sway/commands/hide_edge_borders.c
index 9a1d8445..43bd6dc8 100644
--- a/sway/commands/hide_edge_borders.c
+++ b/sway/commands/hide_edge_borders.c
@@ -20,7 +20,7 @@ struct cmd_results *cmd_hide_edge_borders(int argc, char **argv) {
        }
        if (!argc) {
-                return cmd_results_new(CMD_INVALID, expected_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
        }
        if (strcmp(argv[0], "none") == 0) {
@@ -38,7 +38,7 @@ struct cmd_results *cmd_hide_edge_borders(int argc, char **argv) {
                config->hide_edge_borders = E_NONE;
                config->hide_edge_borders_smart = ESMART_NO_GAPS;
        } else {
-                return cmd_results_new(CMD_INVALID, expected_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
        }
        config->hide_lone_tab = hide_lone_tab;
diff --git a/sway/commands/inhibit_idle.c b/sway/commands/inhibit_idle.c
index aebc2bf9..6125736a 100644
--- a/sway/commands/inhibit_idle.c
+++ b/sway/commands/inhibit_idle.c
@@ -41,7 +41,7 @@ struct cmd_results *cmd_inhibit_idle(int argc, char **argv) {
                        sway_idle_inhibit_v1_user_inhibitor_destroy(inhibitor);
                } else {
                        inhibitor->mode = mode;
-                        sway_idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
+                        sway_idle_inhibit_v1_check_active();
                }
        } else if (!clear) {
                sway_idle_inhibit_v1_user_inhibitor_register(con->view, mode);
diff --git a/sway/commands/input.c b/sway/commands/input.c
index 77acb671..306c40f7 100644
--- a/sway/commands/input.c
+++ b/sway/commands/input.c
@@ -14,6 +14,7 @@ static const struct cmd_handler input_handlers[] = {
        { "drag", input_cmd_drag },
        { "drag_lock", input_cmd_drag_lock },
        { "dwt", input_cmd_dwt },
+        { "dwtp", input_cmd_dwtp },
        { "events", input_cmd_events },
        { "left_handed", input_cmd_left_handed },
        { "map_from_region", input_cmd_map_from_region },
@@ -24,7 +25,9 @@ static const struct cmd_handler input_handlers[] = {
        { "pointer_accel", input_cmd_pointer_accel },
        { "repeat_delay", input_cmd_repeat_delay },
        { "repeat_rate", input_cmd_repeat_rate },
+        { "rotation_angle", input_cmd_rotation_angle },
        { "scroll_button", input_cmd_scroll_button },
+        { "scroll_button_lock", input_cmd_scroll_button_lock },
        { "scroll_factor", input_cmd_scroll_factor },
        { "scroll_method", input_cmd_scroll_method },
        { "tap", input_cmd_tap },
diff --git a/sway/commands/input/calibration_matrix.c b/sway/commands/input/calibration_matrix.c
index 38749fbb..53fe2c35 100644
--- a/sway/commands/input/calibration_matrix.c
+++ b/sway/commands/input/calibration_matrix.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include <strings.h>
 #include "sway/config.h"
diff --git a/sway/commands/input/dwtp.c b/sway/commands/input/dwtp.c
new file mode 100644
index 00000000..232e2b26
--- /dev/null
+++ b/sway/commands/input/dwtp.c
@@ -0,0 +1,25 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/config.h"
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+#include "util.h"
+struct cmd_results *input_cmd_dwtp(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "dwtp", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        struct input_config *ic = config->handler_context.input_config;
+        if (!ic) {
+                return cmd_results_new(CMD_FAILURE, "No input device defined.");
+        }
+        if (parse_boolean(argv[0], true)) {
+                ic->dwtp = LIBINPUT_CONFIG_DWTP_ENABLED;
+        } else {
+                ic->dwtp = LIBINPUT_CONFIG_DWTP_DISABLED;
+        }
+        return cmd_results_new(CMD_SUCCESS, NULL);
+}
diff --git a/sway/commands/input/events.c b/sway/commands/input/events.c
index 9405181a..08d99bf0 100644
--- a/sway/commands/input/events.c
+++ b/sway/commands/input/events.c
@@ -1,14 +1,19 @@
 #include <limits.h>
 #include <string.h>
 #include <strings.h>
-#include <wlr/backend/libinput.h>
+#include <wlr/config.h>
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "sway/input/input-manager.h"
 #include "log.h"
+#if WLR_HAS_LIBINPUT_BACKEND
+#include <wlr/backend/libinput.h>
+#endif
 static void toggle_supported_send_events_for_device(struct input_config *ic,
                struct sway_input_device *input_device) {
+#if WLR_HAS_LIBINPUT_BACKEND
        struct wlr_input_device *wlr_device = input_device->wlr_device;
        if (!wlr_input_device_is_libinput(wlr_device)) {
                return;
@@ -41,6 +46,7 @@ static void toggle_supported_send_events_for_device(struct input_config *ic,
        }
        ic->send_events = mode;
+#endif
 }
 static int mode_for_name(const char *name) {
@@ -56,6 +62,7 @@ static int mode_for_name(const char *name) {
 static void toggle_select_send_events_for_device(struct input_config *ic,
                struct sway_input_device *input_device, int argc, char **argv) {
+#if WLR_HAS_LIBINPUT_BACKEND
        if (!wlr_input_device_is_libinput(input_device->wlr_device)) {
                return;
        }
@@ -72,6 +79,7 @@ static void toggle_select_send_events_for_device(struct input_config *ic,
                }
        }
        ic->send_events = mode_for_name(argv[index % argc]);
+#endif
 }
 static void toggle_send_events(int argc, char **argv) {
diff --git a/sway/commands/input/map_from_region.c b/sway/commands/input/map_from_region.c
index de00b714..2f8f753d 100644
--- a/sway/commands/input/map_from_region.c
+++ b/sway/commands/input/map_from_region.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdbool.h>
 #include <string.h>
 #include <strings.h>
@@ -11,11 +10,21 @@ static bool parse_coords(const char *str, double *x, double *y, bool *mm) {
        *mm = false;
        char *end;
-        *x = strtod(str, &end);
-        if (end[0] != 'x') {
+        // Check for "0x" prefix to avoid strtod treating the string as hex
-                return false;
+        if (str[0] == '0' && str[1] == 'x') {
+                if (strlen(str) < 3) {
+                        return false;
+                }
+                *x = 0;
+                end = (char *)str + 2;
+        } else {
+                *x = strtod(str, &end);
+                if (end[0] != 'x') {
+                        return false;
+                }
+                ++end;
        }
-        ++end;
        *y = strtod(end, &end);
        if (end[0] == 'm') {
diff --git a/sway/commands/input/map_to_output.c b/sway/commands/input/map_to_output.c
index f60fb7d5..a7266baa 100644
--- a/sway/commands/input/map_to_output.c
+++ b/sway/commands/input/map_to_output.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include <strings.h>
 #include "sway/config.h"
diff --git a/sway/commands/input/map_to_region.c b/sway/commands/input/map_to_region.c
index 284b57d0..9087c589 100644
--- a/sway/commands/input/map_to_region.c
+++ b/sway/commands/input/map_to_region.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdlib.h>
 #include <string.h>
 #include "sway/commands.h"
@@ -49,5 +48,5 @@ struct cmd_results *input_cmd_map_to_region(int argc, char **argv) {
 error:
        free(ic->mapped_to_region);
        ic->mapped_to_region = NULL;
-        return cmd_results_new(CMD_FAILURE, errstr);
+        return cmd_results_new(CMD_FAILURE, "%s", errstr);
 }
diff --git a/sway/commands/input/rotation_angle.c b/sway/commands/input/rotation_angle.c
new file mode 100644
index 00000000..5e278fff
--- /dev/null
+++ b/sway/commands/input/rotation_angle.c
@@ -0,0 +1,29 @@
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include "sway/config.h"
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+#include "util.h"
+struct cmd_results *input_cmd_rotation_angle(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "rotation_angle", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        struct input_config *ic = config->handler_context.input_config;
+        if (!ic) {
+                return cmd_results_new(CMD_FAILURE, "No input device defined.");
+        }
+        float rotation_angle = parse_float(argv[0]);
+        if (isnan(rotation_angle)) {
+                return cmd_results_new(CMD_INVALID,
+                        "Invalid rotation_angle; expected float.");
+        } if (rotation_angle < 0 || rotation_angle > 360) {
+                return cmd_results_new(CMD_INVALID, "Input out of range [0, 360)");
+        }
+        ic->rotation_angle = rotation_angle;
+        return cmd_results_new(CMD_SUCCESS, NULL);
+}
diff --git a/sway/commands/input/scroll_button.c b/sway/commands/input/scroll_button.c
index 6b331419..81f69a6d 100644
--- a/sway/commands/input/scroll_button.c
+++ b/sway/commands/input/scroll_button.c
@@ -21,7 +21,7 @@ struct cmd_results *input_cmd_scroll_button(int argc, char **argv) {
        char *message = NULL;
        uint32_t button = get_mouse_button(*argv, &message);
        if (message) {
-                error = cmd_results_new(CMD_INVALID, message);
+                error = cmd_results_new(CMD_INVALID, "%s", message);
                free(message);
                return error;
        } else if (button == SWAY_SCROLL_UP || button == SWAY_SCROLL_DOWN
diff --git a/sway/commands/input/scroll_button_lock.c b/sway/commands/input/scroll_button_lock.c
new file mode 100644
index 00000000..f96b6514
--- /dev/null
+++ b/sway/commands/input/scroll_button_lock.c
@@ -0,0 +1,26 @@
+#include <libinput.h>
+#include <string.h>
+#include <strings.h>
+#include "sway/config.h"
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+#include "util.h"
+struct cmd_results *input_cmd_scroll_button_lock(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "scroll_button_lock", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        struct input_config *ic = config->handler_context.input_config;
+        if (!ic) {
+                return cmd_results_new(CMD_FAILURE, "No input device defined.");
+        }
+        if (parse_boolean(argv[0], true)) {
+                ic->scroll_button_lock = LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED;
+        } else {
+                ic->scroll_button_lock = LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED;
+        }
+        return cmd_results_new(CMD_SUCCESS, NULL);
+}
diff --git a/sway/commands/input/xkb_file.c b/sway/commands/input/xkb_file.c
index 493f94fb..056f00e5 100644
--- a/sway/commands/input/xkb_file.c
+++ b/sway/commands/input/xkb_file.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <unistd.h>
 #include <errno.h>
 #include "sway/config.h"
diff --git a/sway/commands/input/xkb_layout.c b/sway/commands/input/xkb_layout.c
index 22626517..1d01886c 100644
--- a/sway/commands/input/xkb_layout.c
+++ b/sway/commands/input/xkb_layout.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "log.h"
diff --git a/sway/commands/input/xkb_model.c b/sway/commands/input/xkb_model.c
index f4a33de3..a9144a8a 100644
--- a/sway/commands/input/xkb_model.c
+++ b/sway/commands/input/xkb_model.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "log.h"
diff --git a/sway/commands/input/xkb_numlock.c b/sway/commands/input/xkb_numlock.c
index 87d3e60c..bbe848fe 100644
--- a/sway/commands/input/xkb_numlock.c
+++ b/sway/commands/input/xkb_numlock.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "util.h"
diff --git a/sway/commands/input/xkb_options.c b/sway/commands/input/xkb_options.c
index d609293f..7ca20777 100644
--- a/sway/commands/input/xkb_options.c
+++ b/sway/commands/input/xkb_options.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "log.h"
diff --git a/sway/commands/input/xkb_rules.c b/sway/commands/input/xkb_rules.c
index 3b59622c..8fbd26fb 100644
--- a/sway/commands/input/xkb_rules.c
+++ b/sway/commands/input/xkb_rules.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "log.h"
diff --git a/sway/commands/input/xkb_switch_layout.c b/sway/commands/input/xkb_switch_layout.c
index d6548a68..ecac8e6c 100644
--- a/sway/commands/input/xkb_switch_layout.c
+++ b/sway/commands/input/xkb_switch_layout.c
@@ -1,10 +1,15 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
+#include <wlr/interfaces/wlr_keyboard.h>
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "sway/input/input-manager.h"
 #include "log.h"
+struct xkb_switch_layout_action {
+        struct wlr_keyboard *keyboard;
+        xkb_layout_index_t layout;
+};
 static void switch_layout(struct wlr_keyboard *kbd, xkb_layout_index_t idx) {
        xkb_layout_index_t num_layouts = xkb_keymap_num_layouts(kbd->keymap);
        if (idx >= num_layouts) {
@@ -28,10 +33,10 @@ static xkb_layout_index_t get_current_layout_index(struct wlr_keyboard *kbd) {
        return layout_idx;
 }
-static void switch_layout_relative(struct wlr_keyboard *kbd, int dir) {
+static xkb_layout_index_t get_layout_relative(struct wlr_keyboard *kbd, int dir) {
        xkb_layout_index_t num_layouts = xkb_keymap_num_layouts(kbd->keymap);
        xkb_layout_index_t idx = get_current_layout_index(kbd);
-        switch_layout(kbd, (idx + num_layouts + dir) % num_layouts);
+        return (idx + num_layouts + dir) % num_layouts;
 }
 struct cmd_results *input_cmd_xkb_switch_layout(int argc, char **argv) {
@@ -66,6 +71,18 @@ struct cmd_results *input_cmd_xkb_switch_layout(int argc, char **argv) {
                relative = 0;
        }
+        struct xkb_switch_layout_action *actions = calloc(
+                wl_list_length(&server.input->devices),
+                sizeof(struct xkb_switch_layout_action));
+        size_t actions_len = 0;
+        if (!actions) {
+                return cmd_results_new(CMD_FAILURE, "Unable to allocate actions");
+        }
+        /* Calculate new indexes first because switching a layout in one
+           keyboard may result in a change on other keyboards as well because
+           of keyboard groups. */
        struct sway_input_device *dev;
        wl_list_for_each(dev, &server.input->devices, link) {
                if (strcmp(ic->identifier, "*") != 0 &&
@@ -76,12 +93,22 @@ struct cmd_results *input_cmd_xkb_switch_layout(int argc, char **argv) {
                if (dev->wlr_device->type != WLR_INPUT_DEVICE_KEYBOARD) {
                        continue;
                }
+                struct xkb_switch_layout_action *action =
+                        &actions[actions_len++];
+                action->keyboard = wlr_keyboard_from_input_device(dev->wlr_device);
                if (relative) {
-                        switch_layout_relative(dev->wlr_device->keyboard, relative);
+                        action->layout = get_layout_relative(action->keyboard, relative);
                } else {
-                        switch_layout(dev->wlr_device->keyboard, layout);
+                        action->layout = layout;
                }
        }
+        for (size_t i = 0; i < actions_len; i++) {
+                switch_layout(actions[i].keyboard, actions[i].layout);
+        }
+        free(actions);
        return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/input/xkb_variant.c b/sway/commands/input/xkb_variant.c
index d0e21d77..2d14ea9c 100644
--- a/sway/commands/input/xkb_variant.c
+++ b/sway/commands/input/xkb_variant.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "log.h"
diff --git a/sway/commands/layout.c b/sway/commands/layout.c
index 2ba61b38..12ce4839 100644
--- a/sway/commands/layout.c
+++ b/sway/commands/layout.c
@@ -153,7 +153,7 @@ struct cmd_results *cmd_layout(int argc, char **argv) {
                                workspace->output);
        }
        if (new_layout == L_NONE) {
-                return cmd_results_new(CMD_INVALID, expected_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
        }
        if (new_layout != old_layout) {
                if (container) {
diff --git a/sway/commands/mark.c b/sway/commands/mark.c
index aa5f185c..2bfc86b3 100644
--- a/sway/commands/mark.c
+++ b/sway/commands/mark.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "sway/config.h"
@@ -59,7 +58,7 @@ struct cmd_results *cmd_mark(int argc, char **argv) {
        }
        free(mark);
-        container_update_marks_textures(container);
+        container_update_marks(container);
        if (container->view) {
                view_execute_criteria(container->view);
        }
diff --git a/sway/commands/mode.c b/sway/commands/mode.c
index e23e4ee4..b3216967 100644
--- a/sway/commands/mode.c
+++ b/sway/commands/mode.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdbool.h>
 #include <string.h>
 #include "sway/commands.h"
@@ -11,10 +10,12 @@
 // Must be in order for the bsearch
 static const struct cmd_handler mode_handlers[] = {
        { "bindcode", cmd_bindcode },
+        { "bindgesture", cmd_bindgesture },
        { "bindswitch", cmd_bindswitch },
        { "bindsym", cmd_bindsym },
        { "set", cmd_set },
        { "unbindcode", cmd_unbindcode },
+        { "unbindgesture", cmd_unbindgesture },
        { "unbindswitch", cmd_unbindswitch },
        { "unbindsym", cmd_unbindsym },
 };
@@ -59,6 +60,7 @@ struct cmd_results *cmd_mode(int argc, char **argv) {
                mode->keycode_bindings = create_list();
                mode->mouse_bindings = create_list();
                mode->switch_bindings = create_list();
+                mode->gesture_bindings = create_list();
                mode->pango = pango;
                list_add(config->modes, mode);
        }
diff --git a/sway/commands/move.c b/sway/commands/move.c
index f2702fa1..8addf26e 100644
--- a/sway/commands/move.c
+++ b/sway/commands/move.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <ctype.h>
 #include <math.h>
 #include <stdbool.h>
@@ -206,9 +205,17 @@ static void container_move_to_workspace(struct sway_container *container,
                container_detach(container);
                workspace_add_floating(workspace, container);
                container_handle_fullscreen_reparent(container);
-                // If changing output, center it within the workspace
+                // If changing output, adjust the coordinates of the window.
                if (old_output != workspace->output && !container->pending.fullscreen_mode) {
-                        container_floating_move_to_center(container);
+                        struct wlr_box workspace_box, old_workspace_box;
+                        workspace_get_box(workspace, &workspace_box);
+                        workspace_get_box(old_workspace, &old_workspace_box);
+                        floating_fix_coordinates(container, &old_workspace_box, &workspace_box);
+                        if (container->scratchpad && workspace->output) {
+                                struct wlr_box output_box;
+                                output_get_box(workspace->output, &output_box);
+                                container->transform = workspace_box;
+                        }
                }
        } else {
                container_detach(container);
@@ -462,7 +469,7 @@ static struct cmd_results *cmd_move_container(bool no_auto_back_and_forth,
                        if (strcasecmp(argv[1], "number") == 0) {
                                // move [window|container] [to] "workspace number x"
                                if (argc < 3) {
-                                        return cmd_results_new(CMD_INVALID, expected_syntax);
+                                        return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
                                }
                                if (!isdigit(argv[2][0])) {
                                        return cmd_results_new(CMD_INVALID,
@@ -522,7 +529,7 @@ static struct cmd_results *cmd_move_container(bool no_auto_back_and_forth,
                }
                destination = &dest_con->node;
        } else {
-                return cmd_results_new(CMD_INVALID, expected_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
        }
        if (destination->type == N_CONTAINER &&
@@ -686,6 +693,9 @@ static struct cmd_results *cmd_move_workspace(int argc, char **argv) {
        arrange_output(old_output);
        arrange_output(new_output);
+        struct sway_seat *seat = config->handler_context.seat;
+        seat_consider_warp_to_focus(seat);
        return cmd_results_new(CMD_SUCCESS, NULL);
 }
@@ -759,15 +769,6 @@ static struct cmd_results *cmd_move_in_direction(
                ipc_event_window(container, "move");
        }
-        // Hack to re-focus container
-        seat_set_raw_focus(config->handler_context.seat, &new_ws->node);
-        seat_set_focus_container(config->handler_context.seat, container);
-        if (old_ws != new_ws) {
-                ipc_event_workspace(old_ws, new_ws, "focus");
-                workspace_detect_urgent(old_ws);
-                workspace_detect_urgent(new_ws);
-        }
        container_end_mouse_operation(container);
        return cmd_results_new(CMD_SUCCESS, NULL);
@@ -788,15 +789,15 @@ static struct cmd_results *cmd_move_to_position_pointer(
        struct wlr_output *output = wlr_output_layout_output_at(
                        root->output_layout, cursor->x, cursor->y);
        if (output) {
-                struct wlr_box *box =
+                struct wlr_box box;
-                                wlr_output_layout_get_box(root->output_layout, output);
+                wlr_output_layout_get_box(root->output_layout, output, &box);
-                lx = fmax(lx, box->x);
+                lx = fmax(lx, box.x);
-                ly = fmax(ly, box->y);
+                ly = fmax(ly, box.y);
-                if (lx + container->pending.width > box->x + box->width) {
+                if (lx + container->pending.width > box.x + box.width) {
-                        lx = box->x + box->width - container->pending.width;
+                        lx = box.x + box.width - container->pending.width;
                }
-                if (ly + container->pending.height > box->y + box->height) {
+                if (ly + container->pending.height > box.y + box.height) {
-                        ly = box->y + box->height - container->pending.height;
+                        ly = box.y + box.height - container->pending.height;
                }
        }
@@ -818,7 +819,7 @@ static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
        }
        if (!argc) {
-                return cmd_results_new(CMD_INVALID, expected_position_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_position_syntax);
        }
        bool absolute = false;
@@ -828,19 +829,19 @@ static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
                ++argv;
        }
        if (!argc) {
-                return cmd_results_new(CMD_INVALID, expected_position_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_position_syntax);
        }
        if (strcmp(argv[0], "position") == 0) {
                --argc;
                ++argv;
        }
        if (!argc) {
-                return cmd_results_new(CMD_INVALID, expected_position_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_position_syntax);
        }
        if (strcmp(argv[0], "cursor") == 0 || strcmp(argv[0], "mouse") == 0 ||
                        strcmp(argv[0], "pointer") == 0) {
                if (absolute) {
-                        return cmd_results_new(CMD_INVALID, expected_position_syntax);
+                        return cmd_results_new(CMD_INVALID, "%s", expected_position_syntax);
                }
                return cmd_move_to_position_pointer(container);
        } else if (strcmp(argv[0], "center") == 0) {
@@ -862,7 +863,7 @@ static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
        }
        if (argc < 2) {
-                return cmd_results_new(CMD_FAILURE, expected_position_syntax);
+                return cmd_results_new(CMD_FAILURE, "%s", expected_position_syntax);
        }
        struct movement_amount lx = { .amount = 0, .unit = MOVEMENT_UNIT_INVALID };
@@ -874,13 +875,17 @@ static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
                return cmd_results_new(CMD_INVALID, "Invalid x position specified");
        }
+        if (argc < 1) {
+                return cmd_results_new(CMD_FAILURE, "%s", expected_position_syntax);
+        }
        struct movement_amount ly = { .amount = 0, .unit = MOVEMENT_UNIT_INVALID };
        // Y direction
        num_consumed_args = parse_movement_amount(argc, argv, &ly);
        argc -= num_consumed_args;
        argv += num_consumed_args;
        if (argc > 0) {
-                return cmd_results_new(CMD_INVALID, expected_position_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_position_syntax);
        }
        if (ly.unit == MOVEMENT_UNIT_INVALID) {
                return cmd_results_new(CMD_INVALID, "Invalid y position specified");
@@ -1026,13 +1031,13 @@ struct cmd_results *cmd_move(int argc, char **argv) {
        }
        if (!argc) {
-                return cmd_results_new(CMD_INVALID, expected_full_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_full_syntax);
        }
        // Only `move [window|container] [to] workspace` supports
        // `--no-auto-back-and-forth` so treat others as invalid syntax
        if (no_auto_back_and_forth && strcasecmp(argv[0], "workspace") != 0) {
-                return cmd_results_new(CMD_INVALID, expected_full_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_full_syntax);
        }
        if (strcasecmp(argv[0], "workspace") == 0 ||
@@ -1046,5 +1051,5 @@ struct cmd_results *cmd_move(int argc, char **argv) {
                        strcasecmp(argv[1], "position") == 0)) {
                return cmd_move_to_position(argc, argv);
        }
-        return cmd_results_new(CMD_INVALID, expected_full_syntax);
+        return cmd_results_new(CMD_INVALID, "%s", expected_full_syntax);
 }
diff --git a/sway/commands/no_focus.c b/sway/commands/no_focus.c
index 2001e04f..ccfdec82 100644
--- a/sway/commands/no_focus.c
+++ b/sway/commands/no_focus.c
@@ -13,7 +13,7 @@ struct cmd_results *cmd_no_focus(int argc, char **argv) {
        char *err_str = NULL;
        struct criteria *criteria = criteria_parse(argv[0], &err_str);
        if (!criteria) {
-                error = cmd_results_new(CMD_INVALID, err_str);
+                error = cmd_results_new(CMD_INVALID, "%s", err_str);
                free(err_str);
                return error;
        }
diff --git a/sway/commands/opacity.c b/sway/commands/opacity.c
index 96e6228e..610cecc6 100644
--- a/sway/commands/opacity.c
+++ b/sway/commands/opacity.c
@@ -37,6 +37,7 @@ struct cmd_results *cmd_opacity(int argc, char **argv) {
        }
        con->alpha = val;
-        container_damage_whole(con);
+        container_update(con);
        return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/output.c b/sway/commands/output.c
index 4418f23f..5e5d31b3 100644
--- a/sway/commands/output.c
+++ b/sway/commands/output.c
@@ -15,8 +15,11 @@ static const struct cmd_handler output_handlers[] = {
        { "enable", output_cmd_enable },
        { "max_render_time", output_cmd_max_render_time },
        { "mode", output_cmd_mode },
+        { "modeline", output_cmd_modeline },
        { "pos", output_cmd_position },
        { "position", output_cmd_position },
+        { "power", output_cmd_power },
+        { "render_bit_depth", output_cmd_render_bit_depth },
        { "res", output_cmd_mode },
        { "resolution", output_cmd_mode },
        { "scale", output_cmd_scale },
@@ -24,6 +27,7 @@ static const struct cmd_handler output_handlers[] = {
        { "subpixel", output_cmd_subpixel },
        { "toggle", output_cmd_toggle },
        { "transform", output_cmd_transform },
+        { "unplug", output_cmd_unplug },
 };
 struct cmd_results *cmd_output(int argc, char **argv) {
@@ -32,9 +36,9 @@ struct cmd_results *cmd_output(int argc, char **argv) {
                return error;
        }
-        // The NOOP-1 output is a dummy output used when there's no outputs
+        // The HEADLESS-1 output is a dummy output used when there's no outputs
        // connected. It should never be configured.
-        if (strcasecmp(argv[0], root->noop_output->wlr_output->name) == 0) {
+        if (strcasecmp(argv[0], root->fallback_output->wlr_output->name) == 0) {
                return cmd_results_new(CMD_FAILURE,
                                "Refusing to configure the no op output");
        }
@@ -51,7 +55,7 @@ struct cmd_results *cmd_output(int argc, char **argv) {
                if (!sway_output) {
                        return cmd_results_new(CMD_FAILURE, "Unknown output");
                }
-                if (sway_output == root->noop_output) {
+                if (sway_output == root->fallback_output) {
                        return cmd_results_new(CMD_FAILURE,
                                        "Refusing to configure the no op output");
                }
@@ -99,15 +103,18 @@ struct cmd_results *cmd_output(int argc, char **argv) {
        bool background = output->background;
-        output = store_output_config(output);
+        store_output_config(output);
        // If reloading, the output configs will be applied after reading the
        // entire config and before the deferred commands so that an auto generated
        // workspace name is not given to re-enabled outputs.
        if (!config->reloading && !config->validating) {
-                apply_output_config_to_outputs(output);
+                apply_all_output_configs();
                if (background) {
-                        spawn_swaybg();
+                        if (!spawn_swaybg()) {
+                                return cmd_results_new(CMD_FAILURE,
+                                        "Failed to apply background configuration");
+                        }
                }
        }
diff --git a/sway/commands/output/background.c b/sway/commands/output/background.c
index 68ee9fe1..55bd7671 100644
--- a/sway/commands/output/background.c
+++ b/sway/commands/output/background.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <libgen.h>
 #include <stdio.h>
 #include <string.h>
@@ -102,19 +101,19 @@ struct cmd_results *output_cmd_background(int argc, char **argv) {
                        }
                        char *conf_path = dirname(conf);
-                        char *rel_path = src;
+                        char *real_src = malloc(strlen(conf_path) + strlen(src) + 2);
-                        src = malloc(strlen(conf_path) + strlen(src) + 2);
+                        if (!real_src) {
-                        if (!src) {
+                                free(src);
-                                free(rel_path);
                                free(conf);
                                sway_log(SWAY_ERROR, "Unable to allocate memory");
                                return cmd_results_new(CMD_FAILURE,
                                                "Unable to allocate resources");
                        }
-                        sprintf(src, "%s/%s", conf_path, rel_path);
+                        snprintf(real_src, strlen(conf_path) + strlen(src) + 2, "%s/%s", conf_path, src);
-                        free(rel_path);
+                        free(src);
                        free(conf);
+                        src = real_src;
                }
                bool can_access = access(src, F_OK) != -1;
@@ -123,7 +122,10 @@ struct cmd_results *output_cmd_background(int argc, char **argv) {
                                        src);
                        config_add_swaynag_warning("Unable to access background file '%s'",
                                        src);
+                        struct cmd_results *result = cmd_results_new(CMD_FAILURE,
+                                        "unable to access background file '%s'", src);
                        free(src);
+                        return result;
                } else {
                        output->background = src;
                        output->background_option = strdup(mode);
diff --git a/sway/commands/output/dpms.c b/sway/commands/output/dpms.c
index 638c0ade..c7adbd58 100644
--- a/sway/commands/output/dpms.c
+++ b/sway/commands/output/dpms.c
@@ -1,45 +1,8 @@
+#include "log.h"
 #include "sway/commands.h"
-#include "sway/config.h"
-#include "sway/output.h"
-#include "util.h"
-#include <strings.h>
 struct cmd_results *output_cmd_dpms(int argc, char **argv) {
-        if (!config->handler_context.output_config) {
+        sway_log(SWAY_INFO, "The \"output dpms\" command is deprecated, "
-                return cmd_results_new(CMD_FAILURE, "Missing output config");
+                "use \"output power\" instead");
-        }
+        return output_cmd_power(argc, argv);
-        if (!argc) {
-                return cmd_results_new(CMD_INVALID, "Missing dpms argument.");
-        }
-        enum config_dpms current_dpms = DPMS_ON;
-        if (strcasecmp(argv[0], "toggle") == 0) {
-                const char *oc_name = config->handler_context.output_config->name;
-                if (strcmp(oc_name, "*") == 0) {
-                        return cmd_results_new(CMD_INVALID,
-                                        "Cannot apply toggle to all outputs.");
-                }
-                struct sway_output *sway_output = all_output_by_name_or_id(oc_name);
-                if (!sway_output || !sway_output->wlr_output) {
-                        return cmd_results_new(CMD_FAILURE,
-                                        "Cannot apply toggle to unknown output %s", oc_name);
-                }
-                if (sway_output->enabled && !sway_output->wlr_output->enabled) {
-                        current_dpms = DPMS_OFF;
-                }
-        }
-        if (parse_boolean(argv[0], current_dpms == DPMS_ON)) {
-                config->handler_context.output_config->dpms_state = DPMS_ON;
-        } else {
-                config->handler_context.output_config->dpms_state = DPMS_OFF;
-        }
-        config->handler_context.leftovers.argc = argc - 1;
-        config->handler_context.leftovers.argv = argv + 1;
-        return NULL;
 }
diff --git a/sway/commands/output/mode.c b/sway/commands/output/mode.c
index 5b710713..019d625a 100644
--- a/sway/commands/output/mode.c
+++ b/sway/commands/output/mode.c
@@ -20,6 +20,9 @@ struct cmd_results *output_cmd_mode(int argc, char **argv) {
                output->custom_mode = 0;
        }
+        // Reset custom modeline, if any
+        output->drm_mode.type = 0;
        char *end;
        output->width = strtol(*argv, &end, 10);
        if (*end) {
@@ -58,3 +61,58 @@ struct cmd_results *output_cmd_mode(int argc, char **argv) {
        return NULL;
 }
+static bool parse_modeline(char **argv, drmModeModeInfo *mode) {
+        mode->type = DRM_MODE_TYPE_USERDEF;
+        mode->clock = strtof(argv[0], NULL) * 1000;
+        mode->hdisplay = strtol(argv[1], NULL, 10);
+        mode->hsync_start = strtol(argv[2], NULL, 10);
+        mode->hsync_end = strtol(argv[3], NULL, 10);
+        mode->htotal = strtol(argv[4], NULL, 10);
+        mode->vdisplay = strtol(argv[5], NULL, 10);
+        mode->vsync_start = strtol(argv[6], NULL, 10);
+        mode->vsync_end = strtol(argv[7], NULL, 10);
+        mode->vtotal = strtol(argv[8], NULL, 10);
+        mode->vrefresh = mode->clock * 1000.0 * 1000.0
+                / mode->htotal / mode->vtotal;
+        if (strcasecmp(argv[9], "+hsync") == 0) {
+                mode->flags |= DRM_MODE_FLAG_PHSYNC;
+        } else if (strcasecmp(argv[9], "-hsync") == 0) {
+                mode->flags |= DRM_MODE_FLAG_NHSYNC;
+        } else {
+                return false;
+        }
+        if (strcasecmp(argv[10], "+vsync") == 0) {
+                mode->flags |= DRM_MODE_FLAG_PVSYNC;
+        } else if (strcasecmp(argv[10], "-vsync") == 0) {
+                mode->flags |= DRM_MODE_FLAG_NVSYNC;
+        } else {
+                return false;
+        }
+        snprintf(mode->name, sizeof(mode->name), "%dx%d@%d",
+                 mode->hdisplay, mode->vdisplay, mode->vrefresh / 1000);
+        return true;
+}
+struct cmd_results *output_cmd_modeline(int argc, char **argv) {
+        if (!config->handler_context.output_config) {
+                return cmd_results_new(CMD_FAILURE, "Missing output config");
+        }
+        if (!argc) {
+                return cmd_results_new(CMD_INVALID, "Missing modeline argument.");
+        }
+        struct output_config *output = config->handler_context.output_config;
+        if (argc != 11 || !parse_modeline(argv, &output->drm_mode)) {
+                return cmd_results_new(CMD_INVALID, "Invalid modeline");
+        }
+        config->handler_context.leftovers.argc = argc - 12;
+        config->handler_context.leftovers.argv = argv + 12;
+        return NULL;
+}
diff --git a/sway/commands/output/power.c b/sway/commands/output/power.c
new file mode 100644
index 00000000..e6ae2852
--- /dev/null
+++ b/sway/commands/output/power.c
@@ -0,0 +1,43 @@
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/config.h"
+#include "sway/output.h"
+#include "util.h"
+struct cmd_results *output_cmd_power(int argc, char **argv) {
+        if (!config->handler_context.output_config) {
+                return cmd_results_new(CMD_FAILURE, "Missing output config");
+        }
+        if (argc == 0) {
+                return cmd_results_new(CMD_INVALID, "Missing power argument");
+        }
+        bool current = true;
+        if (strcasecmp(argv[0], "toggle") == 0) {
+                const char *oc_name = config->handler_context.output_config->name;
+                if (strcmp(oc_name, "*") == 0) {
+                        return cmd_results_new(CMD_INVALID,
+                                "Cannot apply toggle to all outputs");
+                }
+                struct sway_output *sway_output = all_output_by_name_or_id(oc_name);
+                if (!sway_output || !sway_output->wlr_output) {
+                        return cmd_results_new(CMD_FAILURE,
+                                "Cannot apply toggle to unknown output %s", oc_name);
+                }
+                if (sway_output->enabled && !sway_output->wlr_output->enabled) {
+                        current = false;
+                }
+        }
+        if (parse_boolean(argv[0], current)) {
+                config->handler_context.output_config->power = 1;
+        } else {
+                config->handler_context.output_config->power = 0;
+        }
+        config->handler_context.leftovers.argc = argc - 1;
+        config->handler_context.leftovers.argv = argv + 1;
+        return NULL;
+}
diff --git a/sway/commands/output/render_bit_depth.c b/sway/commands/output/render_bit_depth.c
new file mode 100644
index 00000000..c419321e
--- /dev/null
+++ b/sway/commands/output/render_bit_depth.c
@@ -0,0 +1,29 @@
+#include <drm_fourcc.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/config.h"
+struct cmd_results *output_cmd_render_bit_depth(int argc, char **argv) {
+        if (!config->handler_context.output_config) {
+                return cmd_results_new(CMD_FAILURE, "Missing output config");
+        }
+        if (!argc) {
+                return cmd_results_new(CMD_INVALID, "Missing bit depth argument.");
+        }
+        if (strcmp(*argv, "8") == 0) {
+                config->handler_context.output_config->render_bit_depth =
+                        RENDER_BIT_DEPTH_8;
+        } else if (strcmp(*argv, "10") == 0) {
+                config->handler_context.output_config->render_bit_depth =
+                        RENDER_BIT_DEPTH_10;
+        } else {
+                return cmd_results_new(CMD_INVALID,
+                        "Invalid bit depth. Must be a value in (8|10).");
+        }
+        config->handler_context.leftovers.argc = argc - 1;
+        config->handler_context.leftovers.argv = argv + 1;
+        return NULL;
+}
diff --git a/sway/commands/output/toggle.c b/sway/commands/output/toggle.c
index 6342d526..c6b72845 100644
--- a/sway/commands/output/toggle.c
+++ b/sway/commands/output/toggle.c
@@ -29,7 +29,7 @@ struct cmd_results *output_cmd_toggle(int argc, char **argv) {
                config->handler_context.output_config->enabled = 1;
        }
-        free(oc);
+        free_output_config(oc);
        config->handler_context.leftovers.argc = argc;
        config->handler_context.leftovers.argv = argv;
        return NULL;
diff --git a/sway/commands/output/transform.c b/sway/commands/output/transform.c
index f4fcc8c9..8db71bb3 100644
--- a/sway/commands/output/transform.c
+++ b/sway/commands/output/transform.c
@@ -1,4 +1,5 @@
 #include <string.h>
+#include <wlr/util/transform.h>
 #include "sway/commands.h"
 #include "sway/config.h"
 #include "log.h"
diff --git a/sway/commands/output/unplug.c b/sway/commands/output/unplug.c
new file mode 100644
index 00000000..dfef626f
--- /dev/null
+++ b/sway/commands/output/unplug.c
@@ -0,0 +1,54 @@
+#include <strings.h>
+#include <wlr/config.h>
+#include <wlr/backend/headless.h>
+#include <wlr/backend/wayland.h>
+#if WLR_HAS_X11_BACKEND
+#include <wlr/backend/x11.h>
+#endif
+#include "sway/commands.h"
+#include "sway/config.h"
+#include "sway/output.h"
+static bool is_backend_allowed(struct wlr_backend *backend) {
+        if (wlr_backend_is_headless(backend)) {
+                return true;
+        }
+        if (wlr_backend_is_wl(backend)) {
+                return true;
+        }
+#if WLR_HAS_X11_BACKEND
+        if (wlr_backend_is_x11(backend)) {
+                return true;
+        }
+#endif
+        return false;
+}
+/**
+ * This command is intended for developer use only.
+ */
+struct cmd_results *output_cmd_unplug(int argc, char **argv) {
+        if (!config->handler_context.output_config) {
+                return cmd_results_new(CMD_FAILURE, "Missing output config");
+        }
+        const char *oc_name = config->handler_context.output_config->name;
+        if (strcmp(oc_name, "*") == 0) {
+                return cmd_results_new(CMD_INVALID, "Won't unplug all outputs");
+        }
+        struct sway_output *sway_output = all_output_by_name_or_id(oc_name);
+        if (!sway_output) {
+                return cmd_results_new(CMD_INVALID,
+                        "Cannot unplug unknown output %s", oc_name);
+        }
+        if (!is_backend_allowed(sway_output->wlr_output->backend)) {
+                return cmd_results_new(CMD_INVALID,
+                        "Can only unplug outputs with headless, wayland or x11 backend");
+        }
+        wlr_output_destroy(sway_output->wlr_output);
+        return cmd_results_new(CMD_SUCCESS, NULL);
+}
diff --git a/sway/commands/primary_selection.c b/sway/commands/primary_selection.c
new file mode 100644
index 00000000..9e2689c2
--- /dev/null
+++ b/sway/commands/primary_selection.c
@@ -0,0 +1,25 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/config.h"
+#include "sway/commands.h"
+#include "util.h"
+struct cmd_results *cmd_primary_selection(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "primary_selection", EXPECTED_EQUAL_TO, 1))) {
+                return error;
+        }
+        bool primary_selection = parse_boolean(argv[0], true);
+        // config->primary_selection is reset to the previous value on reload in
+        // load_main_config()
+        if (config->reloading && config->primary_selection != primary_selection) {
+                return cmd_results_new(CMD_FAILURE,
+                                "primary_selection can only be enabled/disabled at launch");
+        }
+        config->primary_selection = primary_selection;
+        return cmd_results_new(CMD_SUCCESS, NULL);
+}
diff --git a/sway/commands/reload.c b/sway/commands/reload.c
index 3c994d54..6c0aac26 100644
--- a/sway/commands/reload.c
+++ b/sway/commands/reload.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "sway/config.h"
@@ -9,9 +8,8 @@
 #include "list.h"
 #include "log.h"
-static void rebuild_textures_iterator(struct sway_container *con, void *data) {
+static void title_bar_update_iterator(struct sway_container *con, void *data) {
-        container_update_marks_textures(con);
+        container_update_title_bar(con);
-        container_update_title_textures(con);
 }
 static void do_reload(void *data) {
@@ -48,8 +46,7 @@ static void do_reload(void *data) {
        }
        list_free_items_and_destroy(bar_ids);
-        config_update_font_height(true);
+        root_for_each_container(title_bar_update_iterator, NULL);
-        root_for_each_container(rebuild_textures_iterator, NULL);
        arrange_root();
 }
diff --git a/sway/commands/rename.c b/sway/commands/rename.c
index 3b855fdf..0d36cc21 100644
--- a/sway/commands/rename.c
+++ b/sway/commands/rename.c
@@ -7,6 +7,7 @@
 #include "sway/config.h"
 #include "sway/ipc-server.h"
 #include "sway/output.h"
+#include "sway/desktop/launcher.h"
 #include "sway/tree/container.h"
 #include "sway/tree/workspace.h"
 #include "sway/tree/root.h"
@@ -25,7 +26,7 @@ struct cmd_results *cmd_rename(int argc, char **argv) {
                                "Can't run this command while there's no outputs connected.");
        }
        if (strcasecmp(argv[0], "workspace") != 0) {
-                return cmd_results_new(CMD_INVALID, expected_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
        }
        int argn = 1;
@@ -64,7 +65,7 @@ struct cmd_results *cmd_rename(int argc, char **argv) {
        ++argn; // move past "to"
        if (argn >= argc) {
-                return cmd_results_new(CMD_INVALID, expected_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
        }
        char *new_name = join_args(argv + argn, argc - argn);
@@ -91,8 +92,6 @@ struct cmd_results *cmd_rename(int argc, char **argv) {
        sway_log(SWAY_DEBUG, "renaming workspace '%s' to '%s'", workspace->name, new_name);
-        root_rename_pid_workspaces(workspace->name, new_name);
        free(workspace->name);
        workspace->name = new_name;
diff --git a/sway/commands/resize.c b/sway/commands/resize.c
index 425069de..32b746ea 100644
--- a/sway/commands/resize.c
+++ b/sway/commands/resize.c
@@ -75,6 +75,10 @@ void container_resize_tiled(struct sway_container *con,
                return;
        }
+        if (container_is_scratchpad_hidden_or_child(con)) {
+                return;
+        }
        // For HORIZONTAL or VERTICAL, we are growing in two directions so select
        // both adjacent siblings. For RIGHT or DOWN, just select the next sibling.
        // For LEFT or UP, convert it to a RIGHT or DOWN resize and reassign con to
@@ -249,16 +253,35 @@ static struct cmd_results *resize_adjust_tiled(uint32_t axis,
                struct movement_amount *amount) {
        struct sway_container *current = config->handler_context.container;
+        if (container_is_scratchpad_hidden_or_child(current)) {
+                return cmd_results_new(CMD_FAILURE, "Cannot resize a hidden scratchpad container");
+        }
        if (amount->unit == MOVEMENT_UNIT_DEFAULT) {
                amount->unit = MOVEMENT_UNIT_PPT;
        }
        if (amount->unit == MOVEMENT_UNIT_PPT) {
+        struct sway_container *parent = current->pending.parent;
                float pct = amount->amount / 100.0f;
                if (is_horizontal(axis)) {
-                        amount->amount = (float)current->pending.width * pct;
+            while (parent && parent->pending.layout != L_HORIZ) {
+                parent = parent->pending.parent;
+            }
+            if (parent) {
+                amount->amount = (float)parent->pending.width * pct;
+            } else {
+                amount->amount = (float)current->pending.workspace->width * pct;
+            }
                } else {
-                        amount->amount = (float)current->pending.height * pct;
+            while (parent && parent->pending.layout != L_VERT) {
+                parent = parent->pending.parent;
+            }
+            if (parent) {
+                amount->amount = (float)parent->pending.height * pct;
+            } else {
+                amount->amount = (float)current->pending.workspace->height * pct;
+            }
                }
        }
@@ -277,6 +300,11 @@ static struct cmd_results *resize_adjust_tiled(uint32_t axis,
 */
 static struct cmd_results *resize_set_tiled(struct sway_container *con,
                struct movement_amount *width, struct movement_amount *height) {
+        if (container_is_scratchpad_hidden_or_child(con)) {
+                return cmd_results_new(CMD_FAILURE, "Cannot resize a hidden scratchpad container");
+        }
        if (width->amount) {
                if (width->unit == MOVEMENT_UNIT_PPT ||
                                width->unit == MOVEMENT_UNIT_DEFAULT) {
@@ -415,7 +443,7 @@ static struct cmd_results *cmd_resize_set(int argc, char **argv) {
                argc -= num_consumed_args;
                argv += num_consumed_args;
                if (width.unit == MOVEMENT_UNIT_INVALID) {
-                        return cmd_results_new(CMD_INVALID, usage);
+                        return cmd_results_new(CMD_INVALID, "%s", usage);
                }
        }
@@ -427,10 +455,10 @@ static struct cmd_results *cmd_resize_set(int argc, char **argv) {
                }
                int num_consumed_args = parse_movement_amount(argc, argv, &height);
                if (argc > num_consumed_args) {
-                        return cmd_results_new(CMD_INVALID, usage);
+                        return cmd_results_new(CMD_INVALID, "%s", usage);
                }
                if (width.unit == MOVEMENT_UNIT_INVALID) {
-                        return cmd_results_new(CMD_INVALID, usage);
+                        return cmd_results_new(CMD_INVALID, "%s", usage);
                }
        }
@@ -462,7 +490,7 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
                "[<amount> px|ppt [or <amount> px|ppt]]'";
        uint32_t axis = parse_resize_axis(*argv);
        if (axis == WLR_EDGE_NONE) {
-                return cmd_results_new(CMD_INVALID, usage);
+                return cmd_results_new(CMD_INVALID, "%s", usage);
        }
        --argc; ++argv;
@@ -473,7 +501,7 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
                argc -= num_consumed_args;
                argv += num_consumed_args;
                if (first_amount.unit == MOVEMENT_UNIT_INVALID) {
-                        return cmd_results_new(CMD_INVALID, usage);
+                        return cmd_results_new(CMD_INVALID, "%s", usage);
                }
        } else {
                first_amount.amount = 10;
@@ -483,7 +511,7 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
        // "or"
        if (argc) {
                if (strcmp(*argv, "or") != 0) {
-                        return cmd_results_new(CMD_INVALID, usage);
+                        return cmd_results_new(CMD_INVALID, "%s", usage);
                }
                --argc; ++argv;
        }
@@ -493,10 +521,10 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
        if (argc) {
                int num_consumed_args = parse_movement_amount(argc, argv, &second_amount);
                if (argc > num_consumed_args) {
-                        return cmd_results_new(CMD_INVALID, usage);
+                        return cmd_results_new(CMD_INVALID, "%s", usage);
                }
                if (second_amount.unit == MOVEMENT_UNIT_INVALID) {
-                        return cmd_results_new(CMD_INVALID, usage);
+                        return cmd_results_new(CMD_INVALID, "%s", usage);
                }
        } else {
                second_amount.amount = 0;
@@ -566,5 +594,5 @@ struct cmd_results *cmd_resize(int argc, char **argv) {
        const char usage[] = "Expected 'resize <shrink|grow> "
                "<width|height|up|down|left|right> [<amount>] [px|ppt]'";
-        return cmd_results_new(CMD_INVALID, usage);
+        return cmd_results_new(CMD_INVALID, "%s", usage);
 }
diff --git a/sway/commands/seat/attach.c b/sway/commands/seat/attach.c
index 00bfdab6..47d18546 100644
--- a/sway/commands/seat/attach.c
+++ b/sway/commands/seat/attach.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "sway/config.h"
diff --git a/sway/commands/seat/cursor.c b/sway/commands/seat/cursor.c
index 749235eb..df7c379d 100644
--- a/sway/commands/seat/cursor.c
+++ b/sway/commands/seat/cursor.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <linux/input-event-codes.h>
 #include <strings.h>
@@ -18,7 +17,7 @@ static struct cmd_results *handle_command(struct sway_cursor *cursor,
                int argc, char **argv) {
        if (strcasecmp(argv[0], "move") == 0) {
                if (argc < 3) {
-                        return cmd_results_new(CMD_INVALID, expected_syntax);
+                        return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
                }
                int delta_x = strtol(argv[1], NULL, 10);
                int delta_y = strtol(argv[2], NULL, 10);
@@ -27,7 +26,7 @@ static struct cmd_results *handle_command(struct sway_cursor *cursor,
                wlr_seat_pointer_notify_frame(cursor->seat->wlr_seat);
        } else if (strcasecmp(argv[0], "set") == 0) {
                if (argc < 3) {
-                        return cmd_results_new(CMD_INVALID, expected_syntax);
+                        return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
                }
                // map absolute coords (0..1,0..1) to root container coords
                float x = strtof(argv[1], NULL) / root->width;
@@ -37,7 +36,7 @@ static struct cmd_results *handle_command(struct sway_cursor *cursor,
                wlr_seat_pointer_notify_frame(cursor->seat->wlr_seat);
        } else {
                if (argc < 2) {
-                        return cmd_results_new(CMD_INVALID, expected_syntax);
+                        return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
                }
                struct cmd_results *error = NULL;
                if ((error = press_or_release(cursor, argv[0], argv[1]))) {
@@ -85,36 +84,36 @@ struct cmd_results *seat_cmd_cursor(int argc, char **argv) {
 static struct cmd_results *press_or_release(struct sway_cursor *cursor,
                char *action, char *button_str) {
-        enum wlr_button_state state;
+        enum wl_pointer_button_state state;
        uint32_t button;
        if (strcasecmp(action, "press") == 0) {
-                state = WLR_BUTTON_PRESSED;
+                state = WL_POINTER_BUTTON_STATE_PRESSED;
        } else if (strcasecmp(action, "release") == 0) {
-                state = WLR_BUTTON_RELEASED;
+                state = WL_POINTER_BUTTON_STATE_RELEASED;
        } else {
-                return cmd_results_new(CMD_INVALID, expected_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
        }
        char *message = NULL;
        button = get_mouse_button(button_str, &message);
        if (message) {
                struct cmd_results *error =
-                        cmd_results_new(CMD_INVALID, message);
+                        cmd_results_new(CMD_INVALID, "%s", message);
                free(message);
                return error;
        } else if (button == SWAY_SCROLL_UP || button == SWAY_SCROLL_DOWN
                        || button == SWAY_SCROLL_LEFT || button == SWAY_SCROLL_RIGHT) {
                // Dispatch axis event
-                enum wlr_axis_orientation orientation =
+                enum wl_pointer_axis orientation =
                        (button == SWAY_SCROLL_UP || button == SWAY_SCROLL_DOWN)
-                        ? WLR_AXIS_ORIENTATION_VERTICAL
+                        ? WL_POINTER_AXIS_VERTICAL_SCROLL
-                        : WLR_AXIS_ORIENTATION_HORIZONTAL;
+                        : WL_POINTER_AXIS_HORIZONTAL_SCROLL;
                double delta = (button == SWAY_SCROLL_UP || button == SWAY_SCROLL_LEFT)
                        ? -1 : 1;
-                struct wlr_event_pointer_axis event = {
+                struct wlr_pointer_axis_event event = {
-                        .device = NULL,
+                        .pointer = NULL,
                        .time_msec = 0,
-                        .source = WLR_AXIS_SOURCE_WHEEL,
+                        .source = WL_POINTER_AXIS_SOURCE_WHEEL,
                        .orientation = orientation,
                        .delta = delta * 15,
                        .delta_discrete = delta
diff --git a/sway/commands/seat/hide_cursor.c b/sway/commands/seat/hide_cursor.c
index e09b82d9..f5177a47 100644
--- a/sway/commands/seat/hide_cursor.c
+++ b/sway/commands/seat/hide_cursor.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "sway/config.h"
diff --git a/sway/commands/seat/idle.c b/sway/commands/seat/idle.c
index 82428f2c..2974453e 100644
--- a/sway/commands/seat/idle.c
+++ b/sway/commands/seat/idle.c
@@ -1,8 +1,8 @@
-#define _POSIX_C_SOURCE 200809L
 #include <limits.h>
 #include <string.h>
 #include <strings.h>
 #include <stdint.h>
+#include "log.h"
 #include "sway/commands.h"
 #include "sway/config.h"
 #include "sway/input/seat.h"
@@ -69,5 +69,10 @@ struct cmd_results *seat_cmd_idle_wake(int argc, char **argv) {
                return cmd_results_new(CMD_FAILURE, "Invalid idle source");
        }
        config->handler_context.seat_config->idle_wake_sources = sources;
+        sway_log(SWAY_INFO, "Warning: seat idle_wake is deprecated");
+        if (config->reading) {
+                config_add_swaynag_warning("seat idle_wake is deprecated. "
+                        "Only seat idle_inhibit is supported.");
+        }
        return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/seat/xcursor_theme.c b/sway/commands/seat/xcursor_theme.c
index 202f35b9..61322a57 100644
--- a/sway/commands/seat/xcursor_theme.c
+++ b/sway/commands/seat/xcursor_theme.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "sway/config.h"
diff --git a/sway/commands/set.c b/sway/commands/set.c
index c539e9fc..ba384c7c 100644
--- a/sway/commands/set.c
+++ b/sway/commands/set.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdio.h>
 #include <string.h>
 #include <strings.h>
diff --git a/sway/commands/show_marks.c b/sway/commands/show_marks.c
index 0d373b80..60cef9fa 100644
--- a/sway/commands/show_marks.c
+++ b/sway/commands/show_marks.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "sway/config.h"
@@ -10,8 +9,8 @@
 #include "stringop.h"
 #include "util.h"
-static void rebuild_marks_iterator(struct sway_container *con, void *data) {
+static void title_bar_update_iterator(struct sway_container *con, void *data) {
-        container_update_marks_textures(con);
+        container_update_marks(con);
 }
 struct cmd_results *cmd_show_marks(int argc, char **argv) {
@@ -23,12 +22,7 @@ struct cmd_results *cmd_show_marks(int argc, char **argv) {
        config->show_marks = parse_boolean(argv[0], config->show_marks);
        if (config->show_marks) {
-                root_for_each_container(rebuild_marks_iterator, NULL);
+                root_for_each_container(title_bar_update_iterator, NULL);
-        }
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                output_damage_whole(output);
        }
        return cmd_results_new(CMD_SUCCESS, NULL);
diff --git a/sway/commands/smart_gaps.c b/sway/commands/smart_gaps.c
index b27f9ccd..a6d165dc 100644
--- a/sway/commands/smart_gaps.c
+++ b/sway/commands/smart_gaps.c
@@ -15,7 +15,12 @@ struct cmd_results *cmd_smart_gaps(int argc, char **argv) {
                return error;
        }
-        config->smart_gaps = parse_boolean(argv[0], config->smart_gaps);
+        if (strcmp(argv[0], "inverse_outer") == 0) {
+                config->smart_gaps = SMART_GAPS_INVERSE_OUTER;
+        } else {
+                config->smart_gaps = parse_boolean(argv[0], config->smart_gaps)
+                        ? SMART_GAPS_ON : SMART_GAPS_OFF;
+        }
        arrange_root();
diff --git a/sway/commands/split.c b/sway/commands/split.c
index 3e25c6f7..500a497d 100644
--- a/sway/commands/split.c
+++ b/sway/commands/split.c
@@ -32,6 +32,24 @@ static struct cmd_results *do_split(int layout) {
        return cmd_results_new(CMD_SUCCESS, NULL);
 }
+static struct cmd_results *do_unsplit(void) {
+        struct sway_container *con = config->handler_context.container;
+        struct sway_workspace *ws = config->handler_context.workspace;
+        if (con && con->pending.parent && con->pending.parent->pending.children->length == 1) {
+                container_flatten(con->pending.parent);
+        } else {
+                return cmd_results_new(CMD_FAILURE, "Can only flatten a child container with no siblings");
+        }
+        if (root->fullscreen_global) {
+                arrange_root();
+        } else {
+                arrange_workspace(ws);
+        }
+        return cmd_results_new(CMD_SUCCESS, NULL);
+}
 struct cmd_results *cmd_split(int argc, char **argv) {
        struct cmd_results *error = NULL;
        if ((error = checkarg(argc, "split", EXPECTED_EQUAL_TO, 1))) {
@@ -55,6 +73,9 @@ struct cmd_results *cmd_split(int argc, char **argv) {
                } else {
                        return do_split(L_VERT);
                }
+        } else if (strcasecmp(argv[0], "n") == 0 ||
+                        strcasecmp(argv[0], "none") == 0) {
+                return do_unsplit();
        } else {
                return cmd_results_new(CMD_FAILURE,
                        "Invalid split command (expected either horizontal or vertical).");
diff --git a/sway/commands/swap.c b/sway/commands/swap.c
index ce5e5128..c0b0d0b9 100644
--- a/sway/commands/swap.c
+++ b/sway/commands/swap.c
@@ -1,10 +1,10 @@
-#define _POSIX_C_SOURCE 200809L
 #include <strings.h>
 #include "config.h"
 #include "log.h"
 #include "sway/commands.h"
 #include "sway/output.h"
 #include "sway/tree/arrange.h"
+#include "sway/tree/container.h"
 #include "sway/tree/root.h"
 #include "sway/tree/view.h"
 #include "sway/tree/workspace.h"
@@ -13,186 +13,12 @@
 static const char expected_syntax[] =
        "Expected 'swap container with id|con_id|mark <arg>'";
-static void swap_places(struct sway_container *con1,
-                struct sway_container *con2) {
-        struct sway_container *temp = malloc(sizeof(struct sway_container));
-        temp->pending.x = con1->pending.x;
-        temp->pending.y = con1->pending.y;
-        temp->pending.width = con1->pending.width;
-        temp->pending.height = con1->pending.height;
-        temp->width_fraction = con1->width_fraction;
-        temp->height_fraction = con1->height_fraction;
-        temp->pending.parent = con1->pending.parent;
-        temp->pending.workspace = con1->pending.workspace;
-        bool temp_floating = container_is_floating(con1);
-        con1->pending.x = con2->pending.x;
-        con1->pending.y = con2->pending.y;
-        con1->pending.width = con2->pending.width;
-        con1->pending.height = con2->pending.height;
-        con1->width_fraction = con2->width_fraction;
-        con1->height_fraction = con2->height_fraction;
-        con2->pending.x = temp->pending.x;
-        con2->pending.y = temp->pending.y;
-        con2->pending.width = temp->pending.width;
-        con2->pending.height = temp->pending.height;
-        con2->width_fraction = temp->width_fraction;
-        con2->height_fraction = temp->height_fraction;
-        int temp_index = container_sibling_index(con1);
-        if (con2->pending.parent) {
-                container_insert_child(con2->pending.parent, con1,
-                                container_sibling_index(con2));
-        } else if (container_is_floating(con2)) {
-                workspace_add_floating(con2->pending.workspace, con1);
-        } else {
-                workspace_insert_tiling(con2->pending.workspace, con1,
-                                container_sibling_index(con2));
-        }
-        if (temp->pending.parent) {
-                container_insert_child(temp->pending.parent, con2, temp_index);
-        } else if (temp_floating) {
-                workspace_add_floating(temp->pending.workspace, con2);
-        } else {
-                workspace_insert_tiling(temp->pending.workspace, con2, temp_index);
-        }
-        free(temp);
-}
-static void swap_focus(struct sway_container *con1,
-                struct sway_container *con2, struct sway_seat *seat,
-                struct sway_container *focus) {
-        if (focus == con1 || focus == con2) {
-                struct sway_workspace *ws1 = con1->pending.workspace;
-                struct sway_workspace *ws2 = con2->pending.workspace;
-                enum sway_container_layout layout1 = container_parent_layout(con1);
-                enum sway_container_layout layout2 = container_parent_layout(con2);
-                if (focus == con1 && (layout2 == L_TABBED || layout2 == L_STACKED)) {
-                        if (workspace_is_visible(ws2)) {
-                                seat_set_focus(seat, &con2->node);
-                        }
-                        seat_set_focus_container(seat, ws1 != ws2 ? con2 : con1);
-                } else if (focus == con2 && (layout1 == L_TABBED
-                                        || layout1 == L_STACKED)) {
-                        if (workspace_is_visible(ws1)) {
-                                seat_set_focus(seat, &con1->node);
-                        }
-                        seat_set_focus_container(seat, ws1 != ws2 ? con1 : con2);
-                } else if (ws1 != ws2) {
-                        seat_set_focus_container(seat, focus == con1 ? con2 : con1);
-                } else {
-                        seat_set_focus_container(seat, focus);
-                }
-        } else {
-                seat_set_focus_container(seat, focus);
-        }
-        if (root->fullscreen_global) {
-                seat_set_focus(seat,
-                                seat_get_focus_inactive(seat, &root->fullscreen_global->node));
-        }
-}
-void container_swap(struct sway_container *con1, struct sway_container *con2) {
-        if (!sway_assert(con1 && con2, "Cannot swap with nothing")) {
-                return;
-        }
-        if (!sway_assert(!container_has_ancestor(con1, con2)
-                                && !container_has_ancestor(con2, con1),
-                                "Cannot swap ancestor and descendant")) {
-                return;
-        }
-        sway_log(SWAY_DEBUG, "Swapping containers %zu and %zu",
-                        con1->node.id, con2->node.id);
-        bool scratch1 = con1->scratchpad;
-        bool hidden1 = container_is_scratchpad_hidden(con1);
-        bool scratch2 = con2->scratchpad;
-        bool hidden2 = container_is_scratchpad_hidden(con2);
-        if (scratch1) {
-                if (hidden1) {
-                        root_scratchpad_show(con1);
-                }
-                root_scratchpad_remove_container(con1);
-        }
-        if (scratch2) {
-                if (hidden2) {
-                        root_scratchpad_show(con2);
-                }
-                root_scratchpad_remove_container(con2);
-        }
-        enum sway_fullscreen_mode fs1 = con1->pending.fullscreen_mode;
-        enum sway_fullscreen_mode fs2 = con2->pending.fullscreen_mode;
-        if (fs1) {
-                container_fullscreen_disable(con1);
-        }
-        if (fs2) {
-                container_fullscreen_disable(con2);
-        }
-        struct sway_seat *seat = config->handler_context.seat;
-        struct sway_container *focus = seat_get_focused_container(seat);
-        struct sway_workspace *vis1 =
-                output_get_active_workspace(con1->pending.workspace->output);
-        struct sway_workspace *vis2 =
-                output_get_active_workspace(con2->pending.workspace->output);
-        if (!sway_assert(vis1 && vis2, "con1 or con2 are on an output without a"
-                                "workspace. This should not happen")) {
-                return;
-        }
-        char *stored_prev_name = NULL;
-        if (seat->prev_workspace_name) {
-                stored_prev_name = strdup(seat->prev_workspace_name);
-        }
-        swap_places(con1, con2);
-        if (!workspace_is_visible(vis1)) {
-                seat_set_focus(seat, seat_get_focus_inactive(seat, &vis1->node));
-        }
-        if (!workspace_is_visible(vis2)) {
-                seat_set_focus(seat, seat_get_focus_inactive(seat, &vis2->node));
-        }
-        swap_focus(con1, con2, seat, focus);
-        if (stored_prev_name) {
-                free(seat->prev_workspace_name);
-                seat->prev_workspace_name = stored_prev_name;
-        }
-        if (scratch1) {
-                root_scratchpad_add_container(con2, NULL);
-                if (!hidden1) {
-                        root_scratchpad_show(con2);
-                }
-        }
-        if (scratch2) {
-                root_scratchpad_add_container(con1, NULL);
-                if (!hidden2) {
-                        root_scratchpad_show(con1);
-                }
-        }
-        if (fs1) {
-                container_set_fullscreen(con2, fs1);
-        }
-        if (fs2) {
-                container_set_fullscreen(con1, fs2);
-        }
-}
 static bool test_con_id(struct sway_container *container, void *data) {
        size_t *con_id = data;
        return container->node.id == *con_id;
 }
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
 static bool test_id(struct sway_container *container, void *data) {
        xcb_window_t *wid = data;
        return (container->view && container->view->type == SWAY_VIEW_XWAYLAND
@@ -219,7 +45,7 @@ struct cmd_results *cmd_swap(int argc, char **argv) {
        }
        if (strcasecmp(argv[0], "container") || strcasecmp(argv[1], "with")) {
-                return cmd_results_new(CMD_INVALID, expected_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
        }
        struct sway_container *current = config->handler_context.container;
@@ -227,7 +53,7 @@ struct cmd_results *cmd_swap(int argc, char **argv) {
        char *value = join_args(argv + 3, argc - 3);
        if (strcasecmp(argv[2], "id") == 0) {
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
                xcb_window_t id = strtol(value, NULL, 0);
                other = root_find_container(test_id, &id);
 #endif
@@ -238,7 +64,7 @@ struct cmd_results *cmd_swap(int argc, char **argv) {
                other = root_find_container(test_mark, value);
        } else {
                free(value);
-                return cmd_results_new(CMD_INVALID, expected_syntax);
+                return cmd_results_new(CMD_INVALID, "%s", expected_syntax);
        }
        if (!other) {
@@ -247,6 +73,9 @@ struct cmd_results *cmd_swap(int argc, char **argv) {
        } else if (!current) {
                error = cmd_results_new(CMD_FAILURE,
                                "Can only swap with containers and views");
+        } else if (current == other) {
+                error = cmd_results_new(CMD_FAILURE,
+                                "Cannot swap a container with itself");
        } else if (container_has_ancestor(current, other)
                        || container_has_ancestor(other, current)) {
                error = cmd_results_new(CMD_FAILURE,
diff --git a/sway/commands/title_align.c b/sway/commands/title_align.c
index c30355de..be298a29 100644
--- a/sway/commands/title_align.c
+++ b/sway/commands/title_align.c
@@ -4,6 +4,10 @@
 #include "sway/tree/container.h"
 #include "sway/tree/root.h"
+static void arrange_title_bar_iterator(struct sway_container *con, void *data) {
+        container_arrange_title_bar(con);
+}
 struct cmd_results *cmd_title_align(int argc, char **argv) {
        struct cmd_results *error = NULL;
        if ((error = checkarg(argc, "title_align", EXPECTED_AT_LEAST, 1))) {
@@ -21,10 +25,7 @@ struct cmd_results *cmd_title_align(int argc, char **argv) {
                                "Expected 'title_align left|center|right'");
        }
-        for (int i = 0; i < root->outputs->length; ++i) {
+        root_for_each_container(arrange_title_bar_iterator, NULL);
-                struct sway_output *output = root->outputs->items[i];
-                output_damage_whole(output);
-        }
        return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/title_format.c b/sway/commands/title_format.c
index 9d312470..0b2ea265 100644
--- a/sway/commands/title_format.c
+++ b/sway/commands/title_format.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "sway/config.h"
@@ -23,6 +22,5 @@ struct cmd_results *cmd_title_format(int argc, char **argv) {
        }
        view->title_format = format;
        view_update_title(view, true);
-        config_update_font_height(true);
        return cmd_results_new(CMD_SUCCESS, NULL);
 }
diff --git a/sway/commands/titlebar_border_thickness.c b/sway/commands/titlebar_border_thickness.c
index 7c27c163..fa3db3c5 100644
--- a/sway/commands/titlebar_border_thickness.c
+++ b/sway/commands/titlebar_border_thickness.c
@@ -27,7 +27,6 @@ struct cmd_results *cmd_titlebar_border_thickness(int argc, char **argv) {
                                        "Expected output to have a workspace");
                }
                arrange_workspace(ws);
-                output_damage_whole(output);
        }
        return cmd_results_new(CMD_SUCCESS, NULL);
diff --git a/sway/commands/titlebar_padding.c b/sway/commands/titlebar_padding.c
index 29ce59ff..6999f7a2 100644
--- a/sway/commands/titlebar_padding.c
+++ b/sway/commands/titlebar_padding.c
@@ -33,7 +33,6 @@ struct cmd_results *cmd_titlebar_padding(int argc, char **argv) {
        for (int i = 0; i < root->outputs->length; ++i) {
                struct sway_output *output = root->outputs->items[i];
                arrange_workspace(output_get_active_workspace(output));
-                output_damage_whole(output);
        }
        return cmd_results_new(CMD_SUCCESS, NULL);
diff --git a/sway/commands/unmark.c b/sway/commands/unmark.c
index 19274dfb..4aba5bae 100644
--- a/sway/commands/unmark.c
+++ b/sway/commands/unmark.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <string.h>
 #include "sway/commands.h"
 #include "sway/config.h"
@@ -8,9 +7,13 @@
 #include "log.h"
 #include "stringop.h"
-static void remove_all_marks_iterator(struct sway_container *con, void *data) {
+static void remove_mark(struct sway_container *con) {
        container_clear_marks(con);
-        container_update_marks_textures(con);
+        container_update_marks(con);
+}
+static void remove_all_marks_iterator(struct sway_container *con, void *data) {
+        remove_mark(con);
 }
 // unmark                  Remove all marks from all views
@@ -38,8 +41,7 @@ struct cmd_results *cmd_unmark(int argc, char **argv) {
                }
        } else if (con && !mark) {
                // Clear all marks from the given container
-                container_clear_marks(con);
+                remove_mark(con);
-                container_update_marks_textures(con);
        } else if (!con && mark) {
                // Remove mark from whichever container has it
                container_find_and_unmark(mark);
diff --git a/sway/commands/workspace.c b/sway/commands/workspace.c
index a6a0beda..37a201b4 100644
--- a/sway/commands/workspace.c
+++ b/sway/commands/workspace.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <ctype.h>
 #include <limits.h>
 #include <string.h>
@@ -61,7 +60,7 @@ static struct cmd_results *cmd_workspace_gaps(int argc, char **argv,
        const char expected[] = "Expected 'workspace <name> gaps "
                "inner|outer|horizontal|vertical|top|right|bottom|left <px>'";
        if (gaps_location == 0) {
-                return cmd_results_new(CMD_INVALID, expected);
+                return cmd_results_new(CMD_INVALID, "%s", expected);
        }
        struct cmd_results *error = NULL;
        if ((error = checkarg(argc, "workspace", EXPECTED_EQUAL_TO,
@@ -79,7 +78,7 @@ static struct cmd_results *cmd_workspace_gaps(int argc, char **argv,
        char *end;
        int amount = strtol(argv[gaps_location + 2], &end, 10);
        if (strlen(end)) {
-                return cmd_results_new(CMD_FAILURE, expected);
+                return cmd_results_new(CMD_FAILURE, "%s", expected);
        }
        bool valid = false;
@@ -110,7 +109,7 @@ static struct cmd_results *cmd_workspace_gaps(int argc, char **argv,
                }
        }
        if (!valid) {
-                return cmd_results_new(CMD_INVALID, expected);
+                return cmd_results_new(CMD_INVALID, "%s", expected);
        }
        // Prevent invalid gaps configurations.
@@ -158,6 +157,10 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
                        return cmd_results_new(CMD_FAILURE,
                                        "Unable to allocate workspace output");
                }
+                if (output_location + 1 < argc) {
+                        list_free_items_and_destroy(wsc->outputs);
+                        wsc->outputs = create_list();
+                }
                for (int i = output_location + 1; i < argc; ++i) {
                        list_add(wsc->outputs, strdup(argv[i]));
                }
@@ -174,7 +177,7 @@ struct cmd_results *cmd_workspace(int argc, char **argv) {
                }
                if (root->fullscreen_global) {
-                        return cmd_results_new(CMD_FAILURE, "workspace",
+                        return cmd_results_new(CMD_FAILURE,
                                "Can't switch workspaces while fullscreen global");
                }
diff --git a/sway/commands/xwayland.c b/sway/commands/xwayland.c
index 6ca26923..c0b175fc 100644
--- a/sway/commands/xwayland.c
+++ b/sway/commands/xwayland.c
@@ -10,7 +10,7 @@ struct cmd_results *cmd_xwayland(int argc, char **argv) {
                return error;
        }
-#ifdef HAVE_XWAYLAND
+#ifdef WLR_HAS_XWAYLAND
        enum xwayland_mode xwayland;
        if (strcmp(argv[0], "force") == 0) {
                xwayland = XWAYLAND_MODE_IMMEDIATE;
@@ -20,6 +20,8 @@ struct cmd_results *cmd_xwayland(int argc, char **argv) {
                xwayland = XWAYLAND_MODE_DISABLED;
        }
+        // config->xwayland is reset to the previous value on reload in
+        // load_main_config()
        if (config->reloading && config->xwayland != xwayland) {
                return cmd_results_new(CMD_FAILURE,
                                "xwayland can only be enabled/disabled at launch");
diff --git a/sway/config.c b/sway/config.c
index fde386c7..f9131e0f 100644
--- a/sway/config.c
+++ b/sway/config.c
@@ -1,3 +1,4 @@
+#undef _POSIX_C_SOURCE
 #define _XOPEN_SOURCE 700 // for realpath
 #include <stdio.h>
 #include <stdbool.h>
@@ -36,19 +37,26 @@
 struct sway_config *config = NULL;
 static struct xkb_state *keysym_translation_state_create(
-                struct xkb_rule_names rules) {
+                struct xkb_rule_names rules, uint32_t context_flags) {
-        struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+        struct xkb_context *context = xkb_context_new(context_flags | XKB_CONTEXT_NO_SECURE_GETENV);
        struct xkb_keymap *xkb_keymap = xkb_keymap_new_from_names(
                context,
                &rules,
                XKB_KEYMAP_COMPILE_NO_FLAGS);
        xkb_context_unref(context);
+        if (xkb_keymap == NULL) {
+                sway_log(SWAY_ERROR, "Failed to compile keysym translation XKB keymap");
+                return NULL;
+        }
        return xkb_state_new(xkb_keymap);
 }
 static void keysym_translation_state_destroy(
                struct xkb_state *state) {
+        if (state == NULL) {
+                return;
+        }
        xkb_keymap_unref(xkb_state_get_keymap(state));
        xkb_state_unref(state);
 }
@@ -82,6 +90,12 @@ static void free_mode(struct sway_mode *mode) {
                }
                list_free(mode->switch_bindings);
        }
+        if (mode->gesture_bindings) {
+                for (int i = 0; i < mode->gesture_bindings->length; i++) {
+                        free_gesture_binding(mode->gesture_bindings->items[i]);
+                }
+                list_free(mode->gesture_bindings);
+        }
        free(mode);
 }
@@ -222,6 +236,7 @@ static void config_defaults(struct sway_config *config) {
        if (!(config->current_mode->keycode_bindings = create_list())) goto cleanup;
        if (!(config->current_mode->mouse_bindings = create_list())) goto cleanup;
        if (!(config->current_mode->switch_bindings = create_list())) goto cleanup;
+        if (!(config->current_mode->gesture_bindings = create_list())) goto cleanup;
        list_add(config->modes, config->current_mode);
        config->floating_mod = 0;
@@ -236,7 +251,7 @@ static void config_defaults(struct sway_config *config) {
        config->default_layout = L_NONE;
        config->default_orientation = L_NONE;
        if (!(config->font = strdup("monospace 10"))) goto cleanup;
-        config->font_height = 17; // height of monospace 10
+        config->font_description = pango_font_description_from_string(config->font);
        config->urgent_timeout = 500;
        config->focus_on_window_activation = FOWA_URGENT;
        config->popup_during_fullscreen = POPUP_SMART;
@@ -266,8 +281,9 @@ static void config_defaults(struct sway_config *config) {
        config->title_align = ALIGN_LEFT;
        config->tiling_drag = true;
        config->tiling_drag_threshold = 9;
+        config->primary_selection = true;
-        config->smart_gaps = false;
+        config->smart_gaps = SMART_GAPS_OFF;
        config->gaps_inner = 0;
        config->gaps_outer.top = 0;
        config->gaps_outer.right = 0;
@@ -291,6 +307,8 @@ static void config_defaults(struct sway_config *config) {
        config->hide_edge_borders_smart = ESMART_OFF;
        config->hide_lone_tab = false;
+        config->has_focused_tab_title = false;
        // border colors
        color_to_rgba(config->border_colors.focused.border, 0x4C7899FF);
        color_to_rgba(config->border_colors.focused.background, 0x285577FF);
@@ -326,8 +344,14 @@ static void config_defaults(struct sway_config *config) {
        // The keysym to keycode translation
        struct xkb_rule_names rules = {0};
-        config->keysym_translation_state =
+        config->keysym_translation_state = keysym_translation_state_create(rules, 0);
-                keysym_translation_state_create(rules);
+        if (config->keysym_translation_state == NULL) {
+                config->keysym_translation_state = keysym_translation_state_create(rules,
+                        XKB_CONTEXT_NO_ENVIRONMENT_NAMES);
+        }
+        if (config->keysym_translation_state == NULL) {
+                goto cleanup;
+        }
        return;
 cleanup:
@@ -342,13 +366,7 @@ static char *config_path(const char *prefix, const char *config_folder) {
        if (!prefix || !prefix[0] || !config_folder || !config_folder[0]) {
                return NULL;
        }
+        return format_str("%s/%s/config", prefix, config_folder);
-        const char *filename = "config";
-        size_t size = 3 + strlen(prefix) + strlen(config_folder) + strlen(filename);
-        char *path = calloc(size, sizeof(char));
-        snprintf(path, size, "%s/%s/%s", prefix, config_folder, filename);
-        return path;
 }
 static char *get_config_path(void) {
@@ -358,10 +376,7 @@ static char *get_config_path(void) {
        const char *config_home = getenv("XDG_CONFIG_HOME");
        if ((config_home == NULL || config_home[0] == '\0') && home != NULL) {
-                size_t size_fallback = 1 + strlen(home) + strlen("/.config");
+                config_home_fallback = format_str("%s/.config", home);
-                config_home_fallback = calloc(size_fallback, sizeof(char));
-                if (config_home_fallback != NULL)
-                        snprintf(config_home_fallback, size_fallback, "%s/.config", home);
                config_home = config_home_fallback;
        }
@@ -465,6 +480,11 @@ bool load_main_config(const char *file, bool is_active, bool validating) {
                                old_config->xwayland ? "enabled" : "disabled");
                config->xwayland = old_config->xwayland;
+                // primary_selection can only be enabled/disabled at launch
+                sway_log(SWAY_DEBUG, "primary_selection will remain %s",
+                                old_config->primary_selection ? "enabled" : "disabled");
+                config->primary_selection = old_config->primary_selection;
                if (!config->validating) {
                        if (old_config->swaybg_client != NULL) {
                                wl_client_destroy(old_config->swaybg_client);
@@ -484,56 +504,7 @@ bool load_main_config(const char *file, bool is_active, bool validating) {
        config->reading = true;
-        // Read security configs
+        bool success = load_config(path, config, &config->swaynag_config_errors);
-        // TODO: Security
-        bool success = true;
-        /*
-        DIR *dir = opendir(SYSCONFDIR "/sway/security.d");
-        if (!dir) {
-                sway_log(SWAY_ERROR,
-                        "%s does not exist, sway will have no security configuration"
-                        " and will probably be broken", SYSCONFDIR "/sway/security.d");
-        } else {
-                list_t *secconfigs = create_list();
-                char *base = SYSCONFDIR "/sway/security.d/";
-                struct dirent *ent = readdir(dir);
-                struct stat s;
-                while (ent != NULL) {
-                        char *_path = malloc(strlen(ent->d_name) + strlen(base) + 1);
-                        strcpy(_path, base);
-                        strcat(_path, ent->d_name);
-                        lstat(_path, &s);
-                        if (S_ISREG(s.st_mode) && ent->d_name[0] != '.') {
-                                list_add(secconfigs, _path);
-                        }
-                        else {
-                                free(_path);
-                        }
-                        ent = readdir(dir);
-                }
-                closedir(dir);
-                list_qsort(secconfigs, qstrcmp);
-                for (int i = 0; i < secconfigs->length; ++i) {
-                        char *_path = secconfigs->items[i];
-                        if (stat(_path, &s) || s.st_uid != 0 || s.st_gid != 0 ||
-                                        (((s.st_mode & 0777) != 0644) &&
-                                        (s.st_mode & 0777) != 0444)) {
-                                sway_log(SWAY_ERROR,
-                                        "Refusing to load %s - it must be owned by root "
-                                        "and mode 644 or 444", _path);
-                                success = false;
-                        } else {
-                                success = success && load_config(_path, config);
-                        }
-                }
-                list_free_items_and_destroy(secconfigs);
-        }
-        */
-        success = success && load_config(path, config,
-                        &config->swaynag_config_errors);
        if (validating) {
                free_config(config);
@@ -541,6 +512,9 @@ bool load_main_config(const char *file, bool is_active, bool validating) {
                return success;
        }
+        // Only really necessary if not explicitly `font` is set in the config.
+        config_update_font_height();
        if (is_active && !validating) {
                input_manager_verify_fallback_seat();
@@ -558,7 +532,7 @@ bool load_main_config(const char *file, bool is_active, bool validating) {
                }
                sway_switch_retrigger_bindings_for_all();
-                reset_outputs();
+                apply_all_output_configs();
                spawn_swaybg();
                config->reloading = false;
@@ -911,23 +885,18 @@ void config_add_swaynag_warning(char *fmt, ...) {
        if (config->reading && !config->validating) {
                va_list args;
                va_start(args, fmt);
-                size_t length = vsnprintf(NULL, 0, fmt, args) + 1;
+                char *str = vformat_str(fmt, args);
                va_end(args);
+                if (str == NULL) {
-                char *temp = malloc(length + 1);
-                if (!temp) {
-                        sway_log(SWAY_ERROR, "Failed to allocate buffer for warning.");
                        return;
                }
-                va_start(args, fmt);
-                vsnprintf(temp, length, fmt, args);
-                va_end(args);
                swaynag_log(config->swaynag_command, &config->swaynag_config_errors,
                        "Warning on line %i (%s) '%s': %s",
                        config->current_config_line_number, config->current_config_path,
-                        config->current_config_line, temp);
+                        config->current_config_line, str);
+                free(str);
        }
 }
@@ -967,7 +936,7 @@ char *do_var_replacement(char *str) {
                                int offset = find - str;
                                strncpy(newptr, str, offset);
                                newptr += offset;
-                                strncpy(newptr, var->value, vvlen);
+                                memcpy(newptr, var->value, vvlen);
                                newptr += vvlen;
                                strcpy(newptr, find + vnlen);
                                free(str);
@@ -991,31 +960,11 @@ int workspace_output_cmp_workspace(const void *a, const void *b) {
        return lenient_strcmp(wsa->workspace, wsb->workspace);
 }
-static void find_font_height_iterator(struct sway_container *con, void *data) {
-        size_t amount_below_baseline = con->title_height - con->title_baseline;
-        size_t extended_height = config->font_baseline + amount_below_baseline;
-        if (extended_height > config->font_height) {
-                config->font_height = extended_height;
-        }
-}
-static void find_baseline_iterator(struct sway_container *con, void *data) {
-        bool *recalculate = data;
-        if (*recalculate) {
-                container_calculate_title_height(con);
-        }
-        if (con->title_baseline > config->font_baseline) {
-                config->font_baseline = con->title_baseline;
-        }
-}
-void config_update_font_height(bool recalculate) {
+void config_update_font_height(void) {
-        size_t prev_max_height = config->font_height;
+        int prev_max_height = config->font_height;
-        config->font_height = 0;
-        config->font_baseline = 0;
-        root_for_each_container(find_baseline_iterator, &recalculate);
+        get_text_metrics(config->font_description, &config->font_height, &config->font_baseline);
-        root_for_each_container(find_font_height_iterator, NULL);
        if (config->font_height != prev_max_height) {
                arrange_root();
@@ -1049,8 +998,12 @@ void translate_keysyms(struct input_config *input_config) {
        struct xkb_rule_names rules = {0};
        input_config_fill_rule_names(input_config, &rules);
-        config->keysym_translation_state =
+        config->keysym_translation_state = keysym_translation_state_create(rules, 0);
-                keysym_translation_state_create(rules);
+        if (config->keysym_translation_state == NULL) {
+                sway_log(SWAY_ERROR, "Failed to create keysym translation XKB state "
+                        "for device '%s'", input_config->identifier);
+                return;
+        }
        for (int i = 0; i < config->modes->length; ++i) {
                struct sway_mode *mode = config->modes->items[i];
diff --git a/sway/config/bar.c b/sway/config/bar.c
index e09add44..908b2865 100644
--- a/sway/config/bar.c
+++ b/sway/config/bar.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <signal.h>
 #include <stdbool.h>
 #include <stdio.h>
@@ -219,6 +218,8 @@ static void invoke_swaybar(struct bar_config *bar) {
                sigprocmask(SIG_SETMASK, &set, NULL);
                signal(SIGPIPE, SIG_DFL);
+                restore_nofile_limit();
                pid = fork();
                if (pid < 0) {
                        sway_log_errno(SWAY_ERROR, "fork failed");
@@ -254,7 +255,6 @@ static void invoke_swaybar(struct bar_config *bar) {
        }
        sway_log(SWAY_DEBUG, "Spawned swaybar %s", bar->id);
-        return;
 }
 void load_swaybar(struct bar_config *bar) {
diff --git a/sway/config/input.c b/sway/config/input.c
index a998e170..de3b21ed 100644
--- a/sway/config/input.c
+++ b/sway/config/input.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdlib.h>
 #include <limits.h>
 #include <float.h>
@@ -25,14 +24,17 @@ struct input_config *new_input_config(const char* identifier) {
        input->drag = INT_MIN;
        input->drag_lock = INT_MIN;
        input->dwt = INT_MIN;
+        input->dwtp = INT_MIN;
        input->send_events = INT_MIN;
        input->click_method = INT_MIN;
        input->middle_emulation = INT_MIN;
        input->natural_scroll = INT_MIN;
        input->accel_profile = INT_MIN;
+        input->rotation_angle = FLT_MIN;
        input->pointer_accel = FLT_MIN;
        input->scroll_factor = FLT_MIN;
        input->scroll_button = INT_MIN;
+        input->scroll_button_lock = INT_MIN;
        input->scroll_method = INT_MIN;
        input->left_handed = INT_MIN;
        input->repeat_delay = INT_MIN;
@@ -61,6 +63,9 @@ void merge_input_config(struct input_config *dst, struct input_config *src) {
        if (src->dwt != INT_MIN) {
                dst->dwt = src->dwt;
        }
+        if (src->dwtp != INT_MIN) {
+                dst->dwtp = src->dwtp;
+        }
        if (src->left_handed != INT_MIN) {
                dst->left_handed = src->left_handed;
        }
@@ -70,6 +75,9 @@ void merge_input_config(struct input_config *dst, struct input_config *src) {
        if (src->natural_scroll != INT_MIN) {
                dst->natural_scroll = src->natural_scroll;
        }
+        if (src->rotation_angle != FLT_MIN) {
+                dst->rotation_angle = src->rotation_angle;
+        }
        if (src->pointer_accel != FLT_MIN) {
                dst->pointer_accel = src->pointer_accel;
        }
@@ -88,6 +96,9 @@ void merge_input_config(struct input_config *dst, struct input_config *src) {
        if (src->scroll_button != INT_MIN) {
                dst->scroll_button = src->scroll_button;
        }
+        if (src->scroll_button_lock != INT_MIN) {
+                dst->scroll_button_lock = src->scroll_button_lock;
+        }
        if (src->send_events != INT_MIN) {
                dst->send_events = src->send_events;
        }
diff --git a/sway/config/output.c b/sway/config/output.c
index 7d0ed395..e7299459 100644
--- a/sway/config/output.c
+++ b/sway/config/output.c
@@ -1,13 +1,15 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
+#include <drm_fourcc.h>
 #include <stdbool.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <wlr/config.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_output.h>
+#include <wlr/types/wlr_output_swapchain_manager.h>
 #include "sway/config.h"
 #include "sway/input/cursor.h"
 #include "sway/output.h"
@@ -15,6 +17,10 @@
 #include "log.h"
 #include "util.h"
+#if WLR_HAS_DRM_BACKEND
+#include <wlr/backend/drm.h>
+#endif
 int output_name_cmp(const void *item, const void *data) {
        const struct output_config *output = item;
        const char *name = data;
@@ -25,8 +31,10 @@ int output_name_cmp(const void *item, const void *data) {
 void output_get_identifier(char *identifier, size_t len,
                struct sway_output *output) {
        struct wlr_output *wlr_output = output->wlr_output;
-        snprintf(identifier, len, "%s %s %s", wlr_output->make, wlr_output->model,
+        snprintf(identifier, len, "%s %s %s",
-                wlr_output->serial);
+                wlr_output->make ? wlr_output->make : "Unknown",
+                wlr_output->model ? wlr_output->model : "Unknown",
+                wlr_output->serial ? wlr_output->serial : "Unknown");
 }
 const char *sway_output_scale_filter_to_string(enum scale_filter_mode scale_filter) {
@@ -58,6 +66,7 @@ struct output_config *new_output_config(const char *name) {
        oc->width = oc->height = -1;
        oc->refresh_rate = -1;
        oc->custom_mode = -1;
+        oc->drm_mode.type = -1;
        oc->x = oc->y = -1;
        oc->scale = -1;
        oc->scale_filter = SCALE_FILTER_DEFAULT;
@@ -65,10 +74,77 @@ struct output_config *new_output_config(const char *name) {
        oc->subpixel = WL_OUTPUT_SUBPIXEL_UNKNOWN;
        oc->max_render_time = -1;
        oc->adaptive_sync = -1;
+        oc->render_bit_depth = RENDER_BIT_DEPTH_DEFAULT;
+        oc->power = -1;
        return oc;
 }
-void merge_output_config(struct output_config *dst, struct output_config *src) {
+// supersede_output_config clears all fields in dst that were set in src
+static void supersede_output_config(struct output_config *dst, struct output_config *src) {
+        if (src->enabled != -1) {
+                dst->enabled = -1;
+        }
+        if (src->width != -1) {
+                dst->width = -1;
+        }
+        if (src->height != -1) {
+                dst->height = -1;
+        }
+        if (src->x != -1) {
+                dst->x = -1;
+        }
+        if (src->y != -1) {
+                dst->y = -1;
+        }
+        if (src->scale != -1) {
+                dst->scale = -1;
+        }
+        if (src->scale_filter != SCALE_FILTER_DEFAULT) {
+                dst->scale_filter = SCALE_FILTER_DEFAULT;
+        }
+        if (src->subpixel != WL_OUTPUT_SUBPIXEL_UNKNOWN) {
+                dst->subpixel = WL_OUTPUT_SUBPIXEL_UNKNOWN;
+        }
+        if (src->refresh_rate != -1) {
+                dst->refresh_rate = -1;
+        }
+        if (src->custom_mode != -1) {
+                dst->custom_mode = -1;
+        }
+        if (src->drm_mode.type != (uint32_t) -1) {
+                dst->drm_mode.type = -1;
+        }
+        if (src->transform != -1) {
+                dst->transform = -1;
+        }
+        if (src->max_render_time != -1) {
+                dst->max_render_time = -1;
+        }
+        if (src->adaptive_sync != -1) {
+                dst->adaptive_sync = -1;
+        }
+        if (src->render_bit_depth != RENDER_BIT_DEPTH_DEFAULT) {
+                dst->render_bit_depth = RENDER_BIT_DEPTH_DEFAULT;
+        }
+        if (src->background) {
+                free(dst->background);
+                dst->background = NULL;
+        }
+        if (src->background_option) {
+                free(dst->background_option);
+                dst->background_option = NULL;
+        }
+        if (src->background_fallback) {
+                free(dst->background_fallback);
+                dst->background_fallback = NULL;
+        }
+        if (src->power != -1) {
+                dst->power = -1;
+        }
+}
+// merge_output_config sets all fields in dst that were set in src
+static void merge_output_config(struct output_config *dst, struct output_config *src) {
        if (src->enabled != -1) {
                dst->enabled = src->enabled;
        }
@@ -99,6 +175,9 @@ void merge_output_config(struct output_config *dst, struct output_config *src) {
        if (src->custom_mode != -1) {
                dst->custom_mode = src->custom_mode;
        }
+        if (src->drm_mode.type != (uint32_t) -1) {
+                memcpy(&dst->drm_mode, &src->drm_mode, sizeof(src->drm_mode));
+        }
        if (src->transform != -1) {
                dst->transform = src->transform;
        }
@@ -108,6 +187,9 @@ void merge_output_config(struct output_config *dst, struct output_config *src) {
        if (src->adaptive_sync != -1) {
                dst->adaptive_sync = src->adaptive_sync;
        }
+        if (src->render_bit_depth != RENDER_BIT_DEPTH_DEFAULT) {
+                dst->render_bit_depth = src->render_bit_depth;
+        }
        if (src->background) {
                free(dst->background);
                dst->background = strdup(src->background);
@@ -120,155 +202,124 @@ void merge_output_config(struct output_config *dst, struct output_config *src) {
                free(dst->background_fallback);
                dst->background_fallback = strdup(src->background_fallback);
        }
-        if (src->dpms_state != 0) {
+        if (src->power != -1) {
-                dst->dpms_state = src->dpms_state;
+                dst->power = src->power;
        }
 }
-static void merge_wildcard_on_all(struct output_config *wildcard) {
+void store_output_config(struct output_config *oc) {
-        for (int i = 0; i < config->output_configs->length; i++) {
+        bool merged = false;
-                struct output_config *oc = config->output_configs->items[i];
+        bool wildcard = strcmp(oc->name, "*") == 0;
-                if (strcmp(wildcard->name, oc->name) != 0) {
+        struct sway_output *output = wildcard ? NULL : all_output_by_name_or_id(oc->name);
-                        sway_log(SWAY_DEBUG, "Merging output * config on %s", oc->name);
-                        merge_output_config(oc, wildcard);
-                }
-        }
-}
-static void merge_id_on_name(struct output_config *oc) {
-        char *id_on_name = NULL;
        char id[128];
-        char *name = NULL;
+        if (output) {
-        struct sway_output *output;
-        wl_list_for_each(output, &root->all_outputs, link) {
-                name = output->wlr_output->name;
                output_get_identifier(id, sizeof(id), output);
-                if (strcmp(name, oc->name) == 0 || strcmp(id, oc->name) == 0) {
-                        size_t length = snprintf(NULL, 0, "%s on %s", id, name) + 1;
-                        id_on_name = malloc(length);
-                        if (!id_on_name) {
-                                sway_log(SWAY_ERROR, "Failed to allocate id on name string");
-                                return;
-                        }
-                        snprintf(id_on_name, length, "%s on %s", id, name);
-                        break;
-                }
        }
-        if (!id_on_name) {
+        for (int i = 0; i < config->output_configs->length; i++) {
-                return;
+                struct output_config *old = config->output_configs->items[i];
-        }
+                // If the old config matches the new config's name, regardless of
-        int i = list_seq_find(config->output_configs, output_name_cmp, id_on_name);
+                // whether it was name or identifier, merge on top of the existing
-        if (i >= 0) {
+                // config. If the new config is a wildcard, this also merges on top of
-                sway_log(SWAY_DEBUG, "Merging on top of existing id on name config");
+                // old wildcard configs.
-                merge_output_config(config->output_configs->items[i], oc);
+                if (strcmp(old->name, oc->name) == 0) {
-        } else {
+                        merge_output_config(old, oc);
-                // If both a name and identifier config, exist generate an id on name
+                        merged = true;
-                int ni = list_seq_find(config->output_configs, output_name_cmp, name);
+                        continue;
-                int ii = list_seq_find(config->output_configs, output_name_cmp, id);
-                if ((ni >= 0 && ii >= 0) || (ni >= 0 && strcmp(oc->name, id) == 0)
-                                || (ii >= 0 && strcmp(oc->name, name) == 0)) {
-                        struct output_config *ion_oc = new_output_config(id_on_name);
-                        if (ni >= 0) {
-                                merge_output_config(ion_oc, config->output_configs->items[ni]);
-                        }
-                        if (ii >= 0) {
-                                merge_output_config(ion_oc, config->output_configs->items[ii]);
-                        }
-                        merge_output_config(ion_oc, oc);
-                        list_add(config->output_configs, ion_oc);
-                        sway_log(SWAY_DEBUG, "Generated id on name output config \"%s\""
-                                " (enabled: %d) (%dx%d@%fHz position %d,%d scale %f "
-                                "transform %d) (bg %s %s) (dpms %d) (max render time: %d)",
-                                ion_oc->name, ion_oc->enabled, ion_oc->width, ion_oc->height,
-                                ion_oc->refresh_rate, ion_oc->x, ion_oc->y, ion_oc->scale,
-                                ion_oc->transform, ion_oc->background,
-                                ion_oc->background_option, ion_oc->dpms_state,
-                                ion_oc->max_render_time);
                }
-        }
-        free(id_on_name);
-}
-struct output_config *store_output_config(struct output_config *oc) {
+                // If the new config is a wildcard config we supersede all non-wildcard
-        bool wildcard = strcmp(oc->name, "*") == 0;
+                // configs. Old wildcard configs have already been handled above.
-        if (wildcard) {
+                if (wildcard) {
-                merge_wildcard_on_all(oc);
+                        supersede_output_config(old, oc);
-        } else {
+                        continue;
-                merge_id_on_name(oc);
+                }
-        }
-        int i = list_seq_find(config->output_configs, output_name_cmp, oc->name);
+                // If the new config matches an output's name, and the old config
-        if (i >= 0) {
+                // matches on that output's identifier, supersede it.
-                sway_log(SWAY_DEBUG, "Merging on top of existing output config");
+                if (output && strcmp(old->name, id) == 0 &&
-                struct output_config *current = config->output_configs->items[i];
+                                strcmp(oc->name, output->wlr_output->name) == 0) {
-                merge_output_config(current, oc);
+                        supersede_output_config(old, oc);
-                free_output_config(oc);
-                oc = current;
-        } else if (!wildcard) {
-                sway_log(SWAY_DEBUG, "Adding non-wildcard output config");
-                i = list_seq_find(config->output_configs, output_name_cmp, "*");
-                if (i >= 0) {
-                        sway_log(SWAY_DEBUG, "Merging on top of output * config");
-                        struct output_config *current = new_output_config(oc->name);
-                        merge_output_config(current, config->output_configs->items[i]);
-                        merge_output_config(current, oc);
-                        free_output_config(oc);
-                        oc = current;
                }
-                list_add(config->output_configs, oc);
-        } else {
-                // New wildcard config. Just add it
-                sway_log(SWAY_DEBUG, "Adding output * config");
-                list_add(config->output_configs, oc);
        }
        sway_log(SWAY_DEBUG, "Config stored for output %s (enabled: %d) (%dx%d@%fHz "
-                "position %d,%d scale %f subpixel %s transform %d) (bg %s %s) (dpms %d) "
+                "position %d,%d scale %f subpixel %s transform %d) (bg %s %s) (power %d) "
                "(max render time: %d)",
                oc->name, oc->enabled, oc->width, oc->height, oc->refresh_rate,
                oc->x, oc->y, oc->scale, sway_wl_output_subpixel_to_string(oc->subpixel),
-                oc->transform, oc->background, oc->background_option, oc->dpms_state,
+                oc->transform, oc->background, oc->background_option, oc->power,
                oc->max_render_time);
-        return oc;
+        // If the configuration was not merged into an existing configuration, add
+        // it to the list. Otherwise we're done with it and can free it.
+        if (!merged) {
+                list_add(config->output_configs, oc);
+        } else {
+                free_output_config(oc);
+        }
 }
-static void set_mode(struct wlr_output *output, int width, int height,
+static void set_mode(struct wlr_output *output, struct wlr_output_state *pending,
-                float refresh_rate, bool custom) {
+                int width, int height, float refresh_rate, bool custom) {
        // Not all floating point integers can be represented exactly
        // as (int)(1000 * mHz / 1000.f)
        // round() the result to avoid any error
-        int mhz = (int)round(refresh_rate * 1000);
+        int mhz = (int)roundf(refresh_rate * 1000);
+        // If no target refresh rate is given, match highest available
+        mhz = mhz <= 0 ? INT_MAX : mhz;
        if (wl_list_empty(&output->modes) || custom) {
                sway_log(SWAY_DEBUG, "Assigning custom mode to %s", output->name);
-                wlr_output_set_custom_mode(output, width, height,
+                wlr_output_state_set_custom_mode(pending, width, height,
                        refresh_rate > 0 ? mhz : 0);
                return;
        }
        struct wlr_output_mode *mode, *best = NULL;
+        int best_diff_mhz = INT_MAX;
        wl_list_for_each(mode, &output->modes, link) {
                if (mode->width == width && mode->height == height) {
-                        if (mode->refresh == mhz) {
+                        int diff_mhz = abs(mode->refresh - mhz);
-                                best = mode;
+                        if (diff_mhz < best_diff_mhz) {
-                                break;
+                                best_diff_mhz = diff_mhz;
-                        }
-                        if (best == NULL || mode->refresh > best->refresh) {
                                best = mode;
+                                if (best_diff_mhz == 0) {
+                                        break;
+                                }
                        }
                }
        }
-        if (!best) {
+        if (best) {
-                sway_log(SWAY_ERROR, "Configured mode for %s not available", output->name);
+                sway_log(SWAY_INFO, "Assigning configured mode (%dx%d@%.3fHz) to %s",
-                sway_log(SWAY_INFO, "Picking preferred mode instead");
+                        best->width, best->height, best->refresh / 1000.f, output->name);
-                best = wlr_output_preferred_mode(output);
        } else {
-                sway_log(SWAY_DEBUG, "Assigning configured mode to %s", output->name);
+                best = wlr_output_preferred_mode(output);
+                sway_log(SWAY_INFO, "Configured mode (%dx%d@%.3fHz) not available, "
+                        "applying preferred mode (%dx%d@%.3fHz)",
+                        width, height, refresh_rate,
+                        best->width, best->height, best->refresh / 1000.f);
+        }
+        wlr_output_state_set_mode(pending, best);
+}
+static void set_modeline(struct wlr_output *output,
+                struct wlr_output_state *pending, drmModeModeInfo *drm_mode) {
+#if WLR_HAS_DRM_BACKEND
+        if (!wlr_output_is_drm(output)) {
+                sway_log(SWAY_ERROR, "Modeline can only be set to DRM output");
+                return;
        }
-        wlr_output_set_mode(output, best);
+        sway_log(SWAY_DEBUG, "Assigning custom modeline to %s", output->name);
+        struct wlr_output_mode *mode = wlr_drm_connector_add_mode(output, drm_mode);
+        if (mode) {
+                wlr_output_state_set_mode(pending, mode);
+        }
+#else
+        sway_log(SWAY_ERROR, "Modeline can only be set to DRM output");
+#endif
 }
 /* Some manufacturers hardcode the aspect-ratio of the output in the physical
@@ -289,23 +340,24 @@ static bool phys_size_is_aspect_ratio(struct wlr_output *output) {
 // 1 inch = 25.4 mm
 #define MM_PER_INCH 25.4
-static int compute_default_scale(struct wlr_output *output) {
+static int compute_default_scale(struct wlr_output *output,
+                struct wlr_output_state *pending) {
        struct wlr_box box = { .width = output->width, .height = output->height };
-        if (output->pending.committed & WLR_OUTPUT_STATE_MODE) {
+        if (pending->committed & WLR_OUTPUT_STATE_MODE) {
-                switch (output->pending.mode_type) {
+                switch (pending->mode_type) {
                case WLR_OUTPUT_STATE_MODE_FIXED:
-                        box.width = output->pending.mode->width;
+                        box.width = pending->mode->width;
-                        box.height = output->pending.mode->height;
+                        box.height = pending->mode->height;
                        break;
                case WLR_OUTPUT_STATE_MODE_CUSTOM:
-                        box.width = output->pending.custom_mode.width;
+                        box.width = pending->custom_mode.width;
-                        box.height = output->pending.custom_mode.height;
+                        box.height = pending->custom_mode.height;
                        break;
                }
        }
        enum wl_output_transform transform = output->transform;
-        if (output->pending.committed & WLR_OUTPUT_STATE_TRANSFORM) {
+        if (pending->committed & WLR_OUTPUT_STATE_TRANSFORM) {
-                transform = output->pending.transform;
+                transform = pending->transform;
        }
        wlr_box_transform(&box, &box, transform, box.width, box.height);
@@ -334,42 +386,70 @@ static int compute_default_scale(struct wlr_output *output) {
        return 2;
 }
+static bool render_format_is_10bit(uint32_t render_format) {
+        return render_format == DRM_FORMAT_XRGB2101010 ||
+                render_format == DRM_FORMAT_XBGR2101010;
+}
+static bool render_format_is_bgr(uint32_t fmt) {
+        return fmt == DRM_FORMAT_XBGR2101010 || fmt == DRM_FORMAT_XBGR8888;
+}
+static bool output_config_is_disabling(struct output_config *oc) {
+        return oc && (!oc->enabled || oc->power == 0);
+}
 static void queue_output_config(struct output_config *oc,
-                struct sway_output *output) {
+                struct sway_output *output, struct wlr_output_state *pending) {
-        if (output == root->noop_output) {
+        if (output == root->fallback_output) {
                return;
        }
        struct wlr_output *wlr_output = output->wlr_output;
-        if (oc && (!oc->enabled || oc->dpms_state == DPMS_OFF)) {
+        if (output_config_is_disabling(oc)) {
                sway_log(SWAY_DEBUG, "Turning off output %s", wlr_output->name);
-                wlr_output_enable(wlr_output, false);
+                wlr_output_state_set_enabled(pending, false);
                return;
        }
        sway_log(SWAY_DEBUG, "Turning on output %s", wlr_output->name);
-        wlr_output_enable(wlr_output, true);
+        wlr_output_state_set_enabled(pending, true);
-        if (oc && oc->width > 0 && oc->height > 0) {
+        if (oc && oc->drm_mode.type != 0 && oc->drm_mode.type != (uint32_t) -1) {
+                sway_log(SWAY_DEBUG, "Set %s modeline",
+                        wlr_output->name);
+                set_modeline(wlr_output, pending, &oc->drm_mode);
+        } else if (oc && oc->width > 0 && oc->height > 0) {
                sway_log(SWAY_DEBUG, "Set %s mode to %dx%d (%f Hz)",
                        wlr_output->name, oc->width, oc->height, oc->refresh_rate);
-                set_mode(wlr_output, oc->width, oc->height,
+                set_mode(wlr_output, pending, oc->width, oc->height,
                        oc->refresh_rate, oc->custom_mode == 1);
        } else if (!wl_list_empty(&wlr_output->modes)) {
-                struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output);
+                sway_log(SWAY_DEBUG, "Set preferred mode");
-                wlr_output_set_mode(wlr_output, mode);
+                struct wlr_output_mode *preferred_mode =
+                        wlr_output_preferred_mode(wlr_output);
+                wlr_output_state_set_mode(pending, preferred_mode);
        }
        if (oc && (oc->subpixel != WL_OUTPUT_SUBPIXEL_UNKNOWN || config->reloading)) {
                sway_log(SWAY_DEBUG, "Set %s subpixel to %s", oc->name,
                        sway_wl_output_subpixel_to_string(oc->subpixel));
-                wlr_output_set_subpixel(wlr_output, oc->subpixel);
+                wlr_output_state_set_subpixel(pending, oc->subpixel);
        }
+        enum wl_output_transform tr = WL_OUTPUT_TRANSFORM_NORMAL;
        if (oc && oc->transform >= 0) {
-                sway_log(SWAY_DEBUG, "Set %s transform to %d", oc->name, oc->transform);
+                tr = oc->transform;
-                wlr_output_set_transform(wlr_output, oc->transform);
+#if WLR_HAS_DRM_BACKEND
+        } else if (wlr_output_is_drm(wlr_output)) {
+                tr = wlr_drm_connector_get_panel_orientation(wlr_output);
+                sway_log(SWAY_DEBUG, "Auto-detected output transform: %d", tr);
+#endif
+        }
+        if (wlr_output->transform != tr) {
+                sway_log(SWAY_DEBUG, "Set %s transform to %d", wlr_output->name, tr);
+                wlr_output_state_set_transform(pending, tr);
        }
        // Apply the scale last before the commit, because the scale auto-detection
@@ -377,50 +457,50 @@ static void queue_output_config(struct output_config *oc,
        float scale;
        if (oc && oc->scale > 0) {
                scale = oc->scale;
+                // The factional-scale-v1 protocol uses increments of 120ths to send
+                // the scale factor to the client. Adjust the scale so that we use the
+                // same value as the clients'.
+                float adjusted_scale = round(scale * 120) / 120;
+                if (scale != adjusted_scale) {
+                        sway_log(SWAY_INFO, "Adjusting output scale from %f to %f",
+                                scale, adjusted_scale);
+                        scale = adjusted_scale;
+                }
        } else {
-                scale = compute_default_scale(wlr_output);
+                scale = compute_default_scale(wlr_output, pending);
                sway_log(SWAY_DEBUG, "Auto-detected output scale: %f", scale);
        }
        if (scale != wlr_output->scale) {
                sway_log(SWAY_DEBUG, "Set %s scale to %f", wlr_output->name, scale);
-                wlr_output_set_scale(wlr_output, scale);
+                wlr_output_state_set_scale(pending, scale);
        }
        if (oc && oc->adaptive_sync != -1) {
                sway_log(SWAY_DEBUG, "Set %s adaptive sync to %d", wlr_output->name,
                        oc->adaptive_sync);
-                wlr_output_enable_adaptive_sync(wlr_output, oc->adaptive_sync == 1);
+                wlr_output_state_set_adaptive_sync_enabled(pending, oc->adaptive_sync == 1);
-        }
-}
-bool apply_output_config(struct output_config *oc, struct sway_output *output) {
-        if (output == root->noop_output) {
-                return false;
        }
-        struct wlr_output *wlr_output = output->wlr_output;
+        if (oc && oc->render_bit_depth != RENDER_BIT_DEPTH_DEFAULT) {
+                if (oc->render_bit_depth == RENDER_BIT_DEPTH_10 &&
-        // Flag to prevent the output mode event handler from calling us
+                        render_format_is_10bit(output->wlr_output->render_format)) {
-        output->enabling = (!oc || oc->enabled);
+                        // 10-bit was set successfully before, try to save some tests by reusing the format
+                        wlr_output_state_set_render_format(pending, output->wlr_output->render_format);
-        queue_output_config(oc, output);
+                } else if (oc->render_bit_depth == RENDER_BIT_DEPTH_10) {
+                        wlr_output_state_set_render_format(pending, DRM_FORMAT_XRGB2101010);
-        if (!oc || oc->dpms_state != DPMS_OFF) {
+                } else {
-                output->current_mode = wlr_output->pending.mode;
+                        wlr_output_state_set_render_format(pending, DRM_FORMAT_XRGB8888);
+                }
        }
+}
-        sway_log(SWAY_DEBUG, "Committing output %s", wlr_output->name);
+static bool finalize_output_config(struct output_config *oc, struct sway_output *output) {
-        if (!wlr_output_commit(wlr_output)) {
+        if (output == root->fallback_output) {
-                // Failed to commit output changes, maybe the output is missing a CRTC.
-                // Leave the output disabled for now and try again when the output gets
-                // the mode we asked for.
-                sway_log(SWAY_ERROR, "Failed to commit output %s", wlr_output->name);
-                output->enabling = false;
                return false;
        }
-        output->enabling = false;
+        struct wlr_output *wlr_output = output->wlr_output;
        if (oc && !oc->enabled) {
                sway_log(SWAY_DEBUG, "Disabling output %s", oc->name);
                if (output->enabled) {
@@ -430,10 +510,6 @@ bool apply_output_config(struct output_config *oc, struct sway_output *output) {
                return true;
        }
-        if (config->reloading) {
-                output_damage_whole(output);
-        }
        if (oc) {
                enum scale_filter_mode scale_filter_old = output->scale_filter;
                switch (oc->scale_filter) {
@@ -450,6 +526,7 @@ bool apply_output_config(struct output_config *oc, struct sway_output *output) {
                if (scale_filter_old != output->scale_filter) {
                        sway_log(SWAY_DEBUG, "Set %s scale_filter to %s", oc->name,
                                sway_output_scale_filter_to_string(output->scale_filter));
+                        wlr_damage_ring_add_whole(&output->scene_output->damage_ring);
                }
        }
@@ -462,12 +539,12 @@ bool apply_output_config(struct output_config *oc, struct sway_output *output) {
        }
        // Update output->{lx, ly, width, height}
-        struct wlr_box *output_box =
+        struct wlr_box output_box;
-                wlr_output_layout_get_box(root->output_layout, wlr_output);
+        wlr_output_layout_get_box(root->output_layout, wlr_output, &output_box);
-        output->lx = output_box->x;
+        output->lx = output_box.x;
-        output->ly = output_box->y;
+        output->ly = output_box.y;
-        output->width = output_box->width;
+        output->width = output_box.width;
-        output->height = output_box->height;
+        output->height = output_box.height;
        if (!output->enabled) {
                output_enable(output);
@@ -479,29 +556,13 @@ bool apply_output_config(struct output_config *oc, struct sway_output *output) {
                output->max_render_time = oc->max_render_time;
        }
-        // Reconfigure all devices, since input config may have been applied before
-        // this output came online, and some config items (like map_to_output) are
-        // dependent on an output being present.
-        input_manager_configure_all_inputs();
-        // Reconfigure the cursor images, since the scale may have changed.
-        input_manager_configure_xcursor();
        return true;
 }
-bool test_output_config(struct output_config *oc, struct sway_output *output) {
-        if (output == root->noop_output) {
-                return false;
-        }
-        queue_output_config(oc, output);
-        bool ok = wlr_output_test(output->wlr_output);
-        wlr_output_rollback(output->wlr_output);
-        return ok;
-}
 static void default_output_config(struct output_config *oc,
                struct wlr_output *wlr_output) {
        oc->enabled = 1;
+        oc->power = 1;
        struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output);
        if (mode != NULL) {
                oc->width = mode->width;
@@ -514,147 +575,418 @@ static void default_output_config(struct output_config *oc,
        struct sway_output *output = wlr_output->data;
        oc->subpixel = output->detected_subpixel;
        oc->transform = WL_OUTPUT_TRANSFORM_NORMAL;
-        oc->dpms_state = DPMS_ON;
        oc->max_render_time = 0;
 }
-static struct output_config *get_output_config(char *identifier,
+// find_output_config returns a merged output_config containing all stored
-                struct sway_output *sway_output) {
+// configuration that applies to the specified output.
+struct output_config *find_output_config(struct sway_output *sway_output) {
        const char *name = sway_output->wlr_output->name;
+        struct output_config *oc = NULL;
+        struct output_config *result = new_output_config(name);
+        if (config->reloading) {
+                default_output_config(result, sway_output->wlr_output);
+        }
-        struct output_config *oc_id_on_name = NULL;
+        char id[128];
-        struct output_config *oc_name = NULL;
+        output_get_identifier(id, sizeof(id), sway_output);
-        struct output_config *oc_id = NULL;
-        size_t length = snprintf(NULL, 0, "%s on %s", identifier, name) + 1;
+        int i;
-        char *id_on_name = malloc(length);
+        bool match = false;
-        snprintf(id_on_name, length, "%s on %s", identifier, name);
+        if ((i = list_seq_find(config->output_configs, output_name_cmp, "*")) >= 0) {
-        int i = list_seq_find(config->output_configs, output_name_cmp, id_on_name);
+                match = true;
-        if (i >= 0) {
+                oc = config->output_configs->items[i];
-                oc_id_on_name = config->output_configs->items[i];
+                merge_output_config(result, oc);
-        } else {
+        }
-                i = list_seq_find(config->output_configs, output_name_cmp, name);
+        if ((i = list_seq_find(config->output_configs, output_name_cmp, name)) >= 0) {
-                if (i >= 0) {
+                match = true;
-                        oc_name = config->output_configs->items[i];
+                oc = config->output_configs->items[i];
+                merge_output_config(result, oc);
+        }
+        if ((i = list_seq_find(config->output_configs, output_name_cmp, id)) >= 0) {
+                match = true;
+                oc = config->output_configs->items[i];
+                merge_output_config(result, oc);
+        }
+        if (!match && !config->reloading) {
+                // No name, identifier, or wildcard config. Since we are not
+                // reloading with defaults, the output config will be empty, so
+                // just return NULL
+                free_output_config(result);
+                return NULL;
+        }
+        return result;
+}
+static bool config_has_auto_mode(struct output_config *oc) {
+        if (!oc) {
+                return true;
+        }
+        if (oc->drm_mode.type != 0 && oc->drm_mode.type != (uint32_t)-1) {
+                return true;
+        } else if (oc->width > 0 && oc->height > 0) {
+                return true;
+        }
+        return false;
+}
+struct search_context {
+        struct wlr_output_swapchain_manager *swapchain_mgr;
+        struct wlr_backend_output_state *states;
+        struct matched_output_config *configs;
+        size_t configs_len;
+        bool degrade_to_off;
+};
+static void dump_output_state(struct wlr_output *wlr_output, struct wlr_output_state *state) {
+        sway_log(SWAY_DEBUG, "Output state for %s", wlr_output->name);
+        if (state->committed & WLR_OUTPUT_STATE_ENABLED) {
+                sway_log(SWAY_DEBUG, "    enabled:       %s", state->enabled ? "yes" : "no");
+        }
+        if (state->committed & WLR_OUTPUT_STATE_RENDER_FORMAT) {
+                sway_log(SWAY_DEBUG, "    render_format: %d", state->render_format);
+        }
+        if (state->committed & WLR_OUTPUT_STATE_MODE) {
+                if (state->mode_type == WLR_OUTPUT_STATE_MODE_CUSTOM) {
+                        sway_log(SWAY_DEBUG, "    custom mode:   %dx%d@%dmHz",
+                                state->custom_mode.width, state->custom_mode.height, state->custom_mode.refresh);
+                } else {
+                        sway_log(SWAY_DEBUG, "    mode:          %dx%d@%dmHz%s",
+                                state->mode->width, state->mode->height, state->mode->refresh,
+                                state->mode->preferred ? " (preferred)" : "");
                }
+        }
+        if (state->committed & WLR_OUTPUT_STATE_ADAPTIVE_SYNC_ENABLED) {
+                sway_log(SWAY_DEBUG, "    adaptive_sync: %s",
+                        state->adaptive_sync_enabled ? "enabled": "disabled");
+        }
+}
+static bool search_valid_config(struct search_context *ctx, size_t output_idx);
+static void reset_output_state(struct wlr_output_state *state) {
+        wlr_output_state_finish(state);
+        wlr_output_state_init(state);
+        state->committed = 0;
+}
-                i = list_seq_find(config->output_configs, output_name_cmp, identifier);
+static void clear_later_output_states(struct wlr_backend_output_state *states,
-                if (i >= 0) {
+                size_t configs_len, size_t output_idx) {
-                        oc_id = config->output_configs->items[i];
+        // Clear and disable all output states after this one to avoid conflict
+        // with previous tests.
+        for (size_t idx = output_idx+1; idx < configs_len; idx++) {
+                struct wlr_backend_output_state *backend_state = &states[idx];
+                struct wlr_output_state *state = &backend_state->base;
+                reset_output_state(state);
+                wlr_output_state_set_enabled(state, false);
+        }
+}
+static bool search_finish(struct search_context *ctx, size_t output_idx) {
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
+        struct wlr_output_state *state = &backend_state->base;
+        struct wlr_output *wlr_output = backend_state->output;
+        clear_later_output_states(ctx->states, ctx->configs_len, output_idx);
+        dump_output_state(wlr_output, state);
+        return wlr_output_swapchain_manager_prepare(ctx->swapchain_mgr, ctx->states, ctx->configs_len) &&
+                search_valid_config(ctx, output_idx+1);
+}
+static bool search_adaptive_sync(struct search_context *ctx, size_t output_idx) {
+        struct matched_output_config *cfg = &ctx->configs[output_idx];
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
+        struct wlr_output_state *state = &backend_state->base;
+        if (cfg->config && cfg->config->adaptive_sync == 1) {
+                wlr_output_state_set_adaptive_sync_enabled(state, true);
+                if (search_finish(ctx, output_idx)) {
+                        return true;
+                }
+        }
+        if (!cfg->config || cfg->config->adaptive_sync != -1) {
+                wlr_output_state_set_adaptive_sync_enabled(state, false);
+                if (search_finish(ctx, output_idx)) {
+                        return true;
                }
        }
+        // If adaptive sync has not been set, or fallback in case we are on a
+        // backend that cannot disable adaptive sync such as the wayland backend.
+        state->committed &= ~WLR_OUTPUT_STATE_ADAPTIVE_SYNC_ENABLED;
+        return search_finish(ctx, output_idx);
+}
-        struct output_config *result = new_output_config("temp");
+static bool search_mode(struct search_context *ctx, size_t output_idx) {
-        if (config->reloading) {
+        struct matched_output_config *cfg = &ctx->configs[output_idx];
-                default_output_config(result, sway_output->wlr_output);
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
+        struct wlr_output_state *state = &backend_state->base;
+        struct wlr_output *wlr_output = backend_state->output;
+        if (!config_has_auto_mode(cfg->config)) {
+                return search_adaptive_sync(ctx, output_idx);
        }
-        if (oc_id_on_name) {
-                // Already have an identifier on name config, use that
+        struct wlr_output_mode *preferred_mode = wlr_output_preferred_mode(wlr_output);
-                free(result->name);
+        if (preferred_mode) {
-                result->name = strdup(id_on_name);
+                wlr_output_state_set_mode(state, preferred_mode);
-                merge_output_config(result, oc_id_on_name);
+                if (search_adaptive_sync(ctx, output_idx)) {
-        } else if (oc_name && oc_id) {
+                        return true;
-                // Generate a config named `<identifier> on <name>` which contains a
-                // merged copy of the identifier on name. This will make sure that both
-                // identifier and name configs are respected, with identifier getting
-                // priority
-                struct output_config *temp = new_output_config(id_on_name);
-                merge_output_config(temp, oc_name);
-                merge_output_config(temp, oc_id);
-                list_add(config->output_configs, temp);
-                free(result->name);
-                result->name = strdup(id_on_name);
-                merge_output_config(result, temp);
-                sway_log(SWAY_DEBUG, "Generated output config \"%s\" (enabled: %d)"
-                        " (%dx%d@%fHz position %d,%d scale %f transform %d) (bg %s %s)"
-                        " (dpms %d) (max render time: %d)", result->name, result->enabled,
-                        result->width, result->height, result->refresh_rate,
-                        result->x, result->y, result->scale, result->transform,
-                        result->background, result->background_option, result->dpms_state,
-                        result->max_render_time);
-        } else if (oc_name) {
-                // No identifier config, just return a copy of the name config
-                free(result->name);
-                result->name = strdup(name);
-                merge_output_config(result, oc_name);
-        } else if (oc_id) {
-                // No name config, just return a copy of the identifier config
-                free(result->name);
-                result->name = strdup(identifier);
-                merge_output_config(result, oc_id);
-        } else {
-                i = list_seq_find(config->output_configs, output_name_cmp, "*");
-                if (i >= 0) {
-                        // No name or identifier config, but there is a wildcard config
-                        free(result->name);
-                        result->name = strdup("*");
-                        merge_output_config(result, config->output_configs->items[i]);
-                } else if (!config->reloading) {
-                        // No name, identifier, or wildcard config. Since we are not
-                        // reloading with defaults, the output config will be empty, so
-                        // just return NULL
-                        free_output_config(result);
-                        result = NULL;
                }
        }
-        free(id_on_name);
+        if (wl_list_empty(&wlr_output->modes)) {
-        return result;
+                state->committed &= ~WLR_OUTPUT_STATE_MODE;
+                return search_adaptive_sync(ctx, output_idx);
+        }
+        struct wlr_output_mode *mode;
+        wl_list_for_each(mode, &backend_state->output->modes, link) {
+                if (mode == preferred_mode) {
+                        continue;
+                }
+                wlr_output_state_set_mode(state, mode);
+                if (search_adaptive_sync(ctx, output_idx)) {
+                        return true;
+                }
+        }
+        return false;
 }
-struct output_config *find_output_config(struct sway_output *output) {
+static bool search_render_format(struct search_context *ctx, size_t output_idx) {
-        char id[128];
+        struct matched_output_config *cfg = &ctx->configs[output_idx];
-        output_get_identifier(id, sizeof(id), output);
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
-        return get_output_config(id, output);
+        struct wlr_output_state *state = &backend_state->base;
+        struct wlr_output *wlr_output = backend_state->output;
+        uint32_t fmts[] = {
+                DRM_FORMAT_XRGB2101010,
+                DRM_FORMAT_XBGR2101010,
+                DRM_FORMAT_XRGB8888,
+                DRM_FORMAT_INVALID,
+        };
+        if (render_format_is_bgr(wlr_output->render_format)) {
+                // Start with BGR in the unlikely event that we previously required it.
+                fmts[0] = DRM_FORMAT_XBGR2101010;
+                fmts[1] = DRM_FORMAT_XRGB2101010;
+        }
+        const struct wlr_drm_format_set *primary_formats =
+                wlr_output_get_primary_formats(wlr_output, WLR_BUFFER_CAP_DMABUF);
+        bool need_10bit = cfg->config && cfg->config->render_bit_depth == RENDER_BIT_DEPTH_10;
+        for (size_t idx = 0; fmts[idx] != DRM_FORMAT_INVALID; idx++) {
+                if (!need_10bit && render_format_is_10bit(fmts[idx])) {
+                        continue;
+                }
+                if (!wlr_drm_format_set_get(primary_formats, fmts[idx])) {
+                        // This is not a supported format for this output
+                        continue;
+                }
+                wlr_output_state_set_render_format(state, fmts[idx]);
+                if (search_mode(ctx, output_idx)) {
+                        return true;
+                }
+        }
+        return false;
 }
-void apply_output_config_to_outputs(struct output_config *oc) {
+static bool search_valid_config(struct search_context *ctx, size_t output_idx) {
-        // Try to find the output container and apply configuration now. If
+        if (output_idx >= ctx->configs_len) {
-        // this is during startup then there will be no container and config
+                // We reached the end of the search, all good!
-        // will be applied during normal "new output" event from wlroots.
+                return true;
-        bool wildcard = strcmp(oc->name, "*") == 0;
+        }
-        char id[128];
-        struct sway_output *sway_output, *tmp;
-        wl_list_for_each_safe(sway_output, tmp, &root->all_outputs, link) {
-                char *name = sway_output->wlr_output->name;
-                output_get_identifier(id, sizeof(id), sway_output);
-                if (wildcard || !strcmp(name, oc->name) || !strcmp(id, oc->name)) {
-                        struct output_config *current = get_output_config(id, sway_output);
-                        if (!current) {
-                                // No stored output config matched, apply oc directly
-                                sway_log(SWAY_DEBUG, "Applying oc directly");
-                                current = new_output_config(oc->name);
-                                merge_output_config(current, oc);
-                        }
-                        apply_output_config(current, sway_output);
-                        free_output_config(current);
-                        if (!wildcard) {
+        struct matched_output_config *cfg = &ctx->configs[output_idx];
-                                // Stop looking if the output config isn't applicable to all
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
-                                // outputs
+        struct wlr_output_state *state = &backend_state->base;
-                                break;
+        struct wlr_output *wlr_output = backend_state->output;
-                        }
+        if (!output_config_is_disabling(cfg->config)) {
+                // Search through our possible configurations, doing a depth-first
+                // through render_format, modes, adaptive_sync and the next output's
+                // config.
+                queue_output_config(cfg->config, cfg->output, &backend_state->base);
+                if (search_render_format(ctx, output_idx)) {
+                        return true;
+                } else if (!ctx->degrade_to_off) {
+                        return false;
+                }
+                // We could not get anything to work, try to disable this output to see
+                // if we can at least make the outputs before us work.
+                sway_log(SWAY_DEBUG, "Unable to find valid config with output %s, disabling",
+                        wlr_output->name);
+                reset_output_state(state);
+        }
+        wlr_output_state_set_enabled(state, false);
+        return search_finish(ctx, output_idx);
+}
+static int compare_matched_output_config_priority(const void *a, const void *b) {
+        const struct matched_output_config *amc = a;
+        const struct matched_output_config *bmc = b;
+        bool a_disabling = output_config_is_disabling(amc->config);
+        bool b_disabling = output_config_is_disabling(bmc->config);
+        bool a_enabled = amc->output->enabled;
+        bool b_enabled = bmc->output->enabled;
+        // We want to give priority to existing enabled outputs. To do so, we want
+        // the configuration order to be:
+        // 1. Existing, enabled outputs
+        // 2. Outputs that need to be enabled
+        // 3. Disabled or disabling outputs
+        if (a_enabled && !a_disabling) {
+                return -1;
+        } else if (b_enabled && !b_disabling) {
+                return 1;
+        } else if (b_disabling && !a_disabling) {
+                return -1;
+        } else if (a_disabling && !b_disabling) {
+                return 1;
+        }
+        return 0;
+}
+void sort_output_configs_by_priority(struct matched_output_config *configs,
+                size_t configs_len) {
+        qsort(configs, configs_len, sizeof(*configs), compare_matched_output_config_priority);
+}
+bool apply_output_configs(struct matched_output_config *configs,
+                size_t configs_len, bool test_only, bool degrade_to_off) {
+        struct wlr_backend_output_state *states = calloc(configs_len, sizeof(*states));
+        if (!states) {
+                return false;
+        }
+        sway_log(SWAY_DEBUG, "Committing %zd outputs", configs_len);
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+                struct wlr_backend_output_state *backend_state = &states[idx];
+                backend_state->output = cfg->output->wlr_output;
+                wlr_output_state_init(&backend_state->base);
+                sway_log(SWAY_DEBUG, "Preparing config for %s",
+                        cfg->output->wlr_output->name);
+                queue_output_config(cfg->config, cfg->output, &backend_state->base);
+        }
+        struct wlr_output_swapchain_manager swapchain_mgr;
+        wlr_output_swapchain_manager_init(&swapchain_mgr, server.backend);
+        bool ok = wlr_output_swapchain_manager_prepare(&swapchain_mgr, states, configs_len);
+        if (!ok) {
+                sway_log(SWAY_ERROR, "Requested backend configuration failed, searching for valid fallbacks");
+                struct search_context ctx = {
+                        .swapchain_mgr = &swapchain_mgr,
+                        .states = states,
+                        .configs = configs,
+                        .configs_len = configs_len,
+                        .degrade_to_off = degrade_to_off,
+                };
+                if (!search_valid_config(&ctx, 0)) {
+                        sway_log(SWAY_ERROR, "Search for valid config failed");
+                        goto out;
                }
        }
+        if (test_only) {
+                // The swapchain manager already did a test for us
+                goto out;
+        }
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+                struct wlr_backend_output_state *backend_state = &states[idx];
+                struct wlr_scene_output_state_options opts = {
+                        .swapchain = wlr_output_swapchain_manager_get_swapchain(
+                                &swapchain_mgr, backend_state->output),
+                };
+                struct wlr_scene_output *scene_output = cfg->output->scene_output;
+                struct wlr_output_state *state = &backend_state->base;
+                if (!wlr_scene_output_build_state(scene_output, state, &opts)) {
+                        sway_log(SWAY_ERROR, "Building output state for '%s' failed",
+                                backend_state->output->name);
+                        goto out;
+                }
+        }
+        ok = wlr_backend_commit(server.backend, states, configs_len);
+        if (!ok) {
+                sway_log(SWAY_ERROR, "Backend commit failed");
+                goto out;
+        }
+        sway_log(SWAY_DEBUG, "Commit of %zd outputs succeeded", configs_len);
+        wlr_output_swapchain_manager_apply(&swapchain_mgr);
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+                sway_log(SWAY_DEBUG, "Finalizing config for %s",
+                        cfg->output->wlr_output->name);
+                finalize_output_config(cfg->config, cfg->output);
+        }
+out:
+        wlr_output_swapchain_manager_finish(&swapchain_mgr);
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct wlr_backend_output_state *backend_state = &states[idx];
+                wlr_output_state_finish(&backend_state->base);
+        }
+        free(states);
+        // Reconfigure all devices, since input config may have been applied before
+        // this output came online, and some config items (like map_to_output) are
+        // dependent on an output being present.
+        input_manager_configure_all_input_mappings();
+        // Reconfigure the cursor images, since the scale may have changed.
+        input_manager_configure_xcursor();
        struct sway_seat *seat;
        wl_list_for_each(seat, &server.input->seats, link) {
                wlr_seat_pointer_notify_clear_focus(seat->wlr_seat);
                cursor_rebase(seat->cursor);
        }
+        return ok;
 }
-void reset_outputs(void) {
+void apply_all_output_configs(void) {
-        struct output_config *oc = NULL;
+        size_t configs_len = wl_list_length(&root->all_outputs);
-        int i = list_seq_find(config->output_configs, output_name_cmp, "*");
+        struct matched_output_config *configs = calloc(configs_len, sizeof(*configs));
-        if (i >= 0) {
+        if (!configs) {
-                oc = config->output_configs->items[i];
+                return;
-        } else {
-                oc = store_output_config(new_output_config("*"));
        }
-        apply_output_config_to_outputs(oc);
+        int config_idx = 0;
+        struct sway_output *sway_output;
+        wl_list_for_each(sway_output, &root->all_outputs, link) {
+                if (sway_output == root->fallback_output) {
+                        configs_len--;
+                        continue;
+                }
+                struct matched_output_config *config = &configs[config_idx++];
+                config->output = sway_output;
+                config->config = find_output_config(sway_output);
+        }
+        sort_output_configs_by_priority(configs, configs_len);
+        apply_output_configs(configs, configs_len, false, true);
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+                free_output_config(cfg->config);
+        }
+        free(configs);
 }
 void free_output_config(struct output_config *oc) {
@@ -704,6 +1036,8 @@ static bool _spawn_swaybg(char **command) {
                sway_log_errno(SWAY_ERROR, "fork failed");
                return false;
        } else if (pid == 0) {
+                restore_nofile_limit();
                pid = fork();
                if (pid < 0) {
                        sway_log_errno(SWAY_ERROR, "fork failed");
@@ -719,7 +1053,9 @@ static bool _spawn_swaybg(char **command) {
                        setenv("WAYLAND_SOCKET", wayland_socket_str, true);
                        execvp(command[0], command);
-                        sway_log_errno(SWAY_ERROR, "execvp failed");
+                        sway_log_errno(SWAY_ERROR, "failed to execute '%s' "
+                                "(background configuration probably not applied)",
+                                command[0]);
                        _exit(EXIT_FAILURE);
                }
                _exit(EXIT_SUCCESS);
@@ -729,12 +1065,13 @@ static bool _spawn_swaybg(char **command) {
                sway_log_errno(SWAY_ERROR, "close failed");
                return false;
        }
-        if (waitpid(pid, NULL, 0) < 0) {
+        int fork_status = 0;
+        if (waitpid(pid, &fork_status, 0) < 0) {
                sway_log_errno(SWAY_ERROR, "waitpid failed");
                return false;
        }
-        return true;
+        return WIFEXITED(fork_status) && WEXITSTATUS(fork_status) == EXIT_SUCCESS;
 }
 bool spawn_swaybg(void) {
diff --git a/sway/config/seat.c b/sway/config/seat.c
index 84260aa3..f2326189 100644
--- a/sway/config/seat.c
+++ b/sway/config/seat.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
@@ -99,7 +98,6 @@ static void seat_attachment_config_free(
                struct seat_attachment_config *attachment) {
        free(attachment->identifier);
        free(attachment);
-        return;
 }
 static struct seat_attachment_config *seat_attachment_config_copy(
diff --git a/sway/criteria.c b/sway/criteria.c
index d2a5566f..13f0530e 100644
--- a/sway/criteria.c
+++ b/sway/criteria.c
@@ -1,9 +1,9 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <strings.h>
-#include <pcre.h>
+#define PCRE2_CODE_UNIT_WIDTH 8
+#include <pcre2.h>
 #include "sway/criteria.h"
 #include "sway/tree/container.h"
 #include "sway/config.h"
@@ -18,10 +18,11 @@
 bool criteria_is_empty(struct criteria *criteria) {
        return !criteria->title
                && !criteria->shell
+                && !criteria->all
                && !criteria->app_id
                && !criteria->con_mark
                && !criteria->con_id
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
                && !criteria->class
                && !criteria->id
                && !criteria->instance
@@ -40,17 +41,19 @@ bool criteria_is_empty(struct criteria *criteria) {
 char *error = NULL;
 // Returns error string on failure or NULL otherwise.
-static bool generate_regex(pcre **regex, char *value) {
+static bool generate_regex(pcre2_code **regex, char *value) {
-        const char *reg_err;
+        int errorcode;
-        int offset;
+        PCRE2_SIZE offset;
-        *regex = pcre_compile(value, PCRE_UTF8 | PCRE_UCP, &reg_err, &offset, NULL);
+        *regex = pcre2_compile((PCRE2_SPTR)value, PCRE2_ZERO_TERMINATED, PCRE2_UTF | PCRE2_UCP, &errorcode, &offset, NULL);
        if (!*regex) {
+                PCRE2_UCHAR buffer[256];
+                pcre2_get_error_message(errorcode, buffer, sizeof(buffer));
                const char *fmt = "Regex compilation for '%s' failed: %s";
-                int len = strlen(fmt) + strlen(value) + strlen(reg_err) - 3;
+                int len = strlen(fmt) + strlen(value) + strlen((char*) buffer) - 3;
                error = malloc(len);
-                snprintf(error, len, fmt, value, reg_err);
+                snprintf(error, len, fmt, value, buffer);
                return false;
        }
@@ -66,7 +69,7 @@ static bool pattern_create(struct pattern **pattern, char *value) {
        if (strcmp(value, "__focused__") == 0) {
                (*pattern)->match_type = PATTERN_FOCUSED;
        } else {
-                (*pattern)->match_type = PATTERN_PCRE;
+                (*pattern)->match_type = PATTERN_PCRE2;
                if (!generate_regex(&(*pattern)->regex, value)) {
                        return false;
                };
@@ -77,7 +80,7 @@ static bool pattern_create(struct pattern **pattern, char *value) {
 static void pattern_destroy(struct pattern *pattern) {
        if (pattern) {
                if (pattern->regex) {
-                        pcre_free(pattern->regex);
+                        pcre2_code_free(pattern->regex);
                }
                free(pattern);
        }
@@ -87,23 +90,27 @@ void criteria_destroy(struct criteria *criteria) {
        pattern_destroy(criteria->title);
        pattern_destroy(criteria->shell);
        pattern_destroy(criteria->app_id);
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        pattern_destroy(criteria->class);
        pattern_destroy(criteria->instance);
        pattern_destroy(criteria->window_role);
 #endif
        pattern_destroy(criteria->con_mark);
-        free(criteria->workspace);
+        pattern_destroy(criteria->workspace);
+        free(criteria->target);
        free(criteria->cmdlist);
        free(criteria->raw);
        free(criteria);
 }
-static int regex_cmp(const char *item, const pcre *regex) {
+static int regex_cmp(const char *item, const pcre2_code *regex) {
-        return pcre_exec(regex, NULL, item, strlen(item), 0, 0, NULL, 0);
+        pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(regex, NULL);
+        int result = pcre2_match(regex, (PCRE2_SPTR)item, strlen(item), 0, 0, match_data, NULL);
+        pcre2_match_data_free(match_data);
+        return result;
 }
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
 static bool view_has_window_type(struct sway_view *view, enum atom_name name) {
        if (view->type != SWAY_VIEW_XWAYLAND) {
                return false;
@@ -155,7 +162,7 @@ static bool criteria_matches_container(struct criteria *criteria,
                bool exists = false;
                struct sway_container *con = container;
                for (int i = 0; i < con->marks->length; ++i) {
-                        if (regex_cmp(con->marks->items[i], criteria->con_mark->regex) == 0) {
+                        if (regex_cmp(con->marks->items[i], criteria->con_mark->regex) >= 0) {
                                exists = true;
                                break;
                        }
@@ -183,7 +190,7 @@ static bool criteria_matches_view(struct criteria *criteria,
        if (criteria->title) {
                const char *title = view_get_title(view);
                if (!title) {
-                        return false;
+                        title = "";
                }
                switch (criteria->title->match_type) {
@@ -192,8 +199,8 @@ static bool criteria_matches_view(struct criteria *criteria,
                                return false;
                        }
                        break;
-                case PATTERN_PCRE:
+                case PATTERN_PCRE2:
-                        if (regex_cmp(title, criteria->title->regex) != 0) {
+                        if (regex_cmp(title, criteria->title->regex) < 0) {
                                return false;
                        }
                        break;
@@ -203,7 +210,7 @@ static bool criteria_matches_view(struct criteria *criteria,
        if (criteria->shell) {
                const char *shell = view_get_shell(view);
                if (!shell) {
-                        return false;
+                        shell = "";
                }
                switch (criteria->shell->match_type) {
@@ -212,8 +219,8 @@ static bool criteria_matches_view(struct criteria *criteria,
                                return false;
                        }
                        break;
-                case PATTERN_PCRE:
+                case PATTERN_PCRE2:
-                        if (regex_cmp(shell, criteria->shell->regex) != 0) {
+                        if (regex_cmp(shell, criteria->shell->regex) < 0) {
                                return false;
                        }
                        break;
@@ -223,7 +230,7 @@ static bool criteria_matches_view(struct criteria *criteria,
        if (criteria->app_id) {
                const char *app_id = view_get_app_id(view);
                if (!app_id) {
-                        return false;
+                        app_id = "";
                }
                switch (criteria->app_id->match_type) {
@@ -232,8 +239,8 @@ static bool criteria_matches_view(struct criteria *criteria,
                                return false;
                        }
                        break;
-                case PATTERN_PCRE:
+                case PATTERN_PCRE2:
-                        if (regex_cmp(app_id, criteria->app_id->regex) != 0) {
+                        if (regex_cmp(app_id, criteria->app_id->regex) < 0) {
                                return false;
                        }
                        break;
@@ -244,7 +251,7 @@ static bool criteria_matches_view(struct criteria *criteria,
                return false;
        }
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        if (criteria->id) { // X11 window ID
                uint32_t x11_window_id = view_get_x11_window_id(view);
                if (!x11_window_id || x11_window_id != criteria->id) {
@@ -255,7 +262,7 @@ static bool criteria_matches_view(struct criteria *criteria,
        if (criteria->class) {
                const char *class = view_get_class(view);
                if (!class) {
-                        return false;
+                        class = "";
                }
                switch (criteria->class->match_type) {
@@ -264,8 +271,8 @@ static bool criteria_matches_view(struct criteria *criteria,
                                return false;
                        }
                        break;
-                case PATTERN_PCRE:
+                case PATTERN_PCRE2:
-                        if (regex_cmp(class, criteria->class->regex) != 0) {
+                        if (regex_cmp(class, criteria->class->regex) < 0) {
                                return false;
                        }
                        break;
@@ -275,17 +282,17 @@ static bool criteria_matches_view(struct criteria *criteria,
        if (criteria->instance) {
                const char *instance = view_get_instance(view);
                if (!instance) {
-                        return false;
+                        instance = "";
                }
                switch (criteria->instance->match_type) {
                case PATTERN_FOCUSED:
-                        if (focused && strcmp(instance, view_get_instance(focused))) {
+                        if (focused && lenient_strcmp(instance, view_get_instance(focused))) {
                                return false;
                        }
                        break;
-                case PATTERN_PCRE:
+                case PATTERN_PCRE2:
-                        if (regex_cmp(instance, criteria->instance->regex) != 0) {
+                        if (regex_cmp(instance, criteria->instance->regex) < 0) {
                                return false;
                        }
                        break;
@@ -295,17 +302,17 @@ static bool criteria_matches_view(struct criteria *criteria,
        if (criteria->window_role) {
                const char *window_role = view_get_window_role(view);
                if (!window_role) {
-                        return false;
+                        window_role = "";
                }
                switch (criteria->window_role->match_type) {
                case PATTERN_FOCUSED:
-                        if (focused && strcmp(window_role, view_get_window_role(focused))) {
+                        if (focused && lenient_strcmp(window_role, view_get_window_role(focused))) {
                                return false;
                        }
                        break;
-                case PATTERN_PCRE:
+                case PATTERN_PCRE2:
-                        if (regex_cmp(window_role, criteria->window_role->regex) != 0) {
+                        if (regex_cmp(window_role, criteria->window_role->regex) < 0) {
                                return false;
                        }
                        break;
@@ -363,8 +370,8 @@ static bool criteria_matches_view(struct criteria *criteria,
                                return false;
                        }
                        break;
-                case PATTERN_PCRE:
+                case PATTERN_PCRE2:
-                        if (regex_cmp(ws->name, criteria->workspace->regex) != 0) {
+                        if (regex_cmp(ws->name, criteria->workspace->regex) < 0) {
                                return false;
                        }
                        break;
@@ -421,7 +428,7 @@ list_t *criteria_get_containers(struct criteria *criteria) {
        return matches;
 }
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
 static enum atom_name parse_window_type(const char *type) {
        if (strcasecmp(type, "normal") == 0) {
                return NET_WM_WINDOW_TYPE_NORMAL;
@@ -449,11 +456,12 @@ static enum atom_name parse_window_type(const char *type) {
 #endif
 enum criteria_token {
+        T_ALL,
        T_APP_ID,
        T_CON_ID,
        T_CON_MARK,
        T_FLOATING,
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        T_CLASS,
        T_ID,
        T_INSTANCE,
@@ -471,13 +479,15 @@ enum criteria_token {
 };
 static enum criteria_token token_from_name(char *name) {
-        if (strcmp(name, "app_id") == 0) {
+        if (strcmp(name, "all") == 0) {
+                return T_ALL;
+        } else if (strcmp(name, "app_id") == 0) {
                return T_APP_ID;
        } else if (strcmp(name, "con_id") == 0) {
                return T_CON_ID;
        } else if (strcmp(name, "con_mark") == 0) {
                return T_CON_MARK;
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        } else if (strcmp(name, "class") == 0) {
                return T_CLASS;
        } else if (strcmp(name, "id") == 0) {
@@ -517,8 +527,8 @@ static bool parse_token(struct criteria *criteria, char *name, char *value) {
                return false;
        }
-        // Require value, unless token is floating or tiled
+        // Require value, unless token is all, floating or tiled
-        if (!value && token != T_FLOATING && token != T_TILING) {
+        if (!value && token != T_ALL && token != T_FLOATING && token != T_TILING) {
                const char *fmt = "Token '%s' requires a value";
                int len = strlen(fmt) + strlen(name) - 1;
                error = malloc(len);
@@ -528,6 +538,9 @@ static bool parse_token(struct criteria *criteria, char *name, char *value) {
        char *endptr = NULL;
        switch (token) {
+        case T_ALL:
+                criteria->all = true;
+                break;
        case T_TITLE:
                pattern_create(&criteria->title, value);
                break;
@@ -553,7 +566,7 @@ static bool parse_token(struct criteria *criteria, char *name, char *value) {
        case T_CON_MARK:
                pattern_create(&criteria->con_mark, value);
                break;
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        case T_CLASS:
                pattern_create(&criteria->class, value);
                break;
@@ -661,7 +674,7 @@ struct criteria *criteria_parse(char *raw, char **error_arg) {
        ++head;
        struct criteria *criteria = calloc(1, sizeof(struct criteria));
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        criteria->window_type = ATOM_LAST; // default value
 #endif
        char *name = NULL, *value = NULL;
@@ -676,7 +689,7 @@ struct criteria *criteria_parse(char *raw, char **error_arg) {
                }
                name = calloc(head - namestart + 1, 1);
                if (head != namestart) {
-                        strncpy(name, namestart, head - namestart);
+                        memcpy(name, namestart, head - namestart);
                }
                // Parse token value
                skip_spaces(&head);
@@ -703,7 +716,7 @@ struct criteria *criteria_parse(char *raw, char **error_arg) {
                                }
                        }
                        value = calloc(head - valuestart + 1, 1);
-                        strncpy(value, valuestart, head - valuestart);
+                        memcpy(value, valuestart, head - valuestart);
                        if (in_quotes) {
                                ++head;
                                in_quotes = false;
@@ -734,7 +747,7 @@ struct criteria *criteria_parse(char *raw, char **error_arg) {
        ++head;
        int len = head - raw;
        criteria->raw = calloc(len + 1, 1);
-        strncpy(criteria->raw, raw, len);
+        memcpy(criteria->raw, raw, len);
        return criteria;
 cleanup:
diff --git a/sway/desktop/desktop.c b/sway/desktop/desktop.c
deleted file mode 100644
index ec45d80a..00000000
--- a/sway/desktop/desktop.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "sway/tree/container.h"
-#include "sway/desktop.h"
-#include "sway/output.h"
-void desktop_damage_surface(struct wlr_surface *surface, double lx, double ly,
-                bool whole) {
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                struct wlr_box *output_box = wlr_output_layout_get_box(
-                        root->output_layout, output->wlr_output);
-                output_damage_surface(output, lx - output_box->x,
-                        ly - output_box->y, surface, whole);
-        }
-}
-void desktop_damage_whole_container(struct sway_container *con) {
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                output_damage_whole_container(output, con);
-        }
-}
-void desktop_damage_box(struct wlr_box *box) {
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                output_damage_box(output, box);
-        }
-}
-void desktop_damage_view(struct sway_view *view) {
-        desktop_damage_whole_container(view->container);
-        struct wlr_box box = {
-                .x = view->container->current.content_x - view->geometry.x,
-                .y = view->container->current.content_y - view->geometry.y,
-                .width = view->surface->current.width,
-                .height = view->surface->current.height,
-        };
-        desktop_damage_box(&box);
-}
diff --git a/sway/desktop/idle_inhibit_v1.c b/sway/desktop/idle_inhibit_v1.c
index a6ad7166..f3af7aa1 100644
--- a/sway/desktop/idle_inhibit_v1.c
+++ b/sway/desktop/idle_inhibit_v1.c
@@ -1,5 +1,5 @@
 #include <stdlib.h>
-#include <wlr/types/wlr_idle.h>
+#include <wlr/types/wlr_idle_notify_v1.h>
 #include "log.h"
 #include "sway/desktop/idle_inhibit_v1.h"
 #include "sway/input/seat.h"
@@ -11,7 +11,7 @@
 static void destroy_inhibitor(struct sway_idle_inhibitor_v1 *inhibitor) {
        wl_list_remove(&inhibitor->link);
        wl_list_remove(&inhibitor->destroy.link);
-        sway_idle_inhibit_v1_check_active(inhibitor->manager);
+        sway_idle_inhibit_v1_check_active();
        free(inhibitor);
 }
@@ -34,7 +34,6 @@ void handle_idle_inhibitor_v1(struct wl_listener *listener, void *data) {
                return;
        }
-        inhibitor->manager = manager;
        inhibitor->mode = INHIBIT_IDLE_APPLICATION;
        inhibitor->wlr_inhibitor = wlr_inhibitor;
        wl_list_insert(&manager->inhibitors, &inhibitor->link);
@@ -42,35 +41,36 @@ void handle_idle_inhibitor_v1(struct wl_listener *listener, void *data) {
        inhibitor->destroy.notify = handle_destroy;
        wl_signal_add(&wlr_inhibitor->events.destroy, &inhibitor->destroy);
-        sway_idle_inhibit_v1_check_active(manager);
+        sway_idle_inhibit_v1_check_active();
 }
 void sway_idle_inhibit_v1_user_inhibitor_register(struct sway_view *view,
                enum sway_idle_inhibit_mode mode) {
+        struct sway_idle_inhibit_manager_v1 *manager = &server.idle_inhibit_manager_v1;
        struct sway_idle_inhibitor_v1 *inhibitor =
                calloc(1, sizeof(struct sway_idle_inhibitor_v1));
        if (!inhibitor) {
                return;
        }
-        inhibitor->manager = server.idle_inhibit_manager_v1;
        inhibitor->mode = mode;
        inhibitor->view = view;
-        wl_list_insert(&inhibitor->manager->inhibitors, &inhibitor->link);
+        wl_list_insert(&manager->inhibitors, &inhibitor->link);
        inhibitor->destroy.notify = handle_destroy;
        wl_signal_add(&view->events.unmap, &inhibitor->destroy);
-        sway_idle_inhibit_v1_check_active(inhibitor->manager);
+        sway_idle_inhibit_v1_check_active();
 }
 struct sway_idle_inhibitor_v1 *sway_idle_inhibit_v1_user_inhibitor_for_view(
                struct sway_view *view) {
+        struct sway_idle_inhibit_manager_v1 *manager = &server.idle_inhibit_manager_v1;
        struct sway_idle_inhibitor_v1 *inhibitor;
-        wl_list_for_each(inhibitor, &server.idle_inhibit_manager_v1->inhibitors,
+        wl_list_for_each(inhibitor, &manager->inhibitors, link) {
-                        link) {
+                if (inhibitor->mode != INHIBIT_IDLE_APPLICATION &&
-                if (inhibitor->view == view &&
+                                inhibitor->view == view) {
-                                inhibitor->mode != INHIBIT_IDLE_APPLICATION) {
                        return inhibitor;
                }
        }
@@ -79,11 +79,11 @@ struct sway_idle_inhibitor_v1 *sway_idle_inhibit_v1_user_inhibitor_for_view(
 struct sway_idle_inhibitor_v1 *sway_idle_inhibit_v1_application_inhibitor_for_view(
                struct sway_view *view) {
+        struct sway_idle_inhibit_manager_v1 *manager = &server.idle_inhibit_manager_v1;
        struct sway_idle_inhibitor_v1 *inhibitor;
-        wl_list_for_each(inhibitor, &server.idle_inhibit_manager_v1->inhibitors,
+        wl_list_for_each(inhibitor, &manager->inhibitors, link) {
-                        link) {
+                if (inhibitor->mode == INHIBIT_IDLE_APPLICATION &&
-                if (inhibitor->view == view &&
+                                view_from_wlr_surface(inhibitor->wlr_inhibitor->surface) == view) {
-                                inhibitor->mode == INHIBIT_IDLE_APPLICATION) {
                        return inhibitor;
                }
        }
@@ -130,8 +130,8 @@ bool sway_idle_inhibit_v1_is_active(struct sway_idle_inhibitor_v1 *inhibitor) {
        return false;
 }
-void sway_idle_inhibit_v1_check_active(
+void sway_idle_inhibit_v1_check_active(void) {
-                struct sway_idle_inhibit_manager_v1 *manager) {
+        struct sway_idle_inhibit_manager_v1 *manager = &server.idle_inhibit_manager_v1;
        struct sway_idle_inhibitor_v1 *inhibitor;
        bool inhibited = false;
        wl_list_for_each(inhibitor, &manager->inhibitors, link) {
@@ -139,27 +139,21 @@ void sway_idle_inhibit_v1_check_active(
                        break;
                }
        }
-        wlr_idle_set_enabled(manager->idle, NULL, !inhibited);
+        wlr_idle_notifier_v1_set_inhibited(server.idle_notifier_v1, inhibited);
 }
-struct sway_idle_inhibit_manager_v1 *sway_idle_inhibit_manager_v1_create(
+bool sway_idle_inhibit_manager_v1_init(void) {
-                struct wl_display *wl_display, struct wlr_idle *idle) {
+        struct sway_idle_inhibit_manager_v1 *manager = &server.idle_inhibit_manager_v1;
-        struct sway_idle_inhibit_manager_v1 *manager =
-                calloc(1, sizeof(struct sway_idle_inhibit_manager_v1));
-        if (!manager) {
-                return NULL;
-        }
-        manager->wlr_manager = wlr_idle_inhibit_v1_create(wl_display);
+        manager->wlr_manager = wlr_idle_inhibit_v1_create(server.wl_display);
        if (!manager->wlr_manager) {
-                free(manager);
+                return false;
-                return NULL;
        }
-        manager->idle = idle;
        wl_signal_add(&manager->wlr_manager->events.new_inhibitor,
                &manager->new_idle_inhibitor_v1);
        manager->new_idle_inhibitor_v1.notify = handle_idle_inhibitor_v1;
        wl_list_init(&manager->inhibitors);
-        return manager;
+        return true;
 }
diff --git a/sway/desktop/launcher.c b/sway/desktop/launcher.c
new file mode 100644
index 00000000..28043d19
--- /dev/null
+++ b/sway/desktop/launcher.c
@@ -0,0 +1,267 @@
+#include <stdlib.h>
+#include <string.h>
+#include <wlr/types/wlr_xdg_activation_v1.h>
+#include "sway/input/seat.h"
+#include "sway/output.h"
+#include "sway/desktop/launcher.h"
+#include "sway/tree/node.h"
+#include "sway/tree/container.h"
+#include "sway/tree/workspace.h"
+#include "sway/tree/root.h"
+#include "log.h"
+/**
+ * Get the pid of a parent process given the pid of a child process.
+ *
+ * Returns the parent pid or NULL if the parent pid cannot be determined.
+ */
+static pid_t get_parent_pid(pid_t child) {
+        pid_t parent = -1;
+        char file_name[100];
+        char *buffer = NULL;
+        const char *sep = " ";
+        FILE *stat = NULL;
+        size_t buf_size = 0;
+        snprintf(file_name, sizeof(file_name), "/proc/%d/stat", child);
+        if ((stat = fopen(file_name, "r"))) {
+                if (getline(&buffer, &buf_size, stat) != -1) {
+                        strtok(buffer, sep); // pid
+                        strtok(NULL, sep);   // executable name
+                        strtok(NULL, sep);   // state
+                        char *token = strtok(NULL, sep);   // parent pid
+                        parent = strtol(token, NULL, 10);
+                }
+                free(buffer);
+                fclose(stat);
+        }
+        if (parent) {
+                return (parent == child) ? -1 : parent;
+        }
+        return -1;
+}
+void launcher_ctx_consume(struct launcher_ctx *ctx) {
+        // The view is now responsible for destroying this ctx
+        wl_list_remove(&ctx->token_destroy.link);
+        wl_list_init(&ctx->token_destroy.link);
+        if (!ctx->activated) {
+                // An unactivated token hasn't been destroyed yet
+                wlr_xdg_activation_token_v1_destroy(ctx->token);
+        }
+        ctx->token = NULL;
+        // Prevent additional matches
+        wl_list_remove(&ctx->link);
+        wl_list_init(&ctx->link);
+}
+void launcher_ctx_destroy(struct launcher_ctx *ctx) {
+        if (ctx == NULL) {
+                return;
+        }
+        wl_list_remove(&ctx->node_destroy.link);
+        wl_list_remove(&ctx->token_destroy.link);
+        if (ctx->seat) {
+                wl_list_remove(&ctx->seat_destroy.link);
+        }
+        wl_list_remove(&ctx->link);
+        wlr_xdg_activation_token_v1_destroy(ctx->token);
+        free(ctx->fallback_name);
+        free(ctx);
+}
+struct launcher_ctx *launcher_ctx_find_pid(pid_t pid) {
+        if (wl_list_empty(&server.pending_launcher_ctxs)) {
+                return NULL;
+        }
+        struct launcher_ctx *ctx = NULL;
+        sway_log(SWAY_DEBUG, "Looking up workspace for pid %d", pid);
+        do {
+                struct launcher_ctx *_ctx = NULL;
+                wl_list_for_each(_ctx, &server.pending_launcher_ctxs, link) {
+                        if (pid == _ctx->pid) {
+                                ctx = _ctx;
+                                sway_log(SWAY_DEBUG,
+                                        "found %s match for pid %d: %s",
+                                        node_type_to_str(ctx->node->type), pid, node_get_name(ctx->node));
+                                break;
+                        }
+                }
+                pid = get_parent_pid(pid);
+        } while (pid > 1);
+        return ctx;
+}
+struct sway_workspace *launcher_ctx_get_workspace(
+                struct launcher_ctx *ctx) {
+        struct sway_workspace *ws = NULL;
+        struct sway_output *output = NULL;
+        switch (ctx->node->type) {
+        case N_CONTAINER:
+                // Unimplemented
+                // TODO: add container matching?
+                ws = ctx->node->sway_container->pending.workspace;
+                break;
+        case N_WORKSPACE:
+                ws = ctx->node->sway_workspace;
+                break;
+        case N_OUTPUT:
+                output = ctx->node->sway_output;
+                ws = workspace_by_name(ctx->fallback_name);
+                if (!ws) {
+                        sway_log(SWAY_DEBUG,
+                                        "Creating workspace %s for pid %d because it disappeared",
+                                        ctx->fallback_name, ctx->pid);
+                        if (!output->enabled) {
+                                sway_log(SWAY_DEBUG,
+                                                "Workspace output %s is disabled, trying another one",
+                                                output->wlr_output->name);
+                                output = NULL;
+                        }
+                        ws = workspace_create(output, ctx->fallback_name);
+                }
+                break;
+        case N_ROOT:
+                ws = workspace_create(NULL, ctx->fallback_name);
+                break;
+        }
+        return ws;
+}
+static void ctx_handle_node_destroy(struct wl_listener *listener, void *data) {
+        struct launcher_ctx *ctx = wl_container_of(listener, ctx, node_destroy);
+        switch (ctx->node->type) {
+        case N_CONTAINER:
+                // Unimplemented
+                break;
+        case N_WORKSPACE:;
+                struct sway_workspace *ws = ctx->node->sway_workspace;
+                wl_list_remove(&ctx->node_destroy.link);
+                wl_list_init(&ctx->node_destroy.link);
+                // We want to save this ws name to recreate later, hopefully on the
+                // same output
+                free(ctx->fallback_name);
+                ctx->fallback_name = strdup(ws->name);
+                if (!ws->output || ws->output->node.destroying) {
+                        // If the output is being destroyed it would be pointless to track
+                        // If the output is being disabled, we'll find out if it's still
+                        // disabled when we try to match it.
+                        ctx->node = &root->node;
+                        break;
+                }
+                ctx->node = &ws->output->node;
+                wl_signal_add(&ctx->node->events.destroy, &ctx->node_destroy);
+                break;
+        case N_OUTPUT:
+                wl_list_remove(&ctx->node_destroy.link);
+                wl_list_init(&ctx->node_destroy.link);
+                // We'll make the ws ctx->name somewhere else
+                ctx->node = &root->node;
+                break;
+        case N_ROOT:
+                // Unreachable
+                break;
+        }
+}
+static void token_handle_destroy(struct wl_listener *listener, void *data) {
+        struct launcher_ctx *ctx = wl_container_of(listener, ctx, token_destroy);
+        ctx->token = NULL;
+        launcher_ctx_destroy(ctx);
+}
+struct launcher_ctx *launcher_ctx_create(struct wlr_xdg_activation_token_v1 *token,
+                struct sway_node *node) {
+        struct launcher_ctx *ctx = calloc(1, sizeof(struct launcher_ctx));
+        const char *fallback_name = NULL;
+        struct sway_workspace *ws = NULL;
+        switch (node->type) {
+        case N_CONTAINER:
+                // Unimplemented
+                free(ctx);
+                return NULL;
+        case N_WORKSPACE:
+                ws = node->sway_workspace;
+                fallback_name = ws->name;
+                break;
+        case N_OUTPUT:;
+                struct sway_output *output = node->sway_output;
+                ws = output_get_active_workspace(output);
+                fallback_name = ws ? ws->name : NULL;
+                break;
+        case N_ROOT:
+                // Unimplemented
+                free(ctx);
+                return NULL;
+        }
+        if (!fallback_name) {
+                // TODO: implement a better fallback.
+                free(ctx);
+                return NULL;
+        }
+        ctx->fallback_name = strdup(fallback_name);
+        ctx->token = token;
+        ctx->node = node;
+        // Having surface set means that the focus check in wlroots has passed
+        ctx->had_focused_surface = token->surface != NULL;
+        ctx->node_destroy.notify = ctx_handle_node_destroy;
+        wl_signal_add(&ctx->node->events.destroy, &ctx->node_destroy);
+        ctx->token_destroy.notify = token_handle_destroy;
+        wl_signal_add(&token->events.destroy, &ctx->token_destroy);
+        wl_list_init(&ctx->link);
+        wl_list_insert(&server.pending_launcher_ctxs, &ctx->link);
+        token->data = ctx;
+        return ctx;
+}
+static void launch_ctx_handle_seat_destroy(struct wl_listener *listener, void *data) {
+        struct launcher_ctx *ctx = wl_container_of(listener, ctx, seat_destroy);
+        ctx->seat = NULL;
+        wl_list_remove(&ctx->seat_destroy.link);
+}
+// Creates a context with a new token for the internal launcher
+struct launcher_ctx *launcher_ctx_create_internal(void) {
+        struct sway_seat *seat = input_manager_current_seat();
+        struct sway_workspace *ws = seat_get_focused_workspace(seat);
+        if (!ws) {
+                sway_log(SWAY_DEBUG, "Failed to create launch context. No workspace.");
+                return NULL;
+        }
+        struct wlr_xdg_activation_token_v1 *token =
+                wlr_xdg_activation_token_v1_create(server.xdg_activation_v1);
+        struct launcher_ctx *ctx = launcher_ctx_create(token, &ws->node);
+        if (!ctx) {
+                wlr_xdg_activation_token_v1_destroy(token);
+                return NULL;
+        }
+        ctx->seat = seat;
+        ctx->seat_destroy.notify = launch_ctx_handle_seat_destroy;
+        wl_signal_add(&seat->wlr_seat->events.destroy, &ctx->seat_destroy);
+        return ctx;
+}
+const char *launcher_ctx_get_token_name(struct launcher_ctx *ctx) {
+        const char *token = wlr_xdg_activation_token_v1_get_name(ctx->token);
+        return token;
+}
diff --git a/sway/desktop/layer_shell.c b/sway/desktop/layer_shell.c
index cadc702a..6221b7b9 100644
--- a/sway/desktop/layer_shell.c
+++ b/sway/desktop/layer_shell.c
@@ -2,10 +2,14 @@
 #include <stdlib.h>
 #include <string.h>
 #include <wayland-server-core.h>
+#include <wlr/types/wlr_fractional_scale_v1.h>
 #include <wlr/types/wlr_layer_shell_v1.h>
-#include <wlr/types/wlr_output_damage.h>
 #include <wlr/types/wlr_output.h>
+#include <wlr/types/wlr_scene.h>
+#include <wlr/types/wlr_subcompositor.h>
+#include <wlr/types/wlr_xdg_shell.h>
 #include "log.h"
+#include "sway/scene_descriptor.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/input-manager.h"
@@ -16,163 +20,55 @@
 #include "sway/tree/arrange.h"
 #include "sway/tree/workspace.h"
-static void apply_exclusive(struct wlr_box *usable_area,
+struct wlr_layer_surface_v1 *toplevel_layer_surface_from_surface(
-                uint32_t anchor, int32_t exclusive,
+                struct wlr_surface *surface) {
-                int32_t margin_top, int32_t margin_right,
+        struct wlr_layer_surface_v1 *layer;
-                int32_t margin_bottom, int32_t margin_left) {
+        do {
-        if (exclusive <= 0) {
+                if (!surface) {
-                return;
+                        return NULL;
-        }
+                }
-        struct {
+                // Topmost layer surface
-                uint32_t singular_anchor;
+                if ((layer = wlr_layer_surface_v1_try_from_wlr_surface(surface))) {
-                uint32_t anchor_triplet;
+                        return layer;
-                int *positive_axis;
+                }
-                int *negative_axis;
+                // Layer subsurface
-                int margin;
+                if (wlr_subsurface_try_from_wlr_surface(surface)) {
-        } edges[] = {
+                        surface = wlr_surface_get_root_surface(surface);
-                // Top
+                        continue;
-                {
+                }
-                        .singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP,
-                        .anchor_triplet =
+                // Layer surface popup
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+                struct wlr_xdg_surface *xdg_surface = NULL;
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
+                if ((xdg_surface = wlr_xdg_surface_try_from_wlr_surface(surface)) &&
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP,
+                                xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP && xdg_surface->popup != NULL) {
-                        .positive_axis = &usable_area->y,
+                        if (!xdg_surface->popup->parent) {
-                        .negative_axis = &usable_area->height,
+                                return NULL;
-                        .margin = margin_top,
-                },
-                // Bottom
-                {
-                        .singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
-                        .anchor_triplet =
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
-                        .positive_axis = NULL,
-                        .negative_axis = &usable_area->height,
-                        .margin = margin_bottom,
-                },
-                // Left
-                {
-                        .singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT,
-                        .anchor_triplet =
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
-                        .positive_axis = &usable_area->x,
-                        .negative_axis = &usable_area->width,
-                        .margin = margin_left,
-                },
-                // Right
-                {
-                        .singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT,
-                        .anchor_triplet =
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
-                                ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
-                        .positive_axis = NULL,
-                        .negative_axis = &usable_area->width,
-                        .margin = margin_right,
-                },
-        };
-        for (size_t i = 0; i < sizeof(edges) / sizeof(edges[0]); ++i) {
-                if ((anchor  == edges[i].singular_anchor || anchor == edges[i].anchor_triplet)
-                                && exclusive + edges[i].margin > 0) {
-                        if (edges[i].positive_axis) {
-                                *edges[i].positive_axis += exclusive + edges[i].margin;
-                        }
-                        if (edges[i].negative_axis) {
-                                *edges[i].negative_axis -= exclusive + edges[i].margin;
                        }
-                        break;
+                        surface = wlr_surface_get_root_surface(xdg_surface->popup->parent);
+                        continue;
                }
-        }
+                // Return early if the surface is not a layer/xdg_popup/sub surface
+                return NULL;
+        } while (true);
 }
-static void arrange_layer(struct sway_output *output, struct wl_list *list,
+static void arrange_surface(struct sway_output *output, const struct wlr_box *full_area,
-                struct wlr_box *usable_area, bool exclusive) {
+                struct wlr_box *usable_area, struct wlr_scene_tree *tree) {
-        struct sway_layer_surface *sway_layer;
+        struct wlr_scene_node *node;
-        struct wlr_box full_area = { 0 };
+        wl_list_for_each(node, &tree->children, link) {
-        wlr_output_effective_resolution(output->wlr_output,
+                struct sway_layer_surface *surface = scene_descriptor_try_get(node,
-                        &full_area.width, &full_area.height);
+                        SWAY_SCENE_DESC_LAYER_SHELL);
-        wl_list_for_each(sway_layer, list, link) {
+                // surface could be null during destruction
-                struct wlr_layer_surface_v1 *layer = sway_layer->layer_surface;
+                if (!surface) {
-                struct wlr_layer_surface_v1_state *state = &layer->current;
-                if (exclusive != (state->exclusive_zone > 0)) {
                        continue;
                }
-                struct wlr_box bounds;
-                if (state->exclusive_zone == -1) {
+                if (!surface->scene->layer_surface->initialized) {
-                        bounds = full_area;
-                } else {
-                        bounds = *usable_area;
-                }
-                struct wlr_box box = {
-                        .width = state->desired_width,
-                        .height = state->desired_height
-                };
-                // Horizontal axis
-                const uint32_t both_horiz = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT
-                        | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
-                if (box.width == 0) {
-                        box.x = bounds.x;
-                } else if ((state->anchor & both_horiz) == both_horiz) {
-                        box.x = bounds.x + ((bounds.width / 2) - (box.width / 2));
-                } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
-                        box.x = bounds.x;
-                } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
-                        box.x = bounds.x + (bounds.width - box.width);
-                } else {
-                        box.x = bounds.x + ((bounds.width / 2) - (box.width / 2));
-                }
-                // Vertical axis
-                const uint32_t both_vert = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
-                        | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
-                if (box.height == 0) {
-                        box.y = bounds.y;
-                } else if ((state->anchor & both_vert) == both_vert) {
-                        box.y = bounds.y + ((bounds.height / 2) - (box.height / 2));
-                } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
-                        box.y = bounds.y;
-                } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
-                        box.y = bounds.y + (bounds.height - box.height);
-                } else {
-                        box.y = bounds.y + ((bounds.height / 2) - (box.height / 2));
-                }
-                // Margin
-                if (box.width == 0) {
-                        box.x += state->margin.left;
-                        box.width = bounds.width -
-                                (state->margin.left + state->margin.right);
-                } else if ((state->anchor & both_horiz) == both_horiz) {
-                        // don't apply margins
-                } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
-                        box.x += state->margin.left;
-                } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
-                        box.x -= state->margin.right;
-                }
-                if (box.height == 0) {
-                        box.y += state->margin.top;
-                        box.height = bounds.height -
-                                (state->margin.top + state->margin.bottom);
-                } else if ((state->anchor & both_vert) == both_vert) {
-                        // don't apply margins
-                } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
-                        box.y += state->margin.top;
-                } else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
-                        box.y -= state->margin.bottom;
-                }
-                if (box.width < 0 || box.height < 0) {
-                        // TODO: Bubble up a protocol error?
-                        wlr_layer_surface_v1_close(layer);
                        continue;
                }
-                // Apply
-                sway_layer->geo = box;
+                wlr_scene_layer_surface_v1_configure(surface->scene, full_area, usable_area);
-                apply_exclusive(usable_area, state->anchor, state->exclusive_zone,
-                                state->margin.top, state->margin.right,
-                                state->margin.bottom, state->margin.left);
-                wlr_layer_surface_v1_configure(layer, box.width, box.height);
        }
 }
@@ -180,81 +76,94 @@ void arrange_layers(struct sway_output *output) {
        struct wlr_box usable_area = { 0 };
        wlr_output_effective_resolution(output->wlr_output,
                        &usable_area.width, &usable_area.height);
+        const struct wlr_box full_area = usable_area;
+        arrange_surface(output, &full_area, &usable_area, output->layers.shell_background);
+        arrange_surface(output, &full_area, &usable_area, output->layers.shell_bottom);
+        arrange_surface(output, &full_area, &usable_area, output->layers.shell_top);
+        arrange_surface(output, &full_area, &usable_area, output->layers.shell_overlay);
-        // Arrange exclusive surfaces from top->bottom
+        if (!wlr_box_equal(&usable_area, &output->usable_area)) {
-        arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
-                        &usable_area, true);
-        arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
-                        &usable_area, true);
-        arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
-                        &usable_area, true);
-        arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
-                        &usable_area, true);
-        if (memcmp(&usable_area, &output->usable_area,
-                                sizeof(struct wlr_box)) != 0) {
                sway_log(SWAY_DEBUG, "Usable area changed, rearranging output");
-                memcpy(&output->usable_area, &usable_area, sizeof(struct wlr_box));
+                output->usable_area = usable_area;
                arrange_output(output);
+        } else {
+                arrange_popups(root->layers.popup);
        }
+}
-        // Arrange non-exclusive surfaces from top->bottom
+static struct wlr_scene_tree *sway_layer_get_scene(struct sway_output *output,
-        arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
+                enum zwlr_layer_shell_v1_layer type) {
-                        &usable_area, false);
+        switch (type) {
-        arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
+        case ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND:
-                        &usable_area, false);
+                return output->layers.shell_background;
-        arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
+        case ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM:
-                        &usable_area, false);
+                return output->layers.shell_bottom;
-        arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
+        case ZWLR_LAYER_SHELL_V1_LAYER_TOP:
-                        &usable_area, false);
+                return output->layers.shell_top;
+        case ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY:
-        // Find topmost keyboard interactive layer, if such a layer exists
+                return output->layers.shell_overlay;
-        uint32_t layers_above_shell[] = {
-                ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY,
-                ZWLR_LAYER_SHELL_V1_LAYER_TOP,
-        };
-        size_t nlayers = sizeof(layers_above_shell) / sizeof(layers_above_shell[0]);
-        struct sway_layer_surface *layer, *topmost = NULL;
-        for (size_t i = 0; i < nlayers; ++i) {
-                wl_list_for_each_reverse(layer,
-                                &output->layers[layers_above_shell[i]], link) {
-                        if (layer->layer_surface->current.keyboard_interactive &&
-                                        layer->layer_surface->mapped) {
-                                topmost = layer;
-                                break;
-                        }
-                }
-                if (topmost != NULL) {
-                        break;
-                }
        }
-        struct sway_seat *seat;
+        sway_assert(false, "unreachable");
-        wl_list_for_each(seat, &server.input->seats, link) {
+        return NULL;
-                if (topmost != NULL) {
+}
-                        seat_set_focus_layer(seat, topmost->layer_surface);
-                } else if (seat->focused_layer &&
+static struct sway_layer_surface *sway_layer_surface_create(
-                                !seat->focused_layer->current.keyboard_interactive) {
+                struct wlr_scene_layer_surface_v1 *scene) {
-                        seat_set_focus_layer(seat, NULL);
+        struct sway_layer_surface *surface = calloc(1, sizeof(*surface));
-                }
+        if (!surface) {
+                sway_log(SWAY_ERROR, "Could not allocate a scene_layer surface");
+                return NULL;
+        }
+        struct wlr_scene_tree *popups = wlr_scene_tree_create(root->layers.popup);
+        if (!popups) {
+                sway_log(SWAY_ERROR, "Could not allocate a scene_layer popup node");
+                free(surface);
+                return NULL;
+        }
+        surface->desc.relative = &scene->tree->node;
+        if (!scene_descriptor_assign(&popups->node,
+                        SWAY_SCENE_DESC_POPUP, &surface->desc)) {
+                sway_log(SWAY_ERROR, "Failed to allocate a popup scene descriptor");
+                wlr_scene_node_destroy(&popups->node);
+                free(surface);
+                return NULL;
        }
+        surface->tree = scene->tree;
+        surface->scene = scene;
+        surface->layer_surface = scene->layer_surface;
+        surface->popups = popups;
+        surface->layer_surface->data = surface;
+        return surface;
 }
 static struct sway_layer_surface *find_mapped_layer_by_client(
-                struct wl_client *client, struct wlr_output *ignore_output) {
+                struct wl_client *client, struct sway_output *ignore_output) {
        for (int i = 0; i < root->outputs->length; ++i) {
                struct sway_output *output = root->outputs->items[i];
-                if (output->wlr_output == ignore_output) {
+                if (output == ignore_output) {
                        continue;
                }
                // For now we'll only check the overlay layer
-                struct sway_layer_surface *lsurface;
+                struct wlr_scene_node *node;
-                wl_list_for_each(lsurface,
+                wl_list_for_each (node, &output->layers.shell_overlay->children, link) {
-                                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], link) {
+                        struct sway_layer_surface *surface = scene_descriptor_try_get(node,
-                        struct wl_resource *resource = lsurface->layer_surface->resource;
+                                SWAY_SCENE_DESC_LAYER_SHELL);
+                        if (!surface) {
+                                continue;
+                        }
+                        struct wlr_layer_surface_v1 *layer_surface = surface->layer_surface;
+                        struct wl_resource *resource = layer_surface->resource;
                        if (wl_resource_get_client(resource) == client
-                                        && lsurface->layer_surface->mapped) {
+                                        && layer_surface->surface->mapped) {
-                                return lsurface;
+                                return surface;
                        }
                }
        }
@@ -262,280 +171,142 @@ static struct sway_layer_surface *find_mapped_layer_by_client(
 }
 static void handle_output_destroy(struct wl_listener *listener, void *data) {
-        struct sway_layer_surface *sway_layer =
+        struct sway_layer_surface *layer =
-                wl_container_of(listener, sway_layer, output_destroy);
+                wl_container_of(listener, layer, output_destroy);
-        // Determine if this layer is being used by an exclusive client. If it is,
-        // try and find another layer owned by this client to pass focus to.
-        struct sway_seat *seat = input_manager_get_default_seat();
-        struct wl_client *client =
-                wl_resource_get_client(sway_layer->layer_surface->resource);
-        bool set_focus = seat->exclusive_client == client;
-        wl_list_remove(&sway_layer->output_destroy.link);
-        wl_list_remove(&sway_layer->link);
-        wl_list_init(&sway_layer->link);
-        if (set_focus) {
-                struct sway_layer_surface *layer =
-                        find_mapped_layer_by_client(client, sway_layer->layer_surface->output);
-                if (layer) {
-                        seat_set_focus_layer(seat, layer->layer_surface);
-                }
-        }
-        sway_layer->layer_surface->output = NULL;
+        layer->output = NULL;
-        wlr_layer_surface_v1_close(sway_layer->layer_surface);
+        wlr_scene_node_destroy(&layer->scene->tree->node);
 }
-static void handle_surface_commit(struct wl_listener *listener, void *data) {
+static void handle_node_destroy(struct wl_listener *listener, void *data) {
        struct sway_layer_surface *layer =
-                wl_container_of(listener, layer, surface_commit);
+                wl_container_of(listener, layer, node_destroy);
-        struct wlr_layer_surface_v1 *layer_surface = layer->layer_surface;
-        struct wlr_output *wlr_output = layer_surface->output;
-        if (wlr_output == NULL) {
-                return;
-        }
-        struct sway_output *output = wlr_output->data;
+        // destroy the scene descriptor straight away if it exists, otherwise
-        struct wlr_box old_geo = layer->geo;
+        // we will try to reflow still considering the destroyed node.
-        arrange_layers(output);
+        scene_descriptor_destroy(&layer->tree->node, SWAY_SCENE_DESC_LAYER_SHELL);
-        bool geo_changed =
-                memcmp(&old_geo, &layer->geo, sizeof(struct wlr_box)) != 0;
-        bool layer_changed = layer->layer != layer_surface->current.layer;
-        if (layer_changed) {
-                wl_list_remove(&layer->link);
-                wl_list_insert(&output->layers[layer_surface->current.layer],
-                        &layer->link);
-                layer->layer = layer_surface->current.layer;
-        }
-        if (geo_changed || layer_changed) {
-                output_damage_surface(output, old_geo.x, old_geo.y,
-                        layer_surface->surface, true);
-                output_damage_surface(output, layer->geo.x, layer->geo.y,
-                        layer_surface->surface, true);
-        } else {
-                output_damage_surface(output, layer->geo.x, layer->geo.y,
-                        layer_surface->surface, false);
-        }
-        transaction_commit_dirty();
-}
-static void unmap(struct sway_layer_surface *sway_layer) {
+        // Determine if this layer is being used by an exclusive client. If it is,
-        struct sway_seat *seat;
+        // try and find another layer owned by this client to pass focus to.
-        wl_list_for_each(seat, &server.input->seats, link) {
+        struct sway_seat *seat = input_manager_get_default_seat();
-                if (seat->focused_layer == sway_layer->layer_surface) {
+        struct wl_client *client =
-                        seat_set_focus_layer(seat, NULL);
+                wl_resource_get_client(layer->layer_surface->resource);
+        if (!server.session_lock.lock) {
+                struct sway_layer_surface *consider_layer =
+                        find_mapped_layer_by_client(client, layer->output);
+                if (consider_layer) {
+                        seat_set_focus_layer(seat, consider_layer->layer_surface);
                }
        }
-        cursor_rebase_all();
+        if (layer->output) {
+                arrange_layers(layer->output);
-        struct wlr_output *wlr_output = sway_layer->layer_surface->output;
+                transaction_commit_dirty();
-        if (wlr_output == NULL) {
-                return;
        }
-        struct sway_output *output = wlr_output->data;
-        if (output == NULL) {
-                return;
-        }
-        output_damage_surface(output, sway_layer->geo.x, sway_layer->geo.y,
-                sway_layer->layer_surface->surface, true);
-}
-static void handle_destroy(struct wl_listener *listener, void *data) {
+        wlr_scene_node_destroy(&layer->popups->node);
-        struct sway_layer_surface *sway_layer =
-                wl_container_of(listener, sway_layer, destroy);
-        sway_log(SWAY_DEBUG, "Layer surface destroyed (%s)",
-                sway_layer->layer_surface->namespace);
-        if (sway_layer->layer_surface->mapped) {
-                unmap(sway_layer);
-        }
-        wl_list_remove(&sway_layer->link);
-        wl_list_remove(&sway_layer->destroy.link);
-        wl_list_remove(&sway_layer->map.link);
-        wl_list_remove(&sway_layer->unmap.link);
-        wl_list_remove(&sway_layer->surface_commit.link);
-        wl_list_remove(&sway_layer->new_popup.link);
-        wl_list_remove(&sway_layer->new_subsurface.link);
-        if (sway_layer->layer_surface->output != NULL) {
-                struct sway_output *output = sway_layer->layer_surface->output->data;
-                if (output != NULL) {
-                        arrange_layers(output);
-                        transaction_commit_dirty();
-                }
-                wl_list_remove(&sway_layer->output_destroy.link);
-                sway_layer->layer_surface->output = NULL;
-        }
-        free(sway_layer);
-}
-static void handle_map(struct wl_listener *listener, void *data) {
+        wl_list_remove(&layer->map.link);
-        struct sway_layer_surface *sway_layer = wl_container_of(listener,
+        wl_list_remove(&layer->unmap.link);
-                        sway_layer, map);
+        wl_list_remove(&layer->surface_commit.link);
-        struct sway_output *output = sway_layer->layer_surface->output->data;
+        wl_list_remove(&layer->node_destroy.link);
-        output_damage_surface(output, sway_layer->geo.x, sway_layer->geo.y,
+        wl_list_remove(&layer->output_destroy.link);
-                sway_layer->layer_surface->surface, true);
-        wlr_surface_send_enter(sway_layer->layer_surface->surface,
-                sway_layer->layer_surface->output);
-        cursor_rebase_all();
-}
-static void handle_unmap(struct wl_listener *listener, void *data) {
+        layer->layer_surface->data = NULL;
-        struct sway_layer_surface *sway_layer = wl_container_of(
-                        listener, sway_layer, unmap);
-        unmap(sway_layer);
-}
-static void subsurface_damage(struct sway_layer_subsurface *subsurface,
+        free(layer);
-                bool whole) {
-        struct sway_layer_surface *layer = subsurface->layer_surface;
-        struct wlr_output *wlr_output = layer->layer_surface->output;
-        if (!wlr_output) {
-                return;
-        }
-        struct sway_output *output = wlr_output->data;
-        int ox = subsurface->wlr_subsurface->current.x + layer->geo.x;
-        int oy = subsurface->wlr_subsurface->current.y + layer->geo.y;
-        output_damage_surface(
-                        output, ox, oy, subsurface->wlr_subsurface->surface, whole);
 }
-static void subsurface_handle_unmap(struct wl_listener *listener, void *data) {
+static void handle_surface_commit(struct wl_listener *listener, void *data) {
-        struct sway_layer_subsurface *subsurface =
+        struct sway_layer_surface *surface =
-                        wl_container_of(listener, subsurface, unmap);
+                wl_container_of(listener, surface, surface_commit);
-        subsurface_damage(subsurface, true);
-}
-static void subsurface_handle_map(struct wl_listener *listener, void *data) {
-        struct sway_layer_subsurface *subsurface =
-                        wl_container_of(listener, subsurface, map);
-        subsurface_damage(subsurface, true);
-}
-static void subsurface_handle_commit(struct wl_listener *listener, void *data) {
-        struct sway_layer_subsurface *subsurface =
-                        wl_container_of(listener, subsurface, commit);
-        subsurface_damage(subsurface, false);
-}
-static void subsurface_handle_destroy(struct wl_listener *listener,
-                void *data) {
-        struct sway_layer_subsurface *subsurface =
-                        wl_container_of(listener, subsurface, destroy);
-        wl_list_remove(&subsurface->map.link);
-        wl_list_remove(&subsurface->unmap.link);
-        wl_list_remove(&subsurface->destroy.link);
-        wl_list_remove(&subsurface->commit.link);
-        free(subsurface);
-}
-static struct sway_layer_subsurface *create_subsurface(
+        struct wlr_layer_surface_v1 *layer_surface = surface->layer_surface;
-                struct wlr_subsurface *wlr_subsurface,
+        if (!layer_surface->initialized) {
-                struct sway_layer_surface *layer_surface) {
+                return;
-        struct sway_layer_subsurface *subsurface =
-                        calloc(1, sizeof(struct sway_layer_subsurface));
-        if (subsurface == NULL) {
-                return NULL;
        }
-        subsurface->wlr_subsurface = wlr_subsurface;
+        uint32_t committed = layer_surface->current.committed;
-        subsurface->layer_surface = layer_surface;
+        if (committed & WLR_LAYER_SURFACE_V1_STATE_LAYER) {
+                enum zwlr_layer_shell_v1_layer layer_type = layer_surface->current.layer;
-        subsurface->map.notify = subsurface_handle_map;
+                struct wlr_scene_tree *output_layer = sway_layer_get_scene(
-        wl_signal_add(&wlr_subsurface->events.map, &subsurface->map);
+                        surface->output, layer_type);
-        subsurface->unmap.notify = subsurface_handle_unmap;
+                wlr_scene_node_reparent(&surface->scene->tree->node, output_layer);
-        wl_signal_add(&wlr_subsurface->events.unmap, &subsurface->unmap);
+        }
-        subsurface->destroy.notify = subsurface_handle_destroy;
-        wl_signal_add(&wlr_subsurface->events.destroy, &subsurface->destroy);
-        subsurface->commit.notify = subsurface_handle_commit;
-        wl_signal_add(&wlr_subsurface->surface->events.commit, &subsurface->commit);
-        return subsurface;
-}
-static void handle_new_subsurface(struct wl_listener *listener, void *data) {
-        struct sway_layer_surface *sway_layer_surface =
-                        wl_container_of(listener, sway_layer_surface, new_subsurface);
-        struct wlr_subsurface *wlr_subsurface = data;
-        create_subsurface(wlr_subsurface, sway_layer_surface);
-}
-static struct sway_layer_surface *popup_get_layer(
+        if (layer_surface->initial_commit || committed || layer_surface->surface->mapped != surface->mapped) {
-                struct sway_layer_popup *popup) {
+                surface->mapped = layer_surface->surface->mapped;
-        while (popup->parent_type == LAYER_PARENT_POPUP) {
+                arrange_layers(surface->output);
-                popup = popup->parent_popup;
+                transaction_commit_dirty();
        }
-        return popup->parent_layer;
 }
-static void popup_damage(struct sway_layer_popup *layer_popup, bool whole) {
+static void handle_map(struct wl_listener *listener, void *data) {
-        struct wlr_xdg_popup *popup = layer_popup->wlr_popup;
+        struct sway_layer_surface *surface = wl_container_of(listener,
-        struct wlr_surface *surface = popup->base->surface;
+                        surface, map);
-        int popup_sx = popup->geometry.x - popup->base->geometry.x;
-        int popup_sy = popup->geometry.y - popup->base->geometry.y;
+        struct wlr_layer_surface_v1 *layer_surface =
-        int ox = popup_sx, oy = popup_sy;
+                                surface->scene->layer_surface;
-        struct sway_layer_surface *layer;
-        while (true) {
+        // focus on new surface
-                if (layer_popup->parent_type == LAYER_PARENT_POPUP) {
+        if (layer_surface->current.keyboard_interactive &&
-                        layer_popup = layer_popup->parent_popup;
+                        (layer_surface->current.layer == ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY ||
-                        ox += layer_popup->wlr_popup->geometry.x;
+                        layer_surface->current.layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP)) {
-                        oy += layer_popup->wlr_popup->geometry.y;
+                struct sway_seat *seat;
-                } else {
+                wl_list_for_each(seat, &server.input->seats, link) {
-                        layer = layer_popup->parent_layer;
+                        // but only if the currently focused layer has a lower precedence
-                        ox += layer->geo.x;
+                        if (!seat->focused_layer ||
-                        oy += layer->geo.y;
+                                        seat->focused_layer->current.layer >= layer_surface->current.layer) {
-                        break;
+                                seat_set_focus_layer(seat, layer_surface);
+                        }
                }
+                arrange_layers(surface->output);
        }
-        struct wlr_output *wlr_output = layer->layer_surface->output;
-        struct sway_output *output = wlr_output->data;
-        output_damage_surface(output, ox, oy, surface, whole);
-}
-static void popup_handle_map(struct wl_listener *listener, void *data) {
+        cursor_rebase_all();
-        struct sway_layer_popup *popup = wl_container_of(listener, popup, map);
-        struct sway_layer_surface *layer = popup_get_layer(popup);
-        struct wlr_output *wlr_output = layer->layer_surface->output;
-        wlr_surface_send_enter(popup->wlr_popup->base->surface, wlr_output);
-        popup_damage(popup, true);
 }
-static void popup_handle_unmap(struct wl_listener *listener, void *data) {
+static void handle_unmap(struct wl_listener *listener, void *data) {
-        struct sway_layer_popup *popup = wl_container_of(listener, popup, unmap);
+        struct sway_layer_surface *surface = wl_container_of(
-        popup_damage(popup, true);
+                        listener, surface, unmap);
-}
+        struct sway_seat *seat;
+        wl_list_for_each(seat, &server.input->seats, link) {
+                if (seat->focused_layer == surface->layer_surface) {
+                        seat_set_focus_layer(seat, NULL);
+                }
+        }
-static void popup_handle_commit(struct wl_listener *listener, void *data) {
+        cursor_rebase_all();
-        struct sway_layer_popup *popup = wl_container_of(listener, popup, commit);
-        popup_damage(popup, false);
 }
 static void popup_handle_destroy(struct wl_listener *listener, void *data) {
        struct sway_layer_popup *popup =
                wl_container_of(listener, popup, destroy);
-        wl_list_remove(&popup->map.link);
-        wl_list_remove(&popup->unmap.link);
        wl_list_remove(&popup->destroy.link);
+        wl_list_remove(&popup->new_popup.link);
        wl_list_remove(&popup->commit.link);
        free(popup);
 }
 static void popup_unconstrain(struct sway_layer_popup *popup) {
-        struct sway_layer_surface *layer = popup_get_layer(popup);
        struct wlr_xdg_popup *wlr_popup = popup->wlr_popup;
+        struct sway_output *output = popup->toplevel->output;
-        struct sway_output *output = layer->layer_surface->output->data;
+        // if a client tries to create a popup while we are in the process of destroying
+        // its output, don't crash.
+        if (!output) {
+                return;
+        }
+        int lx, ly;
+        wlr_scene_node_coords(&popup->toplevel->scene->tree->node, &lx, &ly);
        // the output box expressed in the coordinate system of the toplevel parent
        // of the popup
        struct wlr_box output_toplevel_sx_box = {
-                .x = -layer->geo.x,
+                .x = output->lx - lx,
-                .y = -layer->geo.y,
+                .y = output->ly - ly,
                .width = output->width,
                .height = output->height,
        };
@@ -543,32 +314,38 @@ static void popup_unconstrain(struct sway_layer_popup *popup) {
        wlr_xdg_popup_unconstrain_from_box(wlr_popup, &output_toplevel_sx_box);
 }
+static void popup_handle_commit(struct wl_listener *listener, void *data) {
+        struct sway_layer_popup *popup = wl_container_of(listener, popup, commit);
+        if (popup->wlr_popup->base->initial_commit) {
+                popup_unconstrain(popup);
+        }
+}
 static void popup_handle_new_popup(struct wl_listener *listener, void *data);
 static struct sway_layer_popup *create_popup(struct wlr_xdg_popup *wlr_popup,
-                enum layer_parent parent_type, void *parent) {
+                struct sway_layer_surface *toplevel, struct wlr_scene_tree *parent) {
-        struct sway_layer_popup *popup =
+        struct sway_layer_popup *popup = calloc(1, sizeof(*popup));
-                calloc(1, sizeof(struct sway_layer_popup));
        if (popup == NULL) {
                return NULL;
        }
+        popup->toplevel = toplevel;
        popup->wlr_popup = wlr_popup;
-        popup->parent_type = parent_type;
+        popup->scene = wlr_scene_xdg_surface_create(parent,
-        popup->parent_layer = parent;
+                wlr_popup->base);
+        if (!popup->scene) {
+                free(popup);
+                return NULL;
+        }
-        popup->map.notify = popup_handle_map;
-        wl_signal_add(&wlr_popup->base->events.map, &popup->map);
-        popup->unmap.notify = popup_handle_unmap;
-        wl_signal_add(&wlr_popup->base->events.unmap, &popup->unmap);
        popup->destroy.notify = popup_handle_destroy;
        wl_signal_add(&wlr_popup->base->events.destroy, &popup->destroy);
-        popup->commit.notify = popup_handle_commit;
-        wl_signal_add(&wlr_popup->base->surface->events.commit, &popup->commit);
        popup->new_popup.notify = popup_handle_new_popup;
        wl_signal_add(&wlr_popup->base->events.new_popup, &popup->new_popup);
+        popup->commit.notify = popup_handle_commit;
-        popup_unconstrain(popup);
+        wl_signal_add(&wlr_popup->base->surface->events.commit, &popup->commit);
        return popup;
 }
@@ -577,19 +354,14 @@ static void popup_handle_new_popup(struct wl_listener *listener, void *data) {
        struct sway_layer_popup *sway_layer_popup =
                wl_container_of(listener, sway_layer_popup, new_popup);
        struct wlr_xdg_popup *wlr_popup = data;
-        create_popup(wlr_popup, LAYER_PARENT_POPUP, sway_layer_popup);
+        create_popup(wlr_popup, sway_layer_popup->toplevel, sway_layer_popup->scene);
 }
 static void handle_new_popup(struct wl_listener *listener, void *data) {
        struct sway_layer_surface *sway_layer_surface =
                wl_container_of(listener, sway_layer_surface, new_popup);
        struct wlr_xdg_popup *wlr_popup = data;
-        create_popup(wlr_popup, LAYER_PARENT_LAYER, sway_layer_surface);
+        create_popup(wlr_popup, sway_layer_surface, sway_layer_surface->popups);
-}
-struct sway_layer_surface *layer_from_wlr_layer_surface_v1(
-                struct wlr_layer_surface_v1 *layer_surface) {
-        return layer_surface->data;
 }
 void handle_layer_shell_surface(struct wl_listener *listener, void *data) {
@@ -597,14 +369,14 @@ void handle_layer_shell_surface(struct wl_listener *listener, void *data) {
        sway_log(SWAY_DEBUG, "new layer surface: namespace %s layer %d anchor %" PRIu32
                        " size %" PRIu32 "x%" PRIu32 " margin %" PRIu32 ",%" PRIu32 ",%" PRIu32 ",%" PRIu32 ",",
                layer_surface->namespace,
-                layer_surface->client_pending.layer,
+                layer_surface->pending.layer,
-                layer_surface->client_pending.anchor,
+                layer_surface->pending.anchor,
-                layer_surface->client_pending.desired_width,
+                layer_surface->pending.desired_width,
-                layer_surface->client_pending.desired_height,
+                layer_surface->pending.desired_height,
-                layer_surface->client_pending.margin.top,
+                layer_surface->pending.margin.top,
-                layer_surface->client_pending.margin.right,
+                layer_surface->pending.margin.right,
-                layer_surface->client_pending.margin.bottom,
+                layer_surface->pending.margin.bottom,
-                layer_surface->client_pending.margin.left);
+                layer_surface->pending.margin.left);
        if (!layer_surface->output) {
                // Assign last active output
@@ -616,12 +388,12 @@ void handle_layer_shell_surface(struct wl_listener *listener, void *data) {
                                output = ws->output;
                        }
                }
-                if (!output || output == root->noop_output) {
+                if (!output || output == root->fallback_output) {
                        if (!root->outputs->length) {
                                sway_log(SWAY_ERROR,
                                                "no output to auto-assign layer surface '%s' to",
                                                layer_surface->namespace);
-                                wlr_layer_surface_v1_close(layer_surface);
+                                wlr_layer_surface_v1_destroy(layer_surface);
                                return;
                        }
                        output = root->outputs->items[0];
@@ -629,42 +401,57 @@ void handle_layer_shell_surface(struct wl_listener *listener, void *data) {
                layer_surface->output = output->wlr_output;
        }
-        struct sway_layer_surface *sway_layer =
+        struct sway_output *output = layer_surface->output->data;
-                calloc(1, sizeof(struct sway_layer_surface));
-        if (!sway_layer) {
+        enum zwlr_layer_shell_v1_layer layer_type = layer_surface->pending.layer;
+        struct wlr_scene_tree *output_layer = sway_layer_get_scene(
+                output, layer_type);
+        struct wlr_scene_layer_surface_v1 *scene_surface =
+                wlr_scene_layer_surface_v1_create(output_layer, layer_surface);
+        if (!scene_surface) {
+                sway_log(SWAY_ERROR, "Could not allocate a layer_surface_v1");
                return;
        }
-        sway_layer->surface_commit.notify = handle_surface_commit;
+        struct sway_layer_surface *surface =
-        wl_signal_add(&layer_surface->surface->events.commit,
+                sway_layer_surface_create(scene_surface);
-                &sway_layer->surface_commit);
+        if (!surface) {
+                wlr_layer_surface_v1_destroy(layer_surface);
-        sway_layer->destroy.notify = handle_destroy;
-        wl_signal_add(&layer_surface->events.destroy, &sway_layer->destroy);
-        sway_layer->map.notify = handle_map;
-        wl_signal_add(&layer_surface->events.map, &sway_layer->map);
-        sway_layer->unmap.notify = handle_unmap;
-        wl_signal_add(&layer_surface->events.unmap, &sway_layer->unmap);
-        sway_layer->new_popup.notify = handle_new_popup;
-        wl_signal_add(&layer_surface->events.new_popup, &sway_layer->new_popup);
-        sway_layer->new_subsurface.notify = handle_new_subsurface;
-        wl_signal_add(&layer_surface->surface->events.new_subsurface,
-                        &sway_layer->new_subsurface);
-        sway_layer->layer_surface = layer_surface;
-        layer_surface->data = sway_layer;
-        struct sway_output *output = layer_surface->output->data;
+                sway_log(SWAY_ERROR, "Could not allocate a sway_layer_surface");
-        sway_layer->output_destroy.notify = handle_output_destroy;
+                return;
-        wl_signal_add(&output->events.destroy, &sway_layer->output_destroy);
+        }
-        wl_list_insert(&output->layers[layer_surface->client_pending.layer],
+        if (!scene_descriptor_assign(&scene_surface->tree->node,
-                        &sway_layer->link);
+                        SWAY_SCENE_DESC_LAYER_SHELL, surface)) {
+                sway_log(SWAY_ERROR, "Failed to allocate a layer surface descriptor");
-        // Temporarily set the layer's current state to client_pending
+                // destroying the layer_surface will also destroy its corresponding
-        // So that we can easily arrange it
+                // scene node
-        struct wlr_layer_surface_v1_state old_state = layer_surface->current;
+                wlr_layer_surface_v1_destroy(layer_surface);
-        layer_surface->current = layer_surface->client_pending;
+                return;
-        arrange_layers(output);
+        }
-        layer_surface->current = old_state;
+        surface->output = output;
+        // now that the surface's output is known, we can advertise its scale
+        wlr_fractional_scale_v1_notify_scale(surface->layer_surface->surface,
+                layer_surface->output->scale);
+        wlr_surface_set_preferred_buffer_scale(surface->layer_surface->surface,
+                ceil(layer_surface->output->scale));
+        surface->surface_commit.notify = handle_surface_commit;
+        wl_signal_add(&layer_surface->surface->events.commit,
+                &surface->surface_commit);
+        surface->map.notify = handle_map;
+        wl_signal_add(&layer_surface->surface->events.map, &surface->map);
+        surface->unmap.notify = handle_unmap;
+        wl_signal_add(&layer_surface->surface->events.unmap, &surface->unmap);
+        surface->new_popup.notify = handle_new_popup;
+        wl_signal_add(&layer_surface->events.new_popup, &surface->new_popup);
+        surface->output_destroy.notify = handle_output_destroy;
+        wl_signal_add(&output->events.disable, &surface->output_destroy);
+        surface->node_destroy.notify = handle_node_destroy;
+        wl_signal_add(&scene_surface->tree->node.events.destroy, &surface->node_destroy);
 }
diff --git a/sway/desktop/output.c b/sway/desktop/output.c
index 2f2ab4bc..2722e556 100644
--- a/sway/desktop/output.c
+++ b/sway/desktop/output.c
@@ -1,41 +1,61 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <stdlib.h>
 #include <strings.h>
 #include <time.h>
 #include <wayland-server-core.h>
+#include <wlr/config.h>
+#include <wlr/backend/headless.h>
+#include <wlr/render/swapchain.h>
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_buffer.h>
+#include <wlr/types/wlr_gamma_control_v1.h>
 #include <wlr/types/wlr_matrix.h>
-#include <wlr/types/wlr_output_damage.h>
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_output_management_v1.h>
+#include <wlr/types/wlr_output_power_management_v1.h>
 #include <wlr/types/wlr_output.h>
 #include <wlr/types/wlr_presentation_time.h>
-#include <wlr/types/wlr_surface.h>
+#include <wlr/types/wlr_compositor.h>
 #include <wlr/util/region.h>
+#include <wlr/util/transform.h>
 #include "config.h"
 #include "log.h"
 #include "sway/config.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/seat.h"
+#include "sway/ipc-server.h"
 #include "sway/layers.h"
 #include "sway/output.h"
+#include "sway/scene_descriptor.h"
 #include "sway/server.h"
-#include "sway/surface.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/container.h"
 #include "sway/tree/root.h"
 #include "sway/tree/view.h"
 #include "sway/tree/workspace.h"
+#if WLR_HAS_DRM_BACKEND
+#include <wlr/backend/drm.h>
+#include <wlr/types/wlr_drm_lease_v1.h>
+#endif
+bool output_match_name_or_id(struct sway_output *output,
+                const char *name_or_id) {
+        if (strcmp(name_or_id, "*") == 0) {
+                return true;
+        }
+        char identifier[128];
+        output_get_identifier(identifier, sizeof(identifier), output);
+        return strcasecmp(identifier, name_or_id) == 0
+                || strcasecmp(output->wlr_output->name, name_or_id) == 0;
+}
 struct sway_output *output_by_name_or_id(const char *name_or_id) {
        for (int i = 0; i < root->outputs->length; ++i) {
                struct sway_output *output = root->outputs->items[i];
-                char identifier[128];
+                if (output_match_name_or_id(output, name_or_id)) {
-                output_get_identifier(identifier, sizeof(identifier), output);
-                if (strcasecmp(identifier, name_or_id) == 0
-                                || strcasecmp(output->wlr_output->name, name_or_id) == 0) {
                        return output;
                }
        }
@@ -45,513 +65,217 @@ struct sway_output *output_by_name_or_id(const char *name_or_id) {
 struct sway_output *all_output_by_name_or_id(const char *name_or_id) {
        struct sway_output *output;
        wl_list_for_each(output, &root->all_outputs, link) {
-                char identifier[128];
+                if (output_match_name_or_id(output, name_or_id)) {
-                output_get_identifier(identifier, sizeof(identifier), output);
-                if (strcasecmp(identifier, name_or_id) == 0
-                                || strcasecmp(output->wlr_output->name, name_or_id) == 0) {
                        return output;
                }
        }
        return NULL;
 }
-struct surface_iterator_data {
-        sway_surface_iterator_func_t user_iterator;
-        void *user_data;
-        struct sway_output *output;
-        struct sway_view *view;
-        double ox, oy;
-        int width, height;
-};
-static bool get_surface_box(struct surface_iterator_data *data,
-                struct wlr_surface *surface, int sx, int sy,
-                struct wlr_box *surface_box) {
-        struct sway_output *output = data->output;
-        if (!wlr_surface_has_buffer(surface)) {
-                return false;
-        }
-        int sw = surface->current.width;
-        int sh = surface->current.height;
-        struct wlr_box box = {
+struct sway_workspace *output_get_active_workspace(struct sway_output *output) {
-                .x = floor(data->ox + sx),
+        struct sway_seat *seat = input_manager_current_seat();
-                .y = floor(data->oy + sy),
+        struct sway_node *focus = seat_get_active_tiling_child(seat, &output->node);
-                .width = sw,
+        if (!focus) {
-                .height = sh,
+                if (!output->workspaces->length) {
-        };
+                        return NULL;
-        if (surface_box != NULL) {
+                }
-                memcpy(surface_box, &box, sizeof(struct wlr_box));
+                return output->workspaces->items[0];
        }
+        return focus->sway_workspace;
-        struct wlr_box output_box = {
-                .width = output->width,
-                .height = output->height,
-        };
-        struct wlr_box intersection;
-        return wlr_box_intersection(&intersection, &output_box, &box);
 }
-static void output_for_each_surface_iterator(struct wlr_surface *surface,
+struct send_frame_done_data {
-                int sx, int sy, void *_data) {
+        struct timespec when;
-        struct surface_iterator_data *data = _data;
+        int msec_until_refresh;
+        struct sway_output *output;
-        struct wlr_box box;
+};
-        bool intersects = get_surface_box(data, surface, sx, sy, &box);
-        if (!intersects) {
-                return;
-        }
-        data->user_iterator(data->output, data->view, surface, &box,
+struct buffer_timer {
-                data->user_data);
+        struct wl_listener destroy;
-}
+        struct wl_event_source *frame_done_timer;
+};
-void output_surface_for_each_surface(struct sway_output *output,
+static int handle_buffer_timer(void *data) {
-                struct wlr_surface *surface, double ox, double oy,
+        struct wlr_scene_buffer *buffer = data;
-                sway_surface_iterator_func_t iterator, void *user_data) {
-        struct surface_iterator_data data = {
-                .user_iterator = iterator,
-                .user_data = user_data,
-                .output = output,
-                .view = NULL,
-                .ox = ox,
-                .oy = oy,
-                .width = surface->current.width,
-                .height = surface->current.height,
-        };
-        wlr_surface_for_each_surface(surface,
-                output_for_each_surface_iterator, &data);
-}
-void output_view_for_each_surface(struct sway_output *output,
+        struct timespec now;
-                struct sway_view *view, sway_surface_iterator_func_t iterator,
+        clock_gettime(CLOCK_MONOTONIC, &now);
-                void *user_data) {
+        wlr_scene_buffer_send_frame_done(buffer, &now);
-        struct surface_iterator_data data = {
+        return 0;
-                .user_iterator = iterator,
-                .user_data = user_data,
-                .output = output,
-                .view = view,
-                .ox = view->container->surface_x - output->lx
-                        - view->geometry.x,
-                .oy = view->container->surface_y - output->ly
-                        - view->geometry.y,
-                .width = view->container->current.content_width,
-                .height = view->container->current.content_height,
-        };
-        view_for_each_surface(view, output_for_each_surface_iterator, &data);
 }
-void output_view_for_each_popup_surface(struct sway_output *output,
+static void handle_buffer_timer_destroy(struct wl_listener *listener,
-                struct sway_view *view, sway_surface_iterator_func_t iterator,
+                void *data) {
-                void *user_data) {
+        struct buffer_timer *timer = wl_container_of(listener, timer, destroy);
-        struct surface_iterator_data data = {
-                .user_iterator = iterator,
-                .user_data = user_data,
-                .output = output,
-                .view = view,
-                .ox = view->container->surface_x - output->lx
-                        - view->geometry.x,
-                .oy = view->container->surface_y - output->ly
-                        - view->geometry.y,
-                .width = view->container->current.content_width,
-                .height = view->container->current.content_height,
-        };
-        view_for_each_popup_surface(view, output_for_each_surface_iterator, &data);
-}
-void output_layer_for_each_surface(struct sway_output *output,
+        wl_list_remove(&timer->destroy.link);
-                struct wl_list *layer_surfaces, sway_surface_iterator_func_t iterator,
+        wl_event_source_remove(timer->frame_done_timer);
-                void *user_data) {
+        free(timer);
-        struct sway_layer_surface *layer_surface;
-        wl_list_for_each(layer_surface, layer_surfaces, link) {
-                struct wlr_layer_surface_v1 *wlr_layer_surface_v1 =
-                        layer_surface->layer_surface;
-                struct wlr_surface *surface = wlr_layer_surface_v1->surface;
-                struct surface_iterator_data data = {
-                        .user_iterator = iterator,
-                        .user_data = user_data,
-                        .output = output,
-                        .view = NULL,
-                        .ox = layer_surface->geo.x,
-                        .oy = layer_surface->geo.y,
-                        .width = surface->current.width,
-                        .height = surface->current.height,
-                };
-                wlr_layer_surface_v1_for_each_surface(wlr_layer_surface_v1,
-                        output_for_each_surface_iterator, &data);
-        }
 }
-void output_layer_for_each_toplevel_surface(struct sway_output *output,
+static struct buffer_timer *buffer_timer_get_or_create(struct wlr_scene_buffer *buffer) {
-                struct wl_list *layer_surfaces, sway_surface_iterator_func_t iterator,
+        struct buffer_timer *timer =
-                void *user_data) {
+                scene_descriptor_try_get(&buffer->node, SWAY_SCENE_DESC_BUFFER_TIMER);
-        struct sway_layer_surface *layer_surface;
+        if (timer) {
-        wl_list_for_each(layer_surface, layer_surfaces, link) {
+                return timer;
-                struct wlr_layer_surface_v1 *wlr_layer_surface_v1 =
-                        layer_surface->layer_surface;
-                output_surface_for_each_surface(output, wlr_layer_surface_v1->surface,
-                        layer_surface->geo.x, layer_surface->geo.y, iterator,
-                        user_data);
        }
-}
+        timer = calloc(1, sizeof(struct buffer_timer));
-void output_layer_for_each_popup_surface(struct sway_output *output,
+        if (!timer) {
-                struct wl_list *layer_surfaces, sway_surface_iterator_func_t iterator,
+                return NULL;
-                void *user_data) {
-        struct sway_layer_surface *layer_surface;
-        wl_list_for_each(layer_surface, layer_surfaces, link) {
-                struct wlr_layer_surface_v1 *wlr_layer_surface_v1 =
-                        layer_surface->layer_surface;
-                struct wlr_surface *surface = wlr_layer_surface_v1->surface;
-                struct surface_iterator_data data = {
-                        .user_iterator = iterator,
-                        .user_data = user_data,
-                        .output = output,
-                        .view = NULL,
-                        .ox = layer_surface->geo.x,
-                        .oy = layer_surface->geo.y,
-                        .width = surface->current.width,
-                        .height = surface->current.height,
-                };
-                wlr_layer_surface_v1_for_each_popup_surface(wlr_layer_surface_v1,
-                        output_for_each_surface_iterator, &data);
        }
-}
-#if HAVE_XWAYLAND
+        timer->frame_done_timer = wl_event_loop_add_timer(server.wl_event_loop,
-void output_unmanaged_for_each_surface(struct sway_output *output,
+                handle_buffer_timer, buffer);
-                struct wl_list *unmanaged, sway_surface_iterator_func_t iterator,
+        if (!timer->frame_done_timer) {
-                void *user_data) {
+                free(timer);
-        struct sway_xwayland_unmanaged *unmanaged_surface;
+                return NULL;
-        wl_list_for_each(unmanaged_surface, unmanaged, link) {
-                struct wlr_xwayland_surface *xsurface =
-                        unmanaged_surface->wlr_xwayland_surface;
-                double ox = unmanaged_surface->lx - output->lx;
-                double oy = unmanaged_surface->ly - output->ly;
-                output_surface_for_each_surface(output, xsurface->surface, ox, oy,
-                        iterator, user_data);
        }
-}
-#endif
-void output_drag_icons_for_each_surface(struct sway_output *output,
+        scene_descriptor_assign(&buffer->node, SWAY_SCENE_DESC_BUFFER_TIMER, timer);
-                struct wl_list *drag_icons, sway_surface_iterator_func_t iterator,
-                void *user_data) {
-        struct sway_drag_icon *drag_icon;
-        wl_list_for_each(drag_icon, drag_icons, link) {
-                double ox = drag_icon->x - output->lx;
-                double oy = drag_icon->y - output->ly;
-                if (drag_icon->wlr_drag_icon->mapped) {
-                        output_surface_for_each_surface(output,
-                                drag_icon->wlr_drag_icon->surface, ox, oy,
-                                iterator, user_data);
-                }
-        }
-}
-static void for_each_surface_container_iterator(struct sway_container *con,
+        timer->destroy.notify = handle_buffer_timer_destroy;
-                void *_data) {
+        wl_signal_add(&buffer->node.events.destroy, &timer->destroy);
-        if (!con->view || !view_is_visible(con->view)) {
-                return;
-        }
-        struct surface_iterator_data *data = _data;
+        return timer;
-        output_view_for_each_surface(data->output, con->view,
-                data->user_iterator, data->user_data);
 }
-static void output_for_each_surface(struct sway_output *output,
+static void send_frame_done_iterator(struct wlr_scene_buffer *buffer,
-                sway_surface_iterator_func_t iterator, void *user_data) {
+                int x, int y, void *user_data) {
-        if (output_has_opaque_overlay_layer_surface(output)) {
+        struct send_frame_done_data *data = user_data;
-                goto overlay;
+        struct sway_output *output = data->output;
-        }
+        int view_max_render_time = 0;
-        struct surface_iterator_data data = {
-                .user_iterator = iterator,
-                .user_data = user_data,
-                .output = output,
-                .view = NULL,
-        };
-        struct sway_workspace *workspace = output_get_active_workspace(output);
+        if (buffer->primary_output != data->output->scene_output) {
-        struct sway_container *fullscreen_con = root->fullscreen_global;
+                return;
-        if (!fullscreen_con) {
-                if (!workspace) {
-                        return;
-                }
-                fullscreen_con = workspace->current.fullscreen;
-        }
-        if (fullscreen_con) {
-                for_each_surface_container_iterator(fullscreen_con, &data);
-                container_for_each_child(fullscreen_con,
-                        for_each_surface_container_iterator, &data);
-                // TODO: Show transient containers for fullscreen global
-                if (fullscreen_con == workspace->current.fullscreen) {
-                        for (int i = 0; i < workspace->current.floating->length; ++i) {
-                                struct sway_container *floater =
-                                        workspace->current.floating->items[i];
-                                if (container_is_transient_for(floater, fullscreen_con)) {
-                                        for_each_surface_container_iterator(floater, &data);
-                                }
-                        }
-                }
-#if HAVE_XWAYLAND
-                output_unmanaged_for_each_surface(output, &root->xwayland_unmanaged,
-                        iterator, user_data);
-#endif
-        } else {
-                output_layer_for_each_surface(output,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
-                        iterator, user_data);
-                output_layer_for_each_surface(output,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
-                        iterator, user_data);
-                workspace_for_each_container(workspace,
-                        for_each_surface_container_iterator, &data);
-#if HAVE_XWAYLAND
-                output_unmanaged_for_each_surface(output, &root->xwayland_unmanaged,
-                        iterator, user_data);
-#endif
-                output_layer_for_each_surface(output,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
-                        iterator, user_data);
        }
-overlay:
+        struct wlr_scene_node *current = &buffer->node;
-        output_layer_for_each_surface(output,
+        while (true) {
-                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
+                struct sway_view *view = scene_descriptor_try_get(current,
-                iterator, user_data);
+                        SWAY_SCENE_DESC_VIEW);
-        output_drag_icons_for_each_surface(output, &root->drag_icons,
+                if (view) {
-                iterator, user_data);
+                        view_max_render_time = view->max_render_time;
-}
+                        break;
-static int scale_length(int length, int offset, float scale) {
-        return round((offset + length) * scale) - round(offset * scale);
-}
-void scale_box(struct wlr_box *box, float scale) {
-        box->width = scale_length(box->width, box->x, scale);
-        box->height = scale_length(box->height, box->y, scale);
-        box->x = round(box->x * scale);
-        box->y = round(box->y * scale);
-}
-struct sway_workspace *output_get_active_workspace(struct sway_output *output) {
-        struct sway_seat *seat = input_manager_current_seat();
-        struct sway_node *focus = seat_get_active_tiling_child(seat, &output->node);
-        if (!focus) {
-                if (!output->workspaces->length) {
-                        return NULL;
                }
-                return output->workspaces->items[0];
-        }
-        return focus->sway_workspace;
-}
-bool output_has_opaque_overlay_layer_surface(struct sway_output *output) {
+                if (!current->parent) {
-        struct sway_layer_surface *sway_layer_surface;
+                        break;
-        wl_list_for_each(sway_layer_surface,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], link) {
-                struct wlr_surface *wlr_surface = sway_layer_surface->layer_surface->surface;
-                pixman_box32_t output_box = {
-                        .x2 = output->width,
-                        .y2 = output->height,
-                };
-                pixman_region32_t surface_opaque_box;
-                pixman_region32_init(&surface_opaque_box);
-                pixman_region32_copy(&surface_opaque_box, &wlr_surface->opaque_region);
-                pixman_region32_translate(&surface_opaque_box,
-                        sway_layer_surface->geo.x, sway_layer_surface->geo.y);
-                pixman_region_overlap_t contains =
-                        pixman_region32_contains_rectangle(&surface_opaque_box, &output_box);
-                pixman_region32_fini(&surface_opaque_box);
-                if (contains == PIXMAN_REGION_IN) {
-                        return true;
                }
-        }
-        return false;
-}
-struct send_frame_done_data {
+                current = &current->parent->node;
-        struct timespec when;
-        int msec_until_refresh;
-};
-static void send_frame_done_iterator(struct sway_output *output,
-                struct sway_view *view, struct wlr_surface *surface,
-                struct wlr_box *box, void *user_data) {
-        int view_max_render_time = 0;
-        if (view != NULL) {
-                view_max_render_time = view->max_render_time;
        }
-        struct send_frame_done_data *data = user_data;
        int delay = data->msec_until_refresh - output->max_render_time
                        - view_max_render_time;
-        if (output->max_render_time == 0 || view_max_render_time == 0 || delay < 1) {
+        struct buffer_timer *timer = NULL;
-                wlr_surface_send_frame_done(surface, &data->when);
-        } else {
-                struct sway_surface *sway_surface = surface->data;
-                wl_event_source_timer_update(sway_surface->frame_done_timer, delay);
-        }
-}
-static void send_frame_done(struct sway_output *output, struct send_frame_done_data *data) {
-        output_for_each_surface(output, send_frame_done_iterator, data);
-}
-static void count_surface_iterator(struct sway_output *output,
-                struct sway_view *view, struct wlr_surface *surface,
-                struct wlr_box *box, void *data) {
-        size_t *n = data;
-        (*n)++;
-}
-static bool scan_out_fullscreen_view(struct sway_output *output,
+        if (output->max_render_time != 0 && view_max_render_time != 0 && delay > 0) {
-                struct sway_view *view) {
+                timer = buffer_timer_get_or_create(buffer);
-        struct wlr_output *wlr_output = output->wlr_output;
-        struct sway_workspace *workspace = output->current.active_workspace;
-        if (!sway_assert(workspace, "Expected an active workspace")) {
-                return false;
        }
-        if (!wl_list_empty(&view->saved_buffers)) {
+        if (timer) {
-                return false;
+                wl_event_source_timer_update(timer->frame_done_timer, delay);
+        } else {
+                wlr_scene_buffer_send_frame_done(buffer, &data->when);
        }
+}
-        for (int i = 0; i < workspace->current.floating->length; ++i) {
+static enum wlr_scale_filter_mode get_scale_filter(struct sway_output *output,
-                struct sway_container *floater =
+                struct wlr_scene_buffer *buffer) {
-                        workspace->current.floating->items[i];
+        // if we are scaling down, we should always choose linear
-                if (container_is_transient_for(floater, view->container)) {
+        if (buffer->dst_width > 0 && buffer->dst_height > 0 && (
-                        return false;
+                        buffer->dst_width < buffer->buffer_width ||
-                }
+                        buffer->dst_height < buffer->buffer_height)) {
+                return WLR_SCALE_FILTER_BILINEAR;
        }
-#if HAVE_XWAYLAND
+        switch (output->scale_filter) {
-        if (!wl_list_empty(&root->xwayland_unmanaged)) {
+        case SCALE_FILTER_LINEAR:
-                return false;
+                return WLR_SCALE_FILTER_BILINEAR;
+        case SCALE_FILTER_NEAREST:
+                return WLR_SCALE_FILTER_NEAREST;
+        default:
+                abort(); // unreachable
        }
-#endif
+}
-        if (!wl_list_empty(&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY])) {
+static void output_configure_scene(struct sway_output *output,
-                return false;
+                struct wlr_scene_node *node, float opacity) {
-        }
+        if (!node->enabled) {
-        if (!wl_list_empty(&root->drag_icons)) {
+                return;
-                return false;
        }
-        struct wlr_surface *surface = view->surface;
+        struct sway_container *con =
-        if (surface == NULL) {
+                scene_descriptor_try_get(node, SWAY_SCENE_DESC_CONTAINER);
-                return false;
+        if (con) {
-        }
+                opacity = con->alpha;
-        size_t n_surfaces = 0;
-        output_view_for_each_surface(output, view,
-                count_surface_iterator, &n_surfaces);
-        if (n_surfaces != 1) {
-                return false;
        }
-        if (surface->buffer == NULL) {
+        if (node->type == WLR_SCENE_NODE_BUFFER) {
-                return false;
+                struct wlr_scene_buffer *buffer = wlr_scene_buffer_from_node(node);
-        }
-        if ((float)surface->current.scale != wlr_output->scale ||
+                // hack: don't call the scene setter because that will damage all outputs
-                        surface->current.transform != wlr_output->transform) {
+                // We don't want to damage outputs that aren't our current output that
-                return false;
+                // we're configuring
-        }
+                buffer->filter_mode = get_scale_filter(output, buffer);
-        wlr_output_attach_buffer(wlr_output, &surface->buffer->base);
+                wlr_scene_buffer_set_opacity(buffer, opacity);
-        if (!wlr_output_test(wlr_output)) {
+        } else if (node->type == WLR_SCENE_NODE_TREE) {
-                return false;
+                struct wlr_scene_tree *tree = wlr_scene_tree_from_node(node);
+                struct wlr_scene_node *node;
+                wl_list_for_each(node, &tree->children, link) {
+                        output_configure_scene(output, node, opacity);
+                }
        }
-        wlr_presentation_surface_sampled_on_output(server.presentation, surface,
-                wlr_output);
-        return wlr_output_commit(wlr_output);
 }
 static int output_repaint_timer_handler(void *data) {
        struct sway_output *output = data;
-        if (output->wlr_output == NULL) {
-                return 0;
-        }
-        output->wlr_output->frame_pending = false;
-        struct sway_workspace *workspace = output->current.active_workspace;
+        if (!output->enabled) {
-        if (workspace == NULL) {
                return 0;
        }
-        struct sway_container *fullscreen_con = root->fullscreen_global;
+        output->wlr_output->frame_pending = false;
-        if (!fullscreen_con) {
-                fullscreen_con = workspace->current.fullscreen;
-        }
-        if (fullscreen_con && fullscreen_con->view) {
+        output_configure_scene(output, &root->root_scene->tree.node, 1.0f);
-                // Try to scan-out the fullscreen view
-                static bool last_scanned_out = false;
-                bool scanned_out =
-                        scan_out_fullscreen_view(output, fullscreen_con->view);
-                if (scanned_out && !last_scanned_out) {
+        if (output->gamma_lut_changed) {
-                        sway_log(SWAY_DEBUG, "Scanning out fullscreen view on %s",
+                struct wlr_output_state pending;
-                                output->wlr_output->name);
+                wlr_output_state_init(&pending);
+                if (!wlr_scene_output_build_state(output->scene_output, &pending, NULL)) {
+                        return 0;
                }
-                if (last_scanned_out && !scanned_out) {
-                        sway_log(SWAY_DEBUG, "Stopping fullscreen view scan out on %s",
+                output->gamma_lut_changed = false;
-                                output->wlr_output->name);
+                struct wlr_gamma_control_v1 *gamma_control =
-                        output_damage_whole(output);
+                        wlr_gamma_control_manager_v1_get_control(
+                        server.gamma_control_manager_v1, output->wlr_output);
+                if (!wlr_gamma_control_v1_apply(gamma_control, &pending)) {
+                        wlr_output_state_finish(&pending);
+                        return 0;
                }
-                last_scanned_out = scanned_out;
-                if (scanned_out) {
+                if (!wlr_output_commit_state(output->wlr_output, &pending)) {
+                        wlr_gamma_control_v1_send_failed_and_destroy(gamma_control);
+                        wlr_output_state_finish(&pending);
                        return 0;
                }
-        }
-        bool needs_frame;
+                wlr_output_state_finish(&pending);
-        pixman_region32_t damage;
-        pixman_region32_init(&damage);
-        if (!wlr_output_damage_attach_render(output->damage,
-                        &needs_frame, &damage)) {
                return 0;
        }
-        if (needs_frame) {
+        wlr_scene_output_commit(output->scene_output, NULL);
-                struct timespec now;
-                clock_gettime(CLOCK_MONOTONIC, &now);
-                output_render(output, &now, &damage);
-        } else {
-                wlr_output_rollback(output->wlr_output);
-        }
-        pixman_region32_fini(&damage);
        return 0;
 }
-static void damage_handle_frame(struct wl_listener *listener, void *user_data) {
+static void handle_frame(struct wl_listener *listener, void *user_data) {
        struct sway_output *output =
-                wl_container_of(listener, output, damage_frame);
+                wl_container_of(listener, output, frame);
        if (!output->enabled || !output->wlr_output->enabled) {
                return;
        }
@@ -562,9 +286,7 @@ static void damage_handle_frame(struct wl_listener *listener, void *user_data) {
        if (output->max_render_time != 0) {
                struct timespec now;
-                clockid_t presentation_clock
+                clock_gettime(CLOCK_MONOTONIC, &now);
-                        = wlr_backend_get_presentation_clock(server.backend);
-                clock_gettime(presentation_clock, &now);
                const long NSEC_IN_SECONDS = 1000000000;
                struct timespec predicted_refresh = output->last_presentation;
@@ -611,118 +333,8 @@ static void damage_handle_frame(struct wl_listener *listener, void *user_data) {
        struct send_frame_done_data data = {0};
        clock_gettime(CLOCK_MONOTONIC, &data.when);
        data.msec_until_refresh = msec_until_refresh;
-        send_frame_done(output, &data);
+        data.output = output;
-}
+        wlr_scene_output_for_each_buffer(output->scene_output, send_frame_done_iterator, &data);
-void output_damage_whole(struct sway_output *output) {
-        // The output can exist with no wlr_output if it's just been disconnected
-        // and the transaction to evacuate it has't completed yet.
-        if (output && output->wlr_output && output->damage) {
-                wlr_output_damage_add_whole(output->damage);
-        }
-}
-static void damage_surface_iterator(struct sway_output *output,
-                struct sway_view *view, struct wlr_surface *surface,
-                struct wlr_box *_box, void *_data) {
-        bool *data = _data;
-        bool whole = *data;
-        struct wlr_box box = *_box;
-        scale_box(&box, output->wlr_output->scale);
-        if (pixman_region32_not_empty(&surface->buffer_damage)) {
-                pixman_region32_t damage;
-                pixman_region32_init(&damage);
-                wlr_surface_get_effective_damage(surface, &damage);
-                wlr_region_scale(&damage, &damage, output->wlr_output->scale);
-                if (ceil(output->wlr_output->scale) > surface->current.scale) {
-                        // When scaling up a surface, it'll become blurry so we need to
-                        // expand the damage region
-                        wlr_region_expand(&damage, &damage,
-                                ceil(output->wlr_output->scale) - surface->current.scale);
-                }
-                pixman_region32_translate(&damage, box.x, box.y);
-                wlr_output_damage_add(output->damage, &damage);
-                pixman_region32_fini(&damage);
-        }
-        if (whole) {
-                wlr_output_damage_add_box(output->damage, &box);
-        }
-        if (!wl_list_empty(&surface->current.frame_callback_list)) {
-                wlr_output_schedule_frame(output->wlr_output);
-        }
-}
-void output_damage_surface(struct sway_output *output, double ox, double oy,
-                struct wlr_surface *surface, bool whole) {
-        output_surface_for_each_surface(output, surface, ox, oy,
-                damage_surface_iterator, &whole);
-}
-void output_damage_from_view(struct sway_output *output,
-                struct sway_view *view) {
-        if (!view_is_visible(view)) {
-                return;
-        }
-        bool whole = false;
-        output_view_for_each_surface(output, view, damage_surface_iterator, &whole);
-}
-// Expecting an unscaled box in layout coordinates
-void output_damage_box(struct sway_output *output, struct wlr_box *_box) {
-        struct wlr_box box;
-        memcpy(&box, _box, sizeof(struct wlr_box));
-        box.x -= output->lx;
-        box.y -= output->ly;
-        scale_box(&box, output->wlr_output->scale);
-        wlr_output_damage_add_box(output->damage, &box);
-}
-static void damage_child_views_iterator(struct sway_container *con,
-                void *data) {
-        if (!con->view || !view_is_visible(con->view)) {
-                return;
-        }
-        struct sway_output *output = data;
-        bool whole = true;
-        output_view_for_each_surface(output, con->view, damage_surface_iterator,
-                        &whole);
-}
-void output_damage_whole_container(struct sway_output *output,
-                struct sway_container *con) {
-        // Pad the box by 1px, because the width is a double and might be a fraction
-        struct wlr_box box = {
-                .x = con->current.x - output->lx - 1,
-                .y = con->current.y - output->ly - 1,
-                .width = con->current.width + 2,
-                .height = con->current.height + 2,
-        };
-        scale_box(&box, output->wlr_output->scale);
-        wlr_output_damage_add_box(output->damage, &box);
-        // Damage subsurfaces as well, which may extend outside the box
-        if (con->view) {
-                damage_child_views_iterator(con, output);
-        } else {
-                container_for_each_child(con, damage_child_views_iterator, output);
-        }
-}
-static void damage_handle_destroy(struct wl_listener *listener, void *data) {
-        struct sway_output *output =
-                wl_container_of(listener, output, damage_destroy);
-        if (!output->enabled) {
-                return;
-        }
-        output_disable(output);
-        wl_list_remove(&output->damage_destroy.link);
-        wl_list_remove(&output->damage_frame.link);
-        transaction_commit_dirty();
 }
 static void update_output_manager_config(struct sway_server *server) {
@@ -731,73 +343,61 @@ static void update_output_manager_config(struct sway_server *server) {
        struct sway_output *output;
        wl_list_for_each(output, &root->all_outputs, link) {
-                if (output == root->noop_output) {
+                if (output == root->fallback_output) {
                        continue;
                }
                struct wlr_output_configuration_head_v1 *config_head =
                        wlr_output_configuration_head_v1_create(config, output->wlr_output);
-                struct wlr_box *output_box = wlr_output_layout_get_box(
+                struct wlr_box output_box;
-                        root->output_layout, output->wlr_output);
+                wlr_output_layout_get_box(root->output_layout,
-                // We mark the output enabled even if it is switched off by DPMS
+                        output->wlr_output, &output_box);
-                config_head->state.enabled = output->current_mode != NULL && output->enabled;
+                // We mark the output enabled when it's switched off but not disabled
-                config_head->state.mode = output->current_mode;
+                config_head->state.enabled = !wlr_box_empty(&output_box);
-                if (output_box) {
+                config_head->state.x = output_box.x;
-                        config_head->state.x = output_box->x;
+                config_head->state.y = output_box.y;
-                        config_head->state.y = output_box->y;
-                }
        }
        wlr_output_manager_v1_set_configuration(server->output_manager_v1, config);
+        ipc_event_output();
 }
-static void handle_destroy(struct wl_listener *listener, void *data) {
+static void begin_destroy(struct sway_output *output) {
-        struct sway_output *output = wl_container_of(listener, output, destroy);
        struct sway_server *server = output->server;
-        wl_signal_emit(&output->events.destroy, output);
        if (output->enabled) {
                output_disable(output);
        }
        output_begin_destroy(output);
+        wl_list_remove(&output->link);
+        wl_list_remove(&output->layout_destroy.link);
        wl_list_remove(&output->destroy.link);
        wl_list_remove(&output->commit.link);
-        wl_list_remove(&output->mode.link);
        wl_list_remove(&output->present.link);
+        wl_list_remove(&output->frame.link);
+        wl_list_remove(&output->request_state.link);
+        wlr_scene_output_destroy(output->scene_output);
+        output->scene_output = NULL;
+        output->wlr_output->data = NULL;
+        output->wlr_output = NULL;
        transaction_commit_dirty();
        update_output_manager_config(server);
 }
-static void handle_mode(struct wl_listener *listener, void *data) {
+static void handle_destroy(struct wl_listener *listener, void *data) {
-        struct sway_output *output = wl_container_of(listener, output, mode);
+        struct sway_output *output = wl_container_of(listener, output, destroy);
-        if (!output->enabled && !output->enabling) {
+        begin_destroy(output);
-                struct output_config *oc = find_output_config(output);
-                if (output->wlr_output->current_mode != NULL &&
-                                (!oc || oc->enabled)) {
-                        // We want to enable this output, but it didn't work last time,
-                        // possibly because we hadn't enough CRTCs. Try again now that the
-                        // output has a mode.
-                        sway_log(SWAY_DEBUG, "Output %s has gained a CRTC, "
-                                "trying to enable it", output->wlr_output->name);
-                        apply_output_config(oc, output);
-                }
-                return;
-        }
-        if (!output->enabled) {
-                return;
-        }
-        arrange_layers(output);
-        arrange_output(output);
-        transaction_commit_dirty();
-        update_output_manager_config(output->server);
 }
-static void update_textures(struct sway_container *con, void *data) {
+static void handle_layout_destroy(struct wl_listener *listener, void *data) {
-        container_update_title_textures(con);
+        struct sway_output *output = wl_container_of(listener, output, layout_destroy);
-        container_update_marks_textures(con);
+        begin_destroy(output);
 }
 static void handle_commit(struct wl_listener *listener, void *data) {
@@ -808,24 +408,28 @@ static void handle_commit(struct wl_listener *listener, void *data) {
                return;
        }
-        if (event->committed & WLR_OUTPUT_STATE_SCALE) {
+        if (event->state->committed & (
-                output_for_each_container(output, update_textures, NULL);
+                        WLR_OUTPUT_STATE_MODE |
-        }
+                        WLR_OUTPUT_STATE_TRANSFORM |
+                        WLR_OUTPUT_STATE_SCALE)) {
-        if (event->committed & (WLR_OUTPUT_STATE_TRANSFORM | WLR_OUTPUT_STATE_SCALE)) {
                arrange_layers(output);
                arrange_output(output);
                transaction_commit_dirty();
                update_output_manager_config(output->server);
        }
+        // Next time the output is enabled, try to re-apply the gamma LUT
+        if ((event->state->committed & WLR_OUTPUT_STATE_ENABLED) && !output->wlr_output->enabled) {
+                output->gamma_lut_changed = true;
+        }
 }
 static void handle_present(struct wl_listener *listener, void *data) {
        struct sway_output *output = wl_container_of(listener, output, present);
        struct wlr_output_event_present *output_event = data;
-        if (!output->enabled) {
+        if (!output->enabled || !output_event->presented) {
                return;
        }
@@ -833,37 +437,91 @@ static void handle_present(struct wl_listener *listener, void *data) {
        output->refresh_nsec = output_event->refresh;
 }
+static void handle_request_state(struct wl_listener *listener, void *data) {
+        struct sway_output *output =
+                wl_container_of(listener, output, request_state);
+        const struct wlr_output_event_request_state *event = data;
+        wlr_output_commit_state(output->wlr_output, event->state);
+}
+static unsigned int last_headless_num = 0;
 void handle_new_output(struct wl_listener *listener, void *data) {
        struct sway_server *server = wl_container_of(listener, server, new_output);
        struct wlr_output *wlr_output = data;
-        sway_log(SWAY_DEBUG, "New output %p: %s", wlr_output, wlr_output->name);
+        if (wlr_output == root->fallback_output->wlr_output) {
+                return;
+        }
+        if (wlr_output_is_headless(wlr_output)) {
+                char name[64];
+                snprintf(name, sizeof(name), "HEADLESS-%u", ++last_headless_num);
+                wlr_output_set_name(wlr_output, name);
+        }
+        sway_log(SWAY_DEBUG, "New output %p: %s (non-desktop: %d)",
+                        wlr_output, wlr_output->name, wlr_output->non_desktop);
+        if (wlr_output->non_desktop) {
+                sway_log(SWAY_DEBUG, "Not configuring non-desktop output");
+                struct sway_output_non_desktop *non_desktop = output_non_desktop_create(wlr_output);
+#if WLR_HAS_DRM_BACKEND
+                if (server->drm_lease_manager) {
+                        wlr_drm_lease_v1_manager_offer_output(server->drm_lease_manager,
+                                        wlr_output);
+                }
+#endif
+                list_add(root->non_desktop_outputs, non_desktop);
+                return;
+        }
+        if (!wlr_output_init_render(wlr_output, server->allocator,
+                        server->renderer)) {
+                sway_log(SWAY_ERROR, "Failed to init output render");
+                return;
+        }
+        // Create the scene output here so we're not accidentally creating one for
+        // the fallback output
+        struct wlr_scene_output *scene_output =
+                wlr_scene_output_create(root->root_scene, wlr_output);
+        if (!scene_output) {
+                sway_log(SWAY_ERROR, "Failed to create a scene output");
+                return;
+        }
        struct sway_output *output = output_create(wlr_output);
        if (!output) {
+                sway_log(SWAY_ERROR, "Failed to create a sway output");
+                wlr_scene_output_destroy(scene_output);
                return;
        }
        output->server = server;
-        output->damage = wlr_output_damage_create(wlr_output);
+        output->scene_output = scene_output;
+        wl_signal_add(&root->output_layout->events.destroy, &output->layout_destroy);
+        output->layout_destroy.notify = handle_layout_destroy;
        wl_signal_add(&wlr_output->events.destroy, &output->destroy);
        output->destroy.notify = handle_destroy;
        wl_signal_add(&wlr_output->events.commit, &output->commit);
        output->commit.notify = handle_commit;
-        wl_signal_add(&wlr_output->events.mode, &output->mode);
-        output->mode.notify = handle_mode;
        wl_signal_add(&wlr_output->events.present, &output->present);
        output->present.notify = handle_present;
-        wl_signal_add(&output->damage->events.frame, &output->damage_frame);
+        wl_signal_add(&wlr_output->events.frame, &output->frame);
-        output->damage_frame.notify = damage_handle_frame;
+        output->frame.notify = handle_frame;
-        wl_signal_add(&output->damage->events.destroy, &output->damage_destroy);
+        wl_signal_add(&wlr_output->events.request_state, &output->request_state);
-        output->damage_destroy.notify = damage_handle_destroy;
+        output->request_state.notify = handle_request_state;
        output->repaint_timer = wl_event_loop_add_timer(server->wl_event_loop,
                output_repaint_timer_handler, output);
-        struct output_config *oc = find_output_config(output);
+        if (server->session_lock.lock) {
-        apply_output_config(oc, output);
+                sway_session_lock_add_output(server->session_lock.lock, output);
-        free_output_config(oc);
+        }
+        apply_all_output_configs();
        transaction_commit_dirty();
@@ -877,62 +535,104 @@ void handle_output_layout_change(struct wl_listener *listener,
        update_output_manager_config(server);
 }
+void handle_gamma_control_set_gamma(struct wl_listener *listener, void *data) {
+        struct sway_server *server =
+                wl_container_of(listener, server, gamma_control_set_gamma);
+        const struct wlr_gamma_control_manager_v1_set_gamma_event *event = data;
+        struct sway_output *output = event->output->data;
+        if(!output) {
+                return;
+        }
+        output->gamma_lut_changed = true;
+        wlr_output_schedule_frame(output->wlr_output);
+}
+static struct output_config *output_config_for_config_head(
+                struct wlr_output_configuration_head_v1 *config_head,
+                struct sway_output *output) {
+        struct output_config *oc = new_output_config(output->wlr_output->name);
+        oc->enabled = config_head->state.enabled;
+        if (!oc->enabled) {
+                return oc;
+        }
+        if (config_head->state.mode != NULL) {
+                struct wlr_output_mode *mode = config_head->state.mode;
+                oc->width = mode->width;
+                oc->height = mode->height;
+                oc->refresh_rate = mode->refresh / 1000.f;
+        } else {
+                oc->width = config_head->state.custom_mode.width;
+                oc->height = config_head->state.custom_mode.height;
+                oc->refresh_rate =
+                        config_head->state.custom_mode.refresh / 1000.f;
+        }
+        oc->x = config_head->state.x;
+        oc->y = config_head->state.y;
+        oc->transform = config_head->state.transform;
+        oc->scale = config_head->state.scale;
+        oc->adaptive_sync = config_head->state.adaptive_sync_enabled;
+        return oc;
+}
 static void output_manager_apply(struct sway_server *server,
                struct wlr_output_configuration_v1 *config, bool test_only) {
-        // TODO: perform atomic tests on the whole backend atomically
+        size_t configs_len = wl_list_length(&root->all_outputs);
+        struct matched_output_config *configs = calloc(configs_len, sizeof(*configs));
-        struct wlr_output_configuration_head_v1 *config_head;
+        if (!configs) {
-        // First disable outputs we need to disable
+                return;
-        bool ok = true;
+        }
-        wl_list_for_each(config_head, &config->heads, link) {
-                struct wlr_output *wlr_output = config_head->state.output;
+        int config_idx = 0;
-                struct sway_output *output = wlr_output->data;
+        struct sway_output *sway_output;
-                if (!output->enabled || config_head->state.enabled) {
+        wl_list_for_each(sway_output, &root->all_outputs, link) {
+                if (sway_output == root->fallback_output) {
+                        configs_len--;
                        continue;
                }
-                struct output_config *oc = new_output_config(output->wlr_output->name);
-                oc->enabled = false;
-                if (test_only) {
+                struct matched_output_config *cfg = &configs[config_idx++];
-                        ok &= test_output_config(oc, output);
+                cfg->output = sway_output;
-                } else {
-                        oc = store_output_config(oc);
-                        ok &= apply_output_config(oc, output);
-                }
-        }
-        // Then enable outputs that need to
+                struct wlr_output_configuration_head_v1 *config_head;
-        wl_list_for_each(config_head, &config->heads, link) {
+                wl_list_for_each(config_head, &config->heads, link) {
-                struct wlr_output *wlr_output = config_head->state.output;
+                        if (config_head->state.output == sway_output->wlr_output) {
-                struct sway_output *output = wlr_output->data;
+                                cfg->config = output_config_for_config_head(config_head, sway_output);
-                if (!config_head->state.enabled) {
+                                break;
-                        continue;
+                        }
                }
-                struct output_config *oc = new_output_config(output->wlr_output->name);
+                if (!cfg->config) {
-                oc->enabled = true;
+                        cfg->config = find_output_config(sway_output);
-                if (config_head->state.mode != NULL) {
-                        struct wlr_output_mode *mode = config_head->state.mode;
-                        oc->width = mode->width;
-                        oc->height = mode->height;
-                        oc->refresh_rate = mode->refresh / 1000.f;
-                } else {
-                        oc->width = config_head->state.custom_mode.width;
-                        oc->height = config_head->state.custom_mode.height;
-                        oc->refresh_rate =
-                                config_head->state.custom_mode.refresh / 1000.f;
                }
-                oc->x = config_head->state.x;
+        }
-                oc->y = config_head->state.y;
-                oc->transform = config_head->state.transform;
-                oc->scale = config_head->state.scale;
-                if (test_only) {
+        sort_output_configs_by_priority(configs, configs_len);
-                        ok &= test_output_config(oc, output);
+        bool ok = apply_output_configs(configs, configs_len, test_only, false);
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+                // Only store new configs for successful non-test commits. Old configs,
+                // test-only and failed commits just get freed.
+                bool store_config = false;
+                if (!test_only && ok) {
+                        struct wlr_output_configuration_head_v1 *config_head;
+                        wl_list_for_each(config_head, &config->heads, link) {
+                                if (config_head->state.output == cfg->output->wlr_output) {
+                                        store_config = true;
+                                        break;
+                                }
+                        }
+                }
+                if (store_config) {
+                        store_output_config(cfg->config);
                } else {
-                        oc = store_output_config(oc);
+                        free_output_config(cfg->config);
-                        ok &= apply_output_config(oc, output);
                }
        }
+        free(configs);
        if (ok) {
                wlr_output_configuration_v1_send_succeeded(config);
@@ -970,12 +670,12 @@ void handle_output_power_manager_set_mode(struct wl_listener *listener,
        struct output_config *oc = new_output_config(output->wlr_output->name);
        switch (event->mode) {
        case ZWLR_OUTPUT_POWER_V1_MODE_OFF:
-                oc->dpms_state = DPMS_OFF;
+                oc->power = 0;
                break;
        case ZWLR_OUTPUT_POWER_V1_MODE_ON:
-                oc->dpms_state = DPMS_ON;
+                oc->power = 1;
                break;
        }
-        oc = store_output_config(oc);
+        store_output_config(oc);
-        apply_output_config(oc, output);
+        apply_all_output_configs();
 }
diff --git a/sway/desktop/render.c b/sway/desktop/render.c
deleted file mode 100644
index a5bd8a5f..00000000
--- a/sway/desktop/render.c
+++ /dev/null
@@ -1,1160 +0,0 @@
-#define _POSIX_C_SOURCE 200809L
-#include <assert.h>
-#include <GLES2/gl2.h>
-#include <stdlib.h>
-#include <strings.h>
-#include <time.h>
-#include <wayland-server-core.h>
-#include <wlr/render/gles2.h>
-#include <wlr/render/wlr_renderer.h>
-#include <wlr/types/wlr_buffer.h>
-#include <wlr/types/wlr_matrix.h>
-#include <wlr/types/wlr_output_damage.h>
-#include <wlr/types/wlr_output_layout.h>
-#include <wlr/types/wlr_output.h>
-#include <wlr/types/wlr_surface.h>
-#include <wlr/util/region.h>
-#include "log.h"
-#include "config.h"
-#include "sway/config.h"
-#include "sway/input/input-manager.h"
-#include "sway/input/seat.h"
-#include "sway/layers.h"
-#include "sway/output.h"
-#include "sway/server.h"
-#include "sway/tree/arrange.h"
-#include "sway/tree/container.h"
-#include "sway/tree/root.h"
-#include "sway/tree/view.h"
-#include "sway/tree/workspace.h"
-struct render_data {
-        pixman_region32_t *damage;
-        float alpha;
-        struct wlr_box *clip_box;
-};
-/**
- * Apply scale to a width or height.
- *
- * One does not simply multiply the width by the scale. We allow fractional
- * scaling, which means the resulting scaled width might be a decimal.
- * So we round it.
- *
- * But even this can produce undesirable results depending on the X or Y offset
- * of the box. For example, with a scale of 1.5, a box with width=1 should not
- * scale to 2px if its X coordinate is 1, because the X coordinate would have
- * scaled to 2px.
- */
-static int scale_length(int length, int offset, float scale) {
-        return round((offset + length) * scale) - round(offset * scale);
-}
-static void scissor_output(struct wlr_output *wlr_output,
-                pixman_box32_t *rect) {
-        struct wlr_renderer *renderer = wlr_backend_get_renderer(wlr_output->backend);
-        assert(renderer);
-        struct wlr_box box = {
-                .x = rect->x1,
-                .y = rect->y1,
-                .width = rect->x2 - rect->x1,
-                .height = rect->y2 - rect->y1,
-        };
-        int ow, oh;
-        wlr_output_transformed_resolution(wlr_output, &ow, &oh);
-        enum wl_output_transform transform =
-                wlr_output_transform_invert(wlr_output->transform);
-        wlr_box_transform(&box, &box, transform, ow, oh);
-        wlr_renderer_scissor(renderer, &box);
-}
-static void set_scale_filter(struct wlr_output *wlr_output,
-                struct wlr_texture *texture, enum scale_filter_mode scale_filter) {
-        if (!wlr_texture_is_gles2(texture)) {
-                return;
-        }
-        struct wlr_gles2_texture_attribs attribs;
-        wlr_gles2_texture_get_attribs(texture, &attribs);
-        glBindTexture(attribs.target, attribs.tex);
-        switch (scale_filter) {
-        case SCALE_FILTER_LINEAR:
-                glTexParameteri(attribs.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-                break;
-        case SCALE_FILTER_NEAREST:
-                glTexParameteri(attribs.target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-                break;
-        case SCALE_FILTER_DEFAULT:
-        case SCALE_FILTER_SMART:
-                assert(false); // unreachable
-        }
-}
-static void render_texture(struct wlr_output *wlr_output,
-                pixman_region32_t *output_damage, struct wlr_texture *texture,
-                const struct wlr_fbox *src_box, const struct wlr_box *dst_box,
-                const float matrix[static 9], float alpha) {
-        struct wlr_renderer *renderer =
-                wlr_backend_get_renderer(wlr_output->backend);
-        struct sway_output *output = wlr_output->data;
-        pixman_region32_t damage;
-        pixman_region32_init(&damage);
-        pixman_region32_union_rect(&damage, &damage, dst_box->x, dst_box->y,
-                dst_box->width, dst_box->height);
-        pixman_region32_intersect(&damage, &damage, output_damage);
-        bool damaged = pixman_region32_not_empty(&damage);
-        if (!damaged) {
-                goto damage_finish;
-        }
-        int nrects;
-        pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects);
-        for (int i = 0; i < nrects; ++i) {
-                scissor_output(wlr_output, &rects[i]);
-                set_scale_filter(wlr_output, texture, output->scale_filter);
-                if (src_box != NULL) {
-                        wlr_render_subtexture_with_matrix(renderer, texture, src_box, matrix, alpha);
-                } else {
-                        wlr_render_texture_with_matrix(renderer, texture, matrix, alpha);
-                }
-        }
-damage_finish:
-        pixman_region32_fini(&damage);
-}
-static void render_surface_iterator(struct sway_output *output,
-                struct sway_view *view, struct wlr_surface *surface,
-                struct wlr_box *_box, void *_data) {
-        struct render_data *data = _data;
-        struct wlr_output *wlr_output = output->wlr_output;
-        pixman_region32_t *output_damage = data->damage;
-        float alpha = data->alpha;
-        struct wlr_texture *texture = wlr_surface_get_texture(surface);
-        if (!texture) {
-                return;
-        }
-        struct wlr_fbox src_box;
-        wlr_surface_get_buffer_source_box(surface, &src_box);
-        struct wlr_box proj_box = *_box;
-        scale_box(&proj_box, wlr_output->scale);
-        float matrix[9];
-        enum wl_output_transform transform =
-                wlr_output_transform_invert(surface->current.transform);
-        wlr_matrix_project_box(matrix, &proj_box, transform, 0.0,
-                wlr_output->transform_matrix);
-        struct wlr_box dst_box = *_box;
-        struct wlr_box *clip_box = data->clip_box;
-        if (clip_box != NULL) {
-                dst_box.width = fmin(dst_box.width, clip_box->width);
-                dst_box.height = fmin(dst_box.height, clip_box->height);
-        }
-        scale_box(&dst_box, wlr_output->scale);
-        render_texture(wlr_output, output_damage, texture,
-                &src_box, &dst_box, matrix, alpha);
-        wlr_presentation_surface_sampled_on_output(server.presentation, surface,
-                wlr_output);
-}
-static void render_layer_toplevel(struct sway_output *output,
-                pixman_region32_t *damage, struct wl_list *layer_surfaces) {
-        struct render_data data = {
-                .damage = damage,
-                .alpha = 1.0f,
-        };
-        output_layer_for_each_toplevel_surface(output, layer_surfaces,
-                render_surface_iterator, &data);
-}
-static void render_layer_popups(struct sway_output *output,
-                pixman_region32_t *damage, struct wl_list *layer_surfaces) {
-        struct render_data data = {
-                .damage = damage,
-                .alpha = 1.0f,
-        };
-        output_layer_for_each_popup_surface(output, layer_surfaces,
-                render_surface_iterator, &data);
-}
-#if HAVE_XWAYLAND
-static void render_unmanaged(struct sway_output *output,
-                pixman_region32_t *damage, struct wl_list *unmanaged) {
-        struct render_data data = {
-                .damage = damage,
-                .alpha = 1.0f,
-        };
-        output_unmanaged_for_each_surface(output, unmanaged,
-                render_surface_iterator, &data);
-}
-#endif
-static void render_drag_icons(struct sway_output *output,
-                pixman_region32_t *damage, struct wl_list *drag_icons) {
-        struct render_data data = {
-                .damage = damage,
-                .alpha = 1.0f,
-        };
-        output_drag_icons_for_each_surface(output, drag_icons,
-                render_surface_iterator, &data);
-}
-// _box.x and .y are expected to be layout-local
-// _box.width and .height are expected to be output-buffer-local
-void render_rect(struct sway_output *output,
-                pixman_region32_t *output_damage, const struct wlr_box *_box,
-                float color[static 4]) {
-        struct wlr_output *wlr_output = output->wlr_output;
-        struct wlr_renderer *renderer =
-                wlr_backend_get_renderer(wlr_output->backend);
-        struct wlr_box box;
-        memcpy(&box, _box, sizeof(struct wlr_box));
-        box.x -= output->lx * wlr_output->scale;
-        box.y -= output->ly * wlr_output->scale;
-        pixman_region32_t damage;
-        pixman_region32_init(&damage);
-        pixman_region32_union_rect(&damage, &damage, box.x, box.y,
-                box.width, box.height);
-        pixman_region32_intersect(&damage, &damage, output_damage);
-        bool damaged = pixman_region32_not_empty(&damage);
-        if (!damaged) {
-                goto damage_finish;
-        }
-        int nrects;
-        pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects);
-        for (int i = 0; i < nrects; ++i) {
-                scissor_output(wlr_output, &rects[i]);
-                wlr_render_rect(renderer, &box, color,
-                        wlr_output->transform_matrix);
-        }
-damage_finish:
-        pixman_region32_fini(&damage);
-}
-void premultiply_alpha(float color[4], float opacity) {
-        color[3] *= opacity;
-        color[0] *= color[3];
-        color[1] *= color[3];
-        color[2] *= color[3];
-}
-static void render_view_toplevels(struct sway_view *view,
-                struct sway_output *output, pixman_region32_t *damage, float alpha) {
-        struct render_data data = {
-                .damage = damage,
-                .alpha = alpha,
-        };
-        struct wlr_box clip_box;
-        if (!container_is_current_floating(view->container)) {
-                // As we pass the geometry offsets to the surface iterator, we will
-                // need to account for the offsets in the clip dimensions.
-                clip_box.width = view->container->current.content_width + view->geometry.x;
-                clip_box.height = view->container->current.content_height + view->geometry.y;
-                data.clip_box = &clip_box;
-        }
-        // Render all toplevels without descending into popups
-        double ox = view->container->surface_x -
-                output->lx - view->geometry.x;
-        double oy = view->container->surface_y -
-                output->ly - view->geometry.y;
-        output_surface_for_each_surface(output, view->surface, ox, oy,
-                        render_surface_iterator, &data);
-}
-static void render_view_popups(struct sway_view *view,
-                struct sway_output *output, pixman_region32_t *damage, float alpha) {
-        struct render_data data = {
-                .damage = damage,
-                .alpha = alpha,
-        };
-        output_view_for_each_popup_surface(output, view,
-                render_surface_iterator, &data);
-}
-static void render_saved_view(struct sway_view *view,
-                struct sway_output *output, pixman_region32_t *damage, float alpha) {
-        struct wlr_output *wlr_output = output->wlr_output;
-        if (wl_list_empty(&view->saved_buffers)) {
-                return;
-        }
-        bool floating = container_is_current_floating(view->container);
-        struct sway_saved_buffer *saved_buf;
-        wl_list_for_each(saved_buf, &view->saved_buffers, link) {
-                if (!saved_buf->buffer->texture) {
-                        continue;
-                }
-                struct wlr_box proj_box = {
-                        .x = saved_buf->x - view->saved_geometry.x - output->lx,
-                        .y = saved_buf->y - view->saved_geometry.y - output->ly,
-                        .width = saved_buf->width,
-                        .height = saved_buf->height,
-                };
-                struct wlr_box output_box = {
-                        .width = output->width,
-                        .height = output->height,
-                };
-                struct wlr_box intersection;
-                bool intersects = wlr_box_intersection(&intersection, &output_box, &proj_box);
-                if (!intersects) {
-                        continue;
-                }
-                struct wlr_box dst_box = proj_box;
-                scale_box(&proj_box, wlr_output->scale);
-                float matrix[9];
-                enum wl_output_transform transform = wlr_output_transform_invert(saved_buf->transform);
-                wlr_matrix_project_box(matrix, &proj_box, transform, 0,
-                        wlr_output->transform_matrix);
-                if (!floating) {
-                        dst_box.width = fmin(dst_box.width,
-                                        view->container->current.content_width -
-                                        (saved_buf->x - view->container->current.content_x) + view->saved_geometry.x);
-                        dst_box.height = fmin(dst_box.height,
-                                        view->container->current.content_height -
-                                        (saved_buf->y - view->container->current.content_y) + view->saved_geometry.y);
-                }
-                scale_box(&dst_box, wlr_output->scale);
-                render_texture(wlr_output, damage, saved_buf->buffer->texture,
-                        &saved_buf->source_box, &dst_box, matrix, alpha);
-        }
-        // FIXME: we should set the surface that this saved buffer originates from
-        // as sampled here.
-        // https://github.com/swaywm/sway/pull/4465#discussion_r321082059
-}
-/**
- * Render a view's surface and left/bottom/right borders.
- */
-static void render_view(struct sway_output *output, pixman_region32_t *damage,
-                struct sway_container *con, struct border_colors *colors) {
-        struct sway_view *view = con->view;
-        if (!wl_list_empty(&view->saved_buffers)) {
-                render_saved_view(view, output, damage, view->container->alpha);
-        } else if (view->surface) {
-                render_view_toplevels(view, output, damage, view->container->alpha);
-        }
-        if (con->current.border == B_NONE || con->current.border == B_CSD) {
-                return;
-        }
-        struct wlr_box box;
-        float output_scale = output->wlr_output->scale;
-        float color[4];
-        struct sway_container_state *state = &con->current;
-        if (state->border_left) {
-                memcpy(&color, colors->child_border, sizeof(float) * 4);
-                premultiply_alpha(color, con->alpha);
-                box.x = floor(state->x);
-                box.y = floor(state->content_y);
-                box.width = state->border_thickness;
-                box.height = state->content_height;
-                scale_box(&box, output_scale);
-                render_rect(output, damage, &box, color);
-        }
-        list_t *siblings = container_get_current_siblings(con);
-        enum sway_container_layout layout =
-                container_current_parent_layout(con);
-        if (state->border_right) {
-                if (!container_is_current_floating(con) && siblings->length == 1 && layout == L_HORIZ) {
-                        memcpy(&color, colors->indicator, sizeof(float) * 4);
-                } else {
-                        memcpy(&color, colors->child_border, sizeof(float) * 4);
-                }
-                premultiply_alpha(color, con->alpha);
-                box.x = floor(state->content_x + state->content_width);
-                box.y = floor(state->content_y);
-                box.width = state->border_thickness;
-                box.height = state->content_height;
-                scale_box(&box, output_scale);
-                render_rect(output, damage, &box, color);
-        }
-        if (state->border_bottom) {
-                if (!container_is_current_floating(con) && siblings->length == 1 && layout == L_VERT) {
-                        memcpy(&color, colors->indicator, sizeof(float) * 4);
-                } else {
-                        memcpy(&color, colors->child_border, sizeof(float) * 4);
-                }
-                premultiply_alpha(color, con->alpha);
-                box.x = floor(state->x);
-                box.y = floor(state->content_y + state->content_height);
-                box.width = state->width;
-                box.height = state->border_thickness;
-                scale_box(&box, output_scale);
-                render_rect(output, damage, &box, color);
-        }
-}
-/**
- * Render a titlebar.
- *
- * Care must be taken not to render over the same pixel multiple times,
- * otherwise the colors will be incorrect when using opacity.
- *
- * The height is: 1px border, 3px padding, font height, 3px padding, 1px border
- * The left side is: 1px border, 2px padding, title
- */
-static void render_titlebar(struct sway_output *output,
-                pixman_region32_t *output_damage, struct sway_container *con,
-                int x, int y, int width,
-                struct border_colors *colors, struct wlr_texture *title_texture,
-                struct wlr_texture *marks_texture) {
-        struct wlr_box box;
-        float color[4];
-        float output_scale = output->wlr_output->scale;
-        double output_x = output->lx;
-        double output_y = output->ly;
-        int titlebar_border_thickness = config->titlebar_border_thickness;
-        int titlebar_h_padding = config->titlebar_h_padding;
-        int titlebar_v_padding = config->titlebar_v_padding;
-        enum alignment title_align = config->title_align;
-        // Single pixel bar above title
-        memcpy(&color, colors->border, sizeof(float) * 4);
-        premultiply_alpha(color, con->alpha);
-        box.x = x;
-        box.y = y;
-        box.width = width;
-        box.height = titlebar_border_thickness;
-        scale_box(&box, output_scale);
-        render_rect(output, output_damage, &box, color);
-        // Single pixel bar below title
-        box.x = x;
-        box.y = y + container_titlebar_height() - titlebar_border_thickness;
-        box.width = width;
-        box.height = titlebar_border_thickness;
-        scale_box(&box, output_scale);
-        render_rect(output, output_damage, &box, color);
-        // Single pixel left edge
-        box.x = x;
-        box.y = y + titlebar_border_thickness;
-        box.width = titlebar_border_thickness;
-        box.height = container_titlebar_height() - titlebar_border_thickness * 2;
-        scale_box(&box, output_scale);
-        render_rect(output, output_damage, &box, color);
-        // Single pixel right edge
-        box.x = x + width - titlebar_border_thickness;
-        box.y = y + titlebar_border_thickness;
-        box.width = titlebar_border_thickness;
-        box.height = container_titlebar_height() - titlebar_border_thickness * 2;
-        scale_box(&box, output_scale);
-        render_rect(output, output_damage, &box, color);
-        int inner_x = x - output_x + titlebar_h_padding;
-        int bg_y = y + titlebar_border_thickness;
-        size_t inner_width = width - titlebar_h_padding * 2;
-        // output-buffer local
-        int ob_inner_x = round(inner_x * output_scale);
-        int ob_inner_width = scale_length(inner_width, inner_x, output_scale);
-        int ob_bg_height = scale_length(
-                        (titlebar_v_padding - titlebar_border_thickness) * 2 +
-                        config->font_height, bg_y, output_scale);
-        // Marks
-        int ob_marks_x = 0; // output-buffer-local
-        int ob_marks_width = 0; // output-buffer-local
-        if (config->show_marks && marks_texture) {
-                struct wlr_box texture_box = {
-                        .width = marks_texture->width,
-                        .height = marks_texture->height,
-                };
-                ob_marks_width = texture_box.width;
-                // The marks texture might be shorter than the config->font_height, in
-                // which case we need to pad it as evenly as possible above and below.
-                int ob_padding_total = ob_bg_height - texture_box.height;
-                int ob_padding_above = floor(ob_padding_total / 2.0);
-                int ob_padding_below = ceil(ob_padding_total / 2.0);
-                // Render texture. If the title is on the right, the marks will be on
-                // the left. Otherwise, they will be on the right.
-                if (title_align == ALIGN_RIGHT || texture_box.width > ob_inner_width) {
-                        texture_box.x = ob_inner_x;
-                } else {
-                        texture_box.x = ob_inner_x + ob_inner_width - texture_box.width;
-                }
-                ob_marks_x = texture_box.x;
-                texture_box.y = round((bg_y - output_y) * output_scale) +
-                        ob_padding_above;
-                float matrix[9];
-                wlr_matrix_project_box(matrix, &texture_box,
-                        WL_OUTPUT_TRANSFORM_NORMAL,
-                        0.0, output->wlr_output->transform_matrix);
-                if (ob_inner_width < texture_box.width) {
-                        texture_box.width = ob_inner_width;
-                }
-                render_texture(output->wlr_output, output_damage, marks_texture,
-                        NULL, &texture_box, matrix, con->alpha);
-                // Padding above
-                memcpy(&color, colors->background, sizeof(float) * 4);
-                premultiply_alpha(color, con->alpha);
-                box.x = texture_box.x + round(output_x * output_scale);
-                box.y = round((y + titlebar_border_thickness) * output_scale);
-                box.width = texture_box.width;
-                box.height = ob_padding_above;
-                render_rect(output, output_damage, &box, color);
-                // Padding below
-                box.y += ob_padding_above + texture_box.height;
-                box.height = ob_padding_below;
-                render_rect(output, output_damage, &box, color);
-        }
-        // Title text
-        int ob_title_x = 0;  // output-buffer-local
-        int ob_title_width = 0; // output-buffer-local
-        if (title_texture) {
-                struct wlr_box texture_box = {
-                        .width = title_texture->width,
-                        .height = title_texture->height,
-                };
-                // The effective output may be NULL when con is not on any output.
-                // This can happen because we render all children of containers,
-                // even those that are out of the bounds of any output.
-                struct sway_output *effective = container_get_effective_output(con);
-                float title_scale = effective ? effective->wlr_output->scale : output_scale;
-                texture_box.width = texture_box.width * output_scale / title_scale;
-                texture_box.height = texture_box.height * output_scale / title_scale;
-                ob_title_width = texture_box.width;
-                // The title texture might be shorter than the config->font_height,
-                // in which case we need to pad it above and below.
-                int ob_padding_above = round((config->font_baseline -
-                                        con->title_baseline + titlebar_v_padding -
-                                        titlebar_border_thickness) * output_scale);
-                int ob_padding_below = ob_bg_height - ob_padding_above -
-                        texture_box.height;
-                // Render texture
-                if (texture_box.width > ob_inner_width - ob_marks_width) {
-                        texture_box.x = (title_align == ALIGN_RIGHT && ob_marks_width)
-                                ? ob_marks_x + ob_marks_width : ob_inner_x;
-                } else if (title_align == ALIGN_LEFT) {
-                        texture_box.x = ob_inner_x;
-                } else if (title_align == ALIGN_CENTER) {
-                        // If there are marks visible, center between the edge and marks.
-                        // Otherwise, center in the inner area.
-                        if (ob_marks_width) {
-                                texture_box.x = (ob_inner_x + ob_marks_x) / 2
-                                        - texture_box.width / 2;
-                        } else {
-                                texture_box.x = ob_inner_x + ob_inner_width / 2
-                                        - texture_box.width / 2;
-                        }
-                } else {
-                        texture_box.x = ob_inner_x + ob_inner_width - texture_box.width;
-                }
-                ob_title_x = texture_box.x;
-                texture_box.y =
-                        round((bg_y - output_y) * output_scale) + ob_padding_above;
-                float matrix[9];
-                wlr_matrix_project_box(matrix, &texture_box,
-                        WL_OUTPUT_TRANSFORM_NORMAL,
-                        0.0, output->wlr_output->transform_matrix);
-                if (ob_inner_width - ob_marks_width < texture_box.width) {
-                        texture_box.width = ob_inner_width - ob_marks_width;
-                }
-                render_texture(output->wlr_output, output_damage, title_texture,
-                        NULL, &texture_box, matrix, con->alpha);
-                // Padding above
-                memcpy(&color, colors->background, sizeof(float) * 4);
-                premultiply_alpha(color, con->alpha);
-                box.x = texture_box.x + round(output_x * output_scale);
-                box.y = round((y + titlebar_border_thickness) * output_scale);
-                box.width = texture_box.width;
-                box.height = ob_padding_above;
-                render_rect(output, output_damage, &box, color);
-                // Padding below
-                box.y += ob_padding_above + texture_box.height;
-                box.height = ob_padding_below;
-                render_rect(output, output_damage, &box, color);
-        }
-        // Determine the left + right extends of the textures (output-buffer local)
-        int ob_left_x, ob_left_width, ob_right_x, ob_right_width;
-        if (ob_title_width == 0 && ob_marks_width == 0) {
-                ob_left_x = ob_inner_x;
-                ob_left_width = 0;
-                ob_right_x = ob_inner_x;
-                ob_right_width = 0;
-        } else if (ob_title_x < ob_marks_x) {
-                ob_left_x = ob_title_x;
-                ob_left_width = ob_title_width;
-                ob_right_x = ob_marks_x;
-                ob_right_width = ob_marks_width;
-        } else {
-                ob_left_x = ob_marks_x;
-                ob_left_width = ob_marks_width;
-                ob_right_x = ob_title_x;
-                ob_right_width = ob_title_width;
-        }
-        if (ob_left_x < ob_inner_x) {
-                ob_left_x = ob_inner_x;
-        } else if (ob_left_x + ob_left_width > ob_right_x + ob_right_width) {
-                ob_right_x = ob_left_x;
-                ob_right_width = ob_left_width;
-        }
-        // Filler between title and marks
-        box.width = ob_right_x - ob_left_x - ob_left_width;
-        if (box.width > 0) {
-                box.x = ob_left_x + ob_left_width + round(output_x * output_scale);
-                box.y = round(bg_y * output_scale);
-                box.height = ob_bg_height;
-                render_rect(output, output_damage, &box, color);
-        }
-        // Padding on left side
-        box.x = x + titlebar_border_thickness;
-        box.y = y + titlebar_border_thickness;
-        box.width = titlebar_h_padding - titlebar_border_thickness;
-        box.height = (titlebar_v_padding - titlebar_border_thickness) * 2 +
-                config->font_height;
-        scale_box(&box, output_scale);
-        int left_x = ob_left_x + round(output_x * output_scale);
-        if (box.x + box.width < left_x) {
-                box.width += left_x - box.x - box.width;
-        }
-        render_rect(output, output_damage, &box, color);
-        // Padding on right side
-        box.x = x + width - titlebar_h_padding;
-        box.y = y + titlebar_border_thickness;
-        box.width = titlebar_h_padding - titlebar_border_thickness;
-        box.height = (titlebar_v_padding - titlebar_border_thickness) * 2 +
-                config->font_height;
-        scale_box(&box, output_scale);
-        int right_rx = ob_right_x + ob_right_width + round(output_x * output_scale);
-        if (right_rx < box.x) {
-                box.width += box.x - right_rx;
-                box.x = right_rx;
-        }
-        render_rect(output, output_damage, &box, color);
-}
-/**
- * Render the top border line for a view using "border pixel".
- */
-static void render_top_border(struct sway_output *output,
-                pixman_region32_t *output_damage, struct sway_container *con,
-                struct border_colors *colors) {
-        struct sway_container_state *state = &con->current;
-        if (!state->border_top) {
-                return;
-        }
-        struct wlr_box box;
-        float color[4];
-        float output_scale = output->wlr_output->scale;
-        // Child border - top edge
-        memcpy(&color, colors->child_border, sizeof(float) * 4);
-        premultiply_alpha(color, con->alpha);
-        box.x = floor(state->x);
-        box.y = floor(state->y);
-        box.width = state->width;
-        box.height = state->border_thickness;
-        scale_box(&box, output_scale);
-        render_rect(output, output_damage, &box, color);
-}
-struct parent_data {
-        enum sway_container_layout layout;
-        struct wlr_box box;
-        list_t *children;
-        bool focused;
-        struct sway_container *active_child;
-};
-static void render_container(struct sway_output *output,
-        pixman_region32_t *damage, struct sway_container *con, bool parent_focused);
-/**
- * Render a container's children using a L_HORIZ or L_VERT layout.
- *
- * Wrap child views in borders and leave child containers borderless because
- * they'll apply their own borders to their children.
- */
-static void render_containers_linear(struct sway_output *output,
-                pixman_region32_t *damage, struct parent_data *parent) {
-        for (int i = 0; i < parent->children->length; ++i) {
-                struct sway_container *child = parent->children->items[i];
-                if (child->view) {
-                        struct sway_view *view = child->view;
-                        struct border_colors *colors;
-                        struct wlr_texture *title_texture;
-                        struct wlr_texture *marks_texture;
-                        struct sway_container_state *state = &child->current;
-                        if (view_is_urgent(view)) {
-                                colors = &config->border_colors.urgent;
-                                title_texture = child->title_urgent;
-                                marks_texture = child->marks_urgent;
-                        } else if (state->focused || parent->focused) {
-                                colors = &config->border_colors.focused;
-                                title_texture = child->title_focused;
-                                marks_texture = child->marks_focused;
-                        } else if (child == parent->active_child) {
-                                colors = &config->border_colors.focused_inactive;
-                                title_texture = child->title_focused_inactive;
-                                marks_texture = child->marks_focused_inactive;
-                        } else {
-                                colors = &config->border_colors.unfocused;
-                                title_texture = child->title_unfocused;
-                                marks_texture = child->marks_unfocused;
-                        }
-                        if (state->border == B_NORMAL) {
-                                render_titlebar(output, damage, child, floor(state->x),
-                                                floor(state->y), state->width, colors,
-                                                title_texture, marks_texture);
-                        } else if (state->border == B_PIXEL) {
-                                render_top_border(output, damage, child, colors);
-                        }
-                        render_view(output, damage, child, colors);
-                } else {
-                        render_container(output, damage, child,
-                                        parent->focused || child->current.focused);
-                }
-        }
-}
-/**
- * Render a container's children using the L_TABBED layout.
- */
-static void render_containers_tabbed(struct sway_output *output,
-                pixman_region32_t *damage, struct parent_data *parent) {
-        if (!parent->children->length) {
-                return;
-        }
-        struct sway_container *current = parent->active_child;
-        struct border_colors *current_colors = &config->border_colors.unfocused;
-        int tab_width = parent->box.width / parent->children->length;
-        // Render tabs
-        for (int i = 0; i < parent->children->length; ++i) {
-                struct sway_container *child = parent->children->items[i];
-                struct sway_view *view = child->view;
-                struct sway_container_state *cstate = &child->current;
-                struct border_colors *colors;
-                struct wlr_texture *title_texture;
-                struct wlr_texture *marks_texture;
-                bool urgent = view ?
-                        view_is_urgent(view) : container_has_urgent_child(child);
-                if (urgent) {
-                        colors = &config->border_colors.urgent;
-                        title_texture = child->title_urgent;
-                        marks_texture = child->marks_urgent;
-                } else if (cstate->focused || parent->focused) {
-                        colors = &config->border_colors.focused;
-                        title_texture = child->title_focused;
-                        marks_texture = child->marks_focused;
-                } else if (child == parent->active_child) {
-                        colors = &config->border_colors.focused_inactive;
-                        title_texture = child->title_focused_inactive;
-                        marks_texture = child->marks_focused_inactive;
-                } else {
-                        colors = &config->border_colors.unfocused;
-                        title_texture = child->title_unfocused;
-                        marks_texture = child->marks_unfocused;
-                }
-                int x = floor(cstate->x + tab_width * i);
-                // Make last tab use the remaining width of the parent
-                if (i == parent->children->length - 1) {
-                        tab_width = parent->box.width - tab_width * i;
-                }
-                render_titlebar(output, damage, child, x, parent->box.y, tab_width,
-                                colors, title_texture, marks_texture);
-                if (child == current) {
-                        current_colors = colors;
-                }
-        }
-        // Render surface and left/right/bottom borders
-        if (current->view) {
-                render_view(output, damage, current, current_colors);
-        } else {
-                render_container(output, damage, current,
-                                parent->focused || current->current.focused);
-        }
-}
-/**
- * Render a container's children using the L_STACKED layout.
- */
-static void render_containers_stacked(struct sway_output *output,
-                pixman_region32_t *damage, struct parent_data *parent) {
-        if (!parent->children->length) {
-                return;
-        }
-        struct sway_container *current = parent->active_child;
-        struct border_colors *current_colors = &config->border_colors.unfocused;
-        size_t titlebar_height = container_titlebar_height();
-        // Render titles
-        for (int i = 0; i < parent->children->length; ++i) {
-                struct sway_container *child = parent->children->items[i];
-                struct sway_view *view = child->view;
-                struct sway_container_state *cstate = &child->current;
-                struct border_colors *colors;
-                struct wlr_texture *title_texture;
-                struct wlr_texture *marks_texture;
-                bool urgent = view ?
-                        view_is_urgent(view) : container_has_urgent_child(child);
-                if (urgent) {
-                        colors = &config->border_colors.urgent;
-                        title_texture = child->title_urgent;
-                        marks_texture = child->marks_urgent;
-                } else if (cstate->focused || parent->focused) {
-                        colors = &config->border_colors.focused;
-                        title_texture = child->title_focused;
-                        marks_texture = child->marks_focused;
-                } else if (child == parent->active_child) {
-                        colors = &config->border_colors.focused_inactive;
-                        title_texture = child->title_focused_inactive;
-                        marks_texture = child->marks_focused_inactive;
-                } else {
-                        colors = &config->border_colors.unfocused;
-                        title_texture = child->title_unfocused;
-                        marks_texture = child->marks_unfocused;
-                }
-                int y = parent->box.y + titlebar_height * i;
-                render_titlebar(output, damage, child, parent->box.x, y,
-                                parent->box.width, colors, title_texture, marks_texture);
-                if (child == current) {
-                        current_colors = colors;
-                }
-        }
-        // Render surface and left/right/bottom borders
-        if (current->view) {
-                render_view(output, damage, current, current_colors);
-        } else {
-                render_container(output, damage, current,
-                                parent->focused || current->current.focused);
-        }
-}
-static void render_containers(struct sway_output *output,
-                pixman_region32_t *damage, struct parent_data *parent) {
-        if (config->hide_lone_tab && parent->children->length == 1) {
-                struct sway_container *child = parent->children->items[0];
-                if (child->view) {
-                        render_containers_linear(output,damage, parent);
-                        return;
-                }
-        }
-        switch (parent->layout) {
-        case L_NONE:
-        case L_HORIZ:
-        case L_VERT:
-                render_containers_linear(output, damage, parent);
-                break;
-        case L_STACKED:
-                render_containers_stacked(output, damage, parent);
-                break;
-        case L_TABBED:
-                render_containers_tabbed(output, damage, parent);
-                break;
-        }
-}
-static void render_container(struct sway_output *output,
-                pixman_region32_t *damage, struct sway_container *con, bool focused) {
-        struct parent_data data = {
-                .layout = con->current.layout,
-                .box = {
-                        .x = floor(con->current.x),
-                        .y = floor(con->current.y),
-                        .width = con->current.width,
-                        .height = con->current.height,
-                },
-                .children = con->current.children,
-                .focused = focused,
-                .active_child = con->current.focused_inactive_child,
-        };
-        render_containers(output, damage, &data);
-}
-static void render_workspace(struct sway_output *output,
-                pixman_region32_t *damage, struct sway_workspace *ws, bool focused) {
-        struct parent_data data = {
-                .layout = ws->current.layout,
-                .box = {
-                        .x = floor(ws->current.x),
-                        .y = floor(ws->current.y),
-                        .width = ws->current.width,
-                        .height = ws->current.height,
-                },
-                .children = ws->current.tiling,
-                .focused = focused,
-                .active_child = ws->current.focused_inactive_child,
-        };
-        render_containers(output, damage, &data);
-}
-static void render_floating_container(struct sway_output *soutput,
-                pixman_region32_t *damage, struct sway_container *con) {
-        if (con->view) {
-                struct sway_view *view = con->view;
-                struct border_colors *colors;
-                struct wlr_texture *title_texture;
-                struct wlr_texture *marks_texture;
-                if (view_is_urgent(view)) {
-                        colors = &config->border_colors.urgent;
-                        title_texture = con->title_urgent;
-                        marks_texture = con->marks_urgent;
-                } else if (con->current.focused) {
-                        colors = &config->border_colors.focused;
-                        title_texture = con->title_focused;
-                        marks_texture = con->marks_focused;
-                } else {
-                        colors = &config->border_colors.unfocused;
-                        title_texture = con->title_unfocused;
-                        marks_texture = con->marks_unfocused;
-                }
-                if (con->current.border == B_NORMAL) {
-                        render_titlebar(soutput, damage, con, floor(con->current.x),
-                                        floor(con->current.y), con->current.width, colors,
-                                        title_texture, marks_texture);
-                } else if (con->current.border == B_PIXEL) {
-                        render_top_border(soutput, damage, con, colors);
-                }
-                render_view(soutput, damage, con, colors);
-        } else {
-                render_container(soutput, damage, con, con->current.focused);
-        }
-}
-static void render_floating(struct sway_output *soutput,
-                pixman_region32_t *damage) {
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                for (int j = 0; j < output->current.workspaces->length; ++j) {
-                        struct sway_workspace *ws = output->current.workspaces->items[j];
-                        if (!workspace_is_visible(ws)) {
-                                continue;
-                        }
-                        for (int k = 0; k < ws->current.floating->length; ++k) {
-                                struct sway_container *floater = ws->current.floating->items[k];
-                                if (floater->current.fullscreen_mode != FULLSCREEN_NONE) {
-                                        continue;
-                                }
-                                render_floating_container(soutput, damage, floater);
-                        }
-                }
-        }
-}
-static void render_seatops(struct sway_output *output,
-                pixman_region32_t *damage) {
-        struct sway_seat *seat;
-        wl_list_for_each(seat, &server.input->seats, link) {
-                seatop_render(seat, output, damage);
-        }
-}
-void output_render(struct sway_output *output, struct timespec *when,
-                pixman_region32_t *damage) {
-        struct wlr_output *wlr_output = output->wlr_output;
-        struct wlr_renderer *renderer =
-                wlr_backend_get_renderer(wlr_output->backend);
-        if (!sway_assert(renderer != NULL,
-                        "expected the output backend to have a renderer")) {
-                return;
-        }
-        struct sway_workspace *workspace = output->current.active_workspace;
-        if (workspace == NULL) {
-                return;
-        }
-        struct sway_container *fullscreen_con = root->fullscreen_global;
-        if (!fullscreen_con) {
-                fullscreen_con = workspace->current.fullscreen;
-        }
-        wlr_renderer_begin(renderer, wlr_output->width, wlr_output->height);
-        if (!pixman_region32_not_empty(damage)) {
-                // Output isn't damaged but needs buffer swap
-                goto renderer_end;
-        }
-        if (debug.damage == DAMAGE_HIGHLIGHT) {
-                wlr_renderer_clear(renderer, (float[]){1, 1, 0, 1});
-        } else if (debug.damage == DAMAGE_RERENDER) {
-                int width, height;
-                wlr_output_transformed_resolution(wlr_output, &width, &height);
-                pixman_region32_union_rect(damage, damage, 0, 0, width, height);
-        }
-        if (output_has_opaque_overlay_layer_surface(output)) {
-                goto render_overlay;
-        }
-        if (fullscreen_con) {
-                float clear_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
-                int nrects;
-                pixman_box32_t *rects = pixman_region32_rectangles(damage, &nrects);
-                for (int i = 0; i < nrects; ++i) {
-                        scissor_output(wlr_output, &rects[i]);
-                        wlr_renderer_clear(renderer, clear_color);
-                }
-                if (fullscreen_con->view) {
-                        if (!wl_list_empty(&fullscreen_con->view->saved_buffers)) {
-                                render_saved_view(fullscreen_con->view, output, damage, 1.0f);
-                        } else if (fullscreen_con->view->surface) {
-                                render_view_toplevels(fullscreen_con->view,
-                                                output, damage, 1.0f);
-                        }
-                } else {
-                        render_container(output, damage, fullscreen_con,
-                                        fullscreen_con->current.focused);
-                }
-                for (int i = 0; i < workspace->current.floating->length; ++i) {
-                        struct sway_container *floater =
-                                workspace->current.floating->items[i];
-                        if (container_is_transient_for(floater, fullscreen_con)) {
-                                render_floating_container(output, damage, floater);
-                        }
-                }
-#if HAVE_XWAYLAND
-                render_unmanaged(output, damage, &root->xwayland_unmanaged);
-#endif
-        } else {
-                float clear_color[] = {0.25f, 0.25f, 0.25f, 1.0f};
-                int nrects;
-                pixman_box32_t *rects = pixman_region32_rectangles(damage, &nrects);
-                for (int i = 0; i < nrects; ++i) {
-                        scissor_output(wlr_output, &rects[i]);
-                        wlr_renderer_clear(renderer, clear_color);
-                }
-                render_layer_toplevel(output, damage,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]);
-                render_layer_toplevel(output, damage,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]);
-                render_workspace(output, damage, workspace, workspace->current.focused);
-                render_floating(output, damage);
-#if HAVE_XWAYLAND
-                render_unmanaged(output, damage, &root->xwayland_unmanaged);
-#endif
-                render_layer_toplevel(output, damage,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]);
-                render_layer_popups(output, damage,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]);
-                render_layer_popups(output, damage,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]);
-                render_layer_popups(output, damage,
-                        &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]);
-        }
-        render_seatops(output, damage);
-        struct sway_seat *seat = input_manager_current_seat();
-        struct sway_container *focus = seat_get_focused_container(seat);
-        if (focus && focus->view) {
-                render_view_popups(focus->view, output, damage, focus->alpha);
-        }
-render_overlay:
-        render_layer_toplevel(output, damage,
-                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
-        render_layer_popups(output, damage,
-                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
-        render_drag_icons(output, damage, &root->drag_icons);
-renderer_end:
-        wlr_renderer_scissor(renderer, NULL);
-        wlr_output_render_software_cursors(wlr_output, damage);
-        wlr_renderer_end(renderer);
-        int width, height;
-        wlr_output_transformed_resolution(wlr_output, &width, &height);
-        pixman_region32_t frame_damage;
-        pixman_region32_init(&frame_damage);
-        enum wl_output_transform transform =
-                wlr_output_transform_invert(wlr_output->transform);
-        wlr_region_transform(&frame_damage, &output->damage->current,
-                transform, width, height);
-        if (debug.damage == DAMAGE_HIGHLIGHT) {
-                pixman_region32_union_rect(&frame_damage, &frame_damage,
-                        0, 0, wlr_output->width, wlr_output->height);
-        }
-        wlr_output_set_damage(wlr_output, &frame_damage);
-        pixman_region32_fini(&frame_damage);
-        if (!wlr_output_commit(wlr_output)) {
-                return;
-        }
-        output->last_frame = *when;
-}
diff --git a/sway/desktop/surface.c b/sway/desktop/surface.c
deleted file mode 100644
index 767b2045..00000000
--- a/sway/desktop/surface.c
+++ /dev/null
@@ -1,46 +0,0 @@
-#define _POSIX_C_SOURCE 200112L
-#include <stdlib.h>
-#include <time.h>
-#include <wlr/types/wlr_surface.h>
-#include "sway/server.h"
-#include "sway/surface.h"
-static void handle_destroy(struct wl_listener *listener, void *data) {
-        struct sway_surface *surface = wl_container_of(listener, surface, destroy);
-        surface->wlr_surface->data = NULL;
-        wl_list_remove(&surface->destroy.link);
-        if (surface->frame_done_timer) {
-                wl_event_source_remove(surface->frame_done_timer);
-        }
-        free(surface);
-}
-static int surface_frame_done_timer_handler(void *data) {
-        struct sway_surface *surface = data;
-        struct timespec now;
-        clock_gettime(CLOCK_MONOTONIC, &now);
-        wlr_surface_send_frame_done(surface->wlr_surface, &now);
-        return 0;
-}
-void handle_compositor_new_surface(struct wl_listener *listener, void *data) {
-        struct wlr_surface *wlr_surface = data;
-        struct sway_surface *surface = calloc(1, sizeof(struct sway_surface));
-        surface->wlr_surface = wlr_surface;
-        wlr_surface->data = surface;
-        surface->destroy.notify = handle_destroy;
-        wl_signal_add(&wlr_surface->events.destroy, &surface->destroy);
-        surface->frame_done_timer = wl_event_loop_add_timer(server.wl_event_loop,
-                surface_frame_done_timer_handler, surface);
-        if (!surface->frame_done_timer) {
-                wl_resource_post_no_memory(wlr_surface->resource);
-        }
-}
diff --git a/sway/desktop/transaction.c b/sway/desktop/transaction.c
index b1f3fb32..e464ff1a 100644
--- a/sway/desktop/transaction.c
+++ b/sway/desktop/transaction.c
@@ -1,11 +1,10 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <wlr/types/wlr_buffer.h>
 #include "sway/config.h"
-#include "sway/desktop.h"
+#include "sway/scene_descriptor.h"
 #include "sway/desktop/idle_inhibit_v1.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
@@ -214,39 +213,20 @@ static void transaction_add_node(struct sway_transaction *transaction,
 static void apply_output_state(struct sway_output *output,
                struct sway_output_state *state) {
-        output_damage_whole(output);
        list_free(output->current.workspaces);
        memcpy(&output->current, state, sizeof(struct sway_output_state));
-        output_damage_whole(output);
 }
 static void apply_workspace_state(struct sway_workspace *ws,
                struct sway_workspace_state *state) {
-        output_damage_whole(ws->current.output);
        list_free(ws->current.floating);
        list_free(ws->current.tiling);
        memcpy(&ws->current, state, sizeof(struct sway_workspace_state));
-        output_damage_whole(ws->current.output);
 }
 static void apply_container_state(struct sway_container *container,
                struct sway_container_state *state) {
        struct sway_view *view = container->view;
-        // Damage the old location
-        desktop_damage_whole_container(container);
-        if (view && !wl_list_empty(&view->saved_buffers)) {
-                struct sway_saved_buffer *saved_buf;
-                wl_list_for_each(saved_buf, &view->saved_buffers, link) {
-                        struct wlr_box box = {
-                                .x = saved_buf->x - view->saved_geometry.x,
-                                .y = saved_buf->y - view->saved_geometry.y,
-                                .width = saved_buf->width,
-                                .height = saved_buf->height,
-                        };
-                        desktop_damage_box(&box);
-                }
-        }
        // There are separate children lists for each instruction state, the
        // container's current state and the container's pending state
        // (ie. con->children). The list itself needs to be freed here.
@@ -256,35 +236,443 @@ static void apply_container_state(struct sway_container *container,
        memcpy(&container->current, state, sizeof(struct sway_container_state));
-        if (view && !wl_list_empty(&view->saved_buffers)) {
+        if (view) {
-                if (!container->node.destroying || container->node.ntxnrefs == 1) {
+                if (view->saved_surface_tree) {
-                        view_remove_saved_buffer(view);
+                        if (!container->node.destroying || container->node.ntxnrefs == 1) {
+                                view_remove_saved_buffer(view);
+                        }
+                }
+                // If the view hasn't responded to the configure, center it within
+                // the container. This is important for fullscreen views which
+                // refuse to resize to the size of the output.
+                if (view->surface) {
+                        view_center_and_clip_surface(view);
+                }
+        }
+}
+static void arrange_title_bar(struct sway_container *con,
+                int x, int y, int width, int height) {
+        container_update(con);
+        bool has_title_bar = height > 0;
+        wlr_scene_node_set_enabled(&con->title_bar.tree->node, has_title_bar);
+        if (!has_title_bar) {
+                return;
+        }
+        wlr_scene_node_set_position(&con->title_bar.tree->node, x, y);
+        con->title_width = width;
+        container_arrange_title_bar(con);
+}
+static void disable_container(struct sway_container *con) {
+        if (con->view) {
+                wlr_scene_node_reparent(&con->view->scene_tree->node, con->content_tree);
+        } else {
+                for (int i = 0; i < con->current.children->length; i++) {
+                        struct sway_container *child = con->current.children->items[i];
+                        wlr_scene_node_reparent(&child->scene_tree->node, con->content_tree);
+                        disable_container(child);
+                }
+        }
+}
+static void arrange_container(struct sway_container *con,
+                int width, int height, bool title_bar, int gaps);
+static void arrange_children(enum sway_container_layout layout, list_t *children,
+                struct sway_container *active, struct wlr_scene_tree *content,
+                int width, int height, int gaps) {
+        int title_bar_height = container_titlebar_height();
+        if (layout == L_TABBED) {
+                struct sway_container *first = children->length == 1 ?
+                        ((struct sway_container *)children->items[0]) : NULL;
+                if (config->hide_lone_tab && first && first->view &&
+                                first->current.border != B_NORMAL) {
+                        title_bar_height = 0;
+                }
+                double w = (double) width / children->length;
+                int title_offset = 0;
+                for (int i = 0; i < children->length; i++) {
+                        struct sway_container *child = children->items[i];
+                        bool activated = child == active;
+                        int next_title_offset = round(w * i + w);
+                        arrange_title_bar(child, title_offset, -title_bar_height,
+                                next_title_offset - title_offset, title_bar_height);
+                        wlr_scene_node_set_enabled(&child->border.tree->node, activated);
+                        wlr_scene_node_set_position(&child->scene_tree->node, 0, title_bar_height);
+                        wlr_scene_node_reparent(&child->scene_tree->node, content);
+                        if (activated) {
+                                arrange_container(child, width, height - title_bar_height,
+                                        false, 0);
+                        } else {
+                                disable_container(child);
+                        }
+                        title_offset = next_title_offset;
+                }
+        } else if (layout == L_STACKED) {
+                struct sway_container *first = children->length == 1 ?
+                        ((struct sway_container *)children->items[0]) : NULL;
+                if (config->hide_lone_tab && first && first->view &&
+                                first->current.border != B_NORMAL) {
+                        title_bar_height = 0;
+                }
+                int title_height = title_bar_height * children->length;
+                int y = 0;
+                for (int i = 0; i < children->length; i++) {
+                        struct sway_container *child = children->items[i];
+                        bool activated = child == active;
+                        arrange_title_bar(child, 0, y - title_height, width, title_bar_height);
+                        wlr_scene_node_set_enabled(&child->border.tree->node, activated);
+                        wlr_scene_node_set_position(&child->scene_tree->node, 0, title_height);
+                        wlr_scene_node_reparent(&child->scene_tree->node, content);
+                        if (activated) {
+                                arrange_container(child, width, height - title_height,
+                                        false, 0);
+                        } else {
+                                disable_container(child);
+                        }
+                        y += title_bar_height;
+                }
+        } else if (layout == L_VERT) {
+                int off = 0;
+                for (int i = 0; i < children->length; i++) {
+                        struct sway_container *child = children->items[i];
+                        int cheight = child->current.height;
+                        wlr_scene_node_set_enabled(&child->border.tree->node, true);
+                        wlr_scene_node_set_position(&child->scene_tree->node, 0, off);
+                        wlr_scene_node_reparent(&child->scene_tree->node, content);
+                        arrange_container(child, width, cheight, true, gaps);
+                        off += cheight + gaps;
+                }
+        } else if (layout == L_HORIZ) {
+                int off = 0;
+                for (int i = 0; i < children->length; i++) {
+                        struct sway_container *child = children->items[i];
+                        int cwidth = child->current.width;
+                        wlr_scene_node_set_enabled(&child->border.tree->node, true);
+                        wlr_scene_node_set_position(&child->scene_tree->node, off, 0);
+                        wlr_scene_node_reparent(&child->scene_tree->node, content);
+                        arrange_container(child, cwidth, height, true, gaps);
+                        off += cwidth + gaps;
+                }
+        } else {
+                sway_assert(false, "unreachable");
+        }
+}
+static void arrange_container(struct sway_container *con,
+                int width, int height, bool title_bar, int gaps) {
+        // this container might have previously been in the scratchpad,
+        // make sure it's enabled for viewing
+        wlr_scene_node_set_enabled(&con->scene_tree->node, true);
+        if (con->output_handler) {
+                wlr_scene_buffer_set_dest_size(con->output_handler, width, height);
+        }
+        if (con->view) {
+                int border_top = container_titlebar_height();
+                int border_width = con->current.border_thickness;
+                if (title_bar && con->current.border != B_NORMAL) {
+                        wlr_scene_node_set_enabled(&con->title_bar.tree->node, false);
+                        wlr_scene_node_set_enabled(&con->border.top->node, true);
+                } else {
+                        wlr_scene_node_set_enabled(&con->border.top->node, false);
+                }
+                if (con->current.border == B_NORMAL) {
+                        if (title_bar) {
+                                arrange_title_bar(con, 0, 0, width, border_top);
+                        } else {
+                                border_top = 0;
+                                // should be handled by the parent container
+                        }
+                } else if (con->current.border == B_PIXEL) {
+                        container_update(con);
+                        border_top = title_bar && con->current.border_top ? border_width : 0;
+                } else if (con->current.border == B_NONE) {
+                        container_update(con);
+                        border_top = 0;
+                        border_width = 0;
+                } else if (con->current.border == B_CSD) {
+                        border_top = 0;
+                        border_width = 0;
+                } else {
+                        sway_assert(false, "unreachable");
+                }
+                int border_bottom = con->current.border_bottom ? border_width : 0;
+                int border_left = con->current.border_left ? border_width : 0;
+                int border_right = con->current.border_right ? border_width : 0;
+                wlr_scene_rect_set_size(con->border.top, width, border_top);
+                wlr_scene_rect_set_size(con->border.bottom, width, border_bottom);
+                wlr_scene_rect_set_size(con->border.left,
+                        border_left, height - border_top - border_bottom);
+                wlr_scene_rect_set_size(con->border.right,
+                        border_right, height - border_top - border_bottom);
+                wlr_scene_node_set_position(&con->border.top->node, 0, 0);
+                wlr_scene_node_set_position(&con->border.bottom->node,
+                        0, height - border_bottom);
+                wlr_scene_node_set_position(&con->border.left->node,
+                        0, border_top);
+                wlr_scene_node_set_position(&con->border.right->node,
+                        width - border_right, border_top);
+                // make sure to reparent, it's possible that the client just came out of
+                // fullscreen mode where the parent of the surface is not the container
+                wlr_scene_node_reparent(&con->view->scene_tree->node, con->content_tree);
+                wlr_scene_node_set_position(&con->view->scene_tree->node,
+                        border_left, border_top);
+        } else {
+                // make sure to disable the title bar if the parent is not managing it
+                if (title_bar) {
+                        wlr_scene_node_set_enabled(&con->title_bar.tree->node, false);
+                }
+                arrange_children(con->current.layout, con->current.children,
+                        con->current.focused_inactive_child, con->content_tree,
+                        width, height, gaps);
+        }
+}
+static int container_get_gaps(struct sway_container *con) {
+        struct sway_workspace *ws = con->current.workspace;
+        struct sway_container *temp = con;
+        while (temp) {
+                enum sway_container_layout layout;
+                if (temp->current.parent) {
+                        layout = temp->current.parent->current.layout;
+                } else {
+                        layout = ws->current.layout;
+                }
+                if (layout == L_TABBED || layout == L_STACKED) {
+                        return 0;
+                }
+                temp = temp->pending.parent;
+        }
+        return ws->gaps_inner;
+}
+static void arrange_fullscreen(struct wlr_scene_tree *tree,
+                struct sway_container *fs, struct sway_workspace *ws,
+                int width, int height) {
+        struct wlr_scene_node *fs_node;
+        if (fs->view) {
+                fs_node = &fs->view->scene_tree->node;
+                // if we only care about the view, disable any decorations
+                wlr_scene_node_set_enabled(&fs->scene_tree->node, false);
+        } else {
+                fs_node = &fs->scene_tree->node;
+                arrange_container(fs, width, height, true, container_get_gaps(fs));
+        }
+        wlr_scene_node_reparent(fs_node, tree);
+        wlr_scene_node_lower_to_bottom(fs_node);
+        wlr_scene_node_set_position(fs_node, 0, 0);
+}
+static void arrange_workspace_floating(struct sway_workspace *ws) {
+        for (int i = 0; i < ws->current.floating->length; i++) {
+                struct sway_container *floater = ws->current.floating->items[i];
+                struct wlr_scene_tree *layer = root->layers.floating;
+                if (floater->current.fullscreen_mode != FULLSCREEN_NONE) {
+                        continue;
+                }
+                if (root->fullscreen_global) {
+                        if (container_is_transient_for(floater, root->fullscreen_global)) {
+                                layer = root->layers.fullscreen_global;
+                        }
+                } else {
+                        for (int i = 0; i < root->outputs->length; i++) {
+                                struct sway_output *output = root->outputs->items[i];
+                                struct sway_workspace *active = output->current.active_workspace;
+                                if (active && active->fullscreen &&
+                                                container_is_transient_for(floater, active->fullscreen)) {
+                                        layer = root->layers.fullscreen;
+                                }
+                        }
+                }
+                wlr_scene_node_reparent(&floater->scene_tree->node, layer);
+                wlr_scene_node_set_position(&floater->scene_tree->node,
+                        floater->current.x, floater->current.y);
+                wlr_scene_node_set_enabled(&floater->scene_tree->node, true);
+                arrange_container(floater, floater->current.width, floater->current.height,
+                        true, ws->gaps_inner);
+        }
+}
+static void arrange_workspace_tiling(struct sway_workspace *ws,
+                int width, int height) {
+        arrange_children(ws->current.layout, ws->current.tiling,
+                ws->current.focused_inactive_child, ws->layers.tiling,
+                width, height, ws->gaps_inner);
+}
+static void disable_workspace(struct sway_workspace *ws) {
+        // if any containers were just moved to a disabled workspace it will
+        // have the parent of the old workspace. Move the workspace so that it won't
+        // be shown.
+        for (int i = 0; i < ws->current.tiling->length; i++) {
+                struct sway_container *child = ws->current.tiling->items[i];
+                wlr_scene_node_reparent(&child->scene_tree->node, ws->layers.tiling);
+                disable_container(child);
+        }
+        for (int i = 0; i < ws->current.floating->length; i++) {
+                struct sway_container *floater = ws->current.floating->items[i];
+                wlr_scene_node_reparent(&floater->scene_tree->node, root->layers.floating);
+                disable_container(floater);
+                wlr_scene_node_set_enabled(&floater->scene_tree->node, false);
+        }
+}
+static void arrange_output(struct sway_output *output, int width, int height) {
+        for (int i = 0; i < output->current.workspaces->length; i++) {
+                struct sway_workspace *child = output->current.workspaces->items[i];
+                bool activated = output->current.active_workspace == child;
+                wlr_scene_node_reparent(&child->layers.tiling->node, output->layers.tiling);
+                wlr_scene_node_reparent(&child->layers.fullscreen->node, output->layers.fullscreen);
+                for (int i = 0; i < child->current.floating->length; i++) {
+                        struct sway_container *floater = child->current.floating->items[i];
+                        wlr_scene_node_reparent(&floater->scene_tree->node, root->layers.floating);
+                        wlr_scene_node_set_enabled(&floater->scene_tree->node, activated);
+                }
+                if (activated) {
+                        struct sway_container *fs = child->current.fullscreen;
+                        wlr_scene_node_set_enabled(&child->layers.tiling->node, !fs);
+                        wlr_scene_node_set_enabled(&child->layers.fullscreen->node, fs);
+                        arrange_workspace_floating(child);
+                        wlr_scene_node_set_enabled(&output->layers.shell_background->node, !fs);
+                        wlr_scene_node_set_enabled(&output->layers.shell_bottom->node, !fs);
+                        wlr_scene_node_set_enabled(&output->layers.fullscreen->node, fs);
+                        if (fs) {
+                                wlr_scene_rect_set_size(output->fullscreen_background, width, height);
+                                arrange_fullscreen(child->layers.fullscreen, fs, child,
+                                        width, height);
+                        } else {
+                                struct wlr_box *area = &output->usable_area;
+                                struct side_gaps *gaps = &child->current_gaps;
+                                wlr_scene_node_set_position(&child->layers.tiling->node,
+                                        gaps->left + area->x, gaps->top + area->y);
+                                arrange_workspace_tiling(child,
+                                        area->width - gaps->left - gaps->right,
+                                        area->height - gaps->top - gaps->bottom);
+                        }
+                } else {
+                        wlr_scene_node_set_enabled(&child->layers.tiling->node, false);
+                        wlr_scene_node_set_enabled(&child->layers.fullscreen->node, false);
+                        disable_workspace(child);
                }
        }
+}
-        // If the view hasn't responded to the configure, center it within
+void arrange_popups(struct wlr_scene_tree *popups) {
-        // the container. This is important for fullscreen views which
+        struct wlr_scene_node *node;
-        // refuse to resize to the size of the output.
+        wl_list_for_each(node, &popups->children, link) {
-        if (view && view->surface) {
+                struct sway_popup_desc *popup = scene_descriptor_try_get(node,
-                view_center_surface(view);
+                        SWAY_SCENE_DESC_POPUP);
+                int lx, ly;
+                wlr_scene_node_coords(popup->relative, &lx, &ly);
+                wlr_scene_node_set_position(node, lx, ly);
        }
+}
+static void arrange_root(struct sway_root *root) {
+        struct sway_container *fs = root->fullscreen_global;
+        wlr_scene_node_set_enabled(&root->layers.shell_background->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.shell_bottom->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.tiling->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.floating->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.shell_top->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.fullscreen->node, !fs);
-        // Damage the new location
+        // hide all contents in the scratchpad
-        desktop_damage_whole_container(container);
+        for (int i = 0; i < root->scratchpad->length; i++) {
-        if (view && view->surface) {
+                struct sway_container *con = root->scratchpad->items[i];
-                struct wlr_surface *surface = view->surface;
-                struct wlr_box box = {
+                wlr_scene_node_set_enabled(&con->scene_tree->node, false);
-                        .x = container->current.content_x - view->geometry.x,
-                        .y = container->current.content_y - view->geometry.y,
-                        .width = surface->current.width,
-                        .height = surface->current.height,
-                };
-                desktop_damage_box(&box);
        }
-        if (!container->node.destroying) {
+        if (fs) {
-                container_discover_outputs(container);
+                for (int i = 0; i < root->outputs->length; i++) {
+                        struct sway_output *output = root->outputs->items[i];
+                        struct sway_workspace *ws = output->current.active_workspace;
+                        if (ws) {
+                                arrange_workspace_floating(ws);
+                        }
+                }
+                arrange_fullscreen(root->layers.fullscreen_global, fs, NULL,
+                        root->width, root->height);
+        } else {
+                for (int i = 0; i < root->outputs->length; i++) {
+                        struct sway_output *output = root->outputs->items[i];
+                        wlr_scene_output_set_position(output->scene_output, output->lx, output->ly);
+                        wlr_scene_node_reparent(&output->layers.shell_background->node, root->layers.shell_background);
+                        wlr_scene_node_reparent(&output->layers.shell_bottom->node, root->layers.shell_bottom);
+                        wlr_scene_node_reparent(&output->layers.tiling->node, root->layers.tiling);
+                        wlr_scene_node_reparent(&output->layers.shell_top->node, root->layers.shell_top);
+                        wlr_scene_node_reparent(&output->layers.shell_overlay->node, root->layers.shell_overlay);
+                        wlr_scene_node_reparent(&output->layers.fullscreen->node, root->layers.fullscreen);
+                        wlr_scene_node_reparent(&output->layers.session_lock->node, root->layers.session_lock);
+                        wlr_scene_node_set_position(&output->layers.shell_background->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.shell_bottom->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.tiling->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.fullscreen->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.shell_top->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.shell_overlay->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.session_lock->node, output->lx, output->ly);
+                        arrange_output(output, output->width, output->height);
+                }
        }
+        arrange_popups(root->layers.popup);
 }
 /**
@@ -326,8 +714,6 @@ static void transaction_apply(struct sway_transaction *transaction) {
                node->instruction = NULL;
        }
-        cursor_rebase_all();
 }
 static void transaction_commit_pending(void);
@@ -340,11 +726,13 @@ static void transaction_progress(void) {
                return;
        }
        transaction_apply(server.queued_transaction);
+        arrange_root(root);
+        cursor_rebase_all();
        transaction_destroy(server.queued_transaction);
        server.queued_transaction = NULL;
        if (!server.pending_transaction) {
-                sway_idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
+                sway_idle_inhibit_v1_check_active();
                return;
        }
@@ -373,7 +761,7 @@ static bool should_configure(struct sway_node *node,
        }
        struct sway_container_state *cstate = &node->sway_container->current;
        struct sway_container_state *istate = &instruction->container_state;
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        // Xwayland views are position-aware and need to be reconfigured
        // when their position changes.
        if (node->sway_container->view->type == SWAY_VIEW_XWAYLAND) {
@@ -402,7 +790,7 @@ static void transaction_commit(struct sway_transaction *transaction) {
                struct sway_transaction_instruction *instruction =
                        transaction->instructions->items[i];
                struct sway_node *node = instruction->node;
-                bool hidden = node_is_view(node) &&
+                bool hidden = node_is_view(node) && !node->destroying &&
                        !view_is_visible(node->sway_container->view);
                if (should_configure(node, instruction)) {
                        instruction->serial = view_configure(node->sway_container->view,
@@ -415,21 +803,11 @@ static void transaction_commit(struct sway_transaction *transaction) {
                                ++transaction->num_waiting;
                        }
-                        // From here on we are rendering a saved buffer of the view, which
+                        view_send_frame_done(node->sway_container->view);
-                        // means we can send a frame done event to make the client redraw it
-                        // as soon as possible. Additionally, this is required if a view is
-                        // mapping and its default geometry doesn't intersect an output.
-                        struct timespec now;
-                        clock_gettime(CLOCK_MONOTONIC, &now);
-                        wlr_surface_send_frame_done(
-                                        node->sway_container->view->surface, &now);
                }
                if (!hidden && node_is_view(node) &&
-                                wl_list_empty(&node->sway_container->view->saved_buffers)) {
+                                !node->sway_container->view->saved_surface_tree) {
                        view_save_buffer(node->sway_container->view);
-                        memcpy(&node->sway_container->view->saved_geometry,
-                                        &node->sway_container->view->geometry,
-                                        sizeof(struct wlr_box));
                }
                node->instruction = instruction;
        }
@@ -499,16 +877,18 @@ static void set_instruction_ready(
        transaction_progress();
 }
-void transaction_notify_view_ready_by_serial(struct sway_view *view,
+bool transaction_notify_view_ready_by_serial(struct sway_view *view,
                uint32_t serial) {
        struct sway_transaction_instruction *instruction =
                view->container->node.instruction;
        if (instruction != NULL && instruction->serial == serial) {
                set_instruction_ready(instruction);
+                return true;
        }
+        return false;
 }
-void transaction_notify_view_ready_by_geometry(struct sway_view *view,
+bool transaction_notify_view_ready_by_geometry(struct sway_view *view,
                double x, double y, int width, int height) {
        struct sway_transaction_instruction *instruction =
                view->container->node.instruction;
@@ -518,7 +898,9 @@ void transaction_notify_view_ready_by_geometry(struct sway_view *view,
                        instruction->container_state.content_width == width &&
                        instruction->container_state.content_height == height) {
                set_instruction_ready(instruction);
+                return true;
        }
+        return false;
 }
 static void _transaction_commit_dirty(bool server_request) {
diff --git a/sway/desktop/xdg_shell.c b/sway/desktop/xdg_shell.c
index d34654fd..7c417891 100644
--- a/sway/desktop/xdg_shell.c
+++ b/sway/desktop/xdg_shell.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 199309L
 #include <float.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -7,7 +6,7 @@
 #include <wlr/util/edges.h>
 #include "log.h"
 #include "sway/decoration.h"
-#include "sway/desktop.h"
+#include "sway/scene_descriptor.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/input-manager.h"
@@ -19,64 +18,45 @@
 #include "sway/tree/workspace.h"
 #include "sway/xdg_decoration.h"
-static const struct sway_view_child_impl popup_impl;
-static void popup_get_root_coords(struct sway_view_child *child,
-                int *root_sx, int *root_sy) {
-        struct sway_xdg_popup *popup = (struct sway_xdg_popup *)child;
-        struct wlr_xdg_surface *surface = popup->wlr_xdg_surface;
-        int x_offset = -child->view->geometry.x - surface->geometry.x;
-        int y_offset = -child->view->geometry.y - surface->geometry.y;
-        wlr_xdg_popup_get_toplevel_coords(surface->popup,
-                x_offset + surface->popup->geometry.x,
-                y_offset + surface->popup->geometry.y,
-                root_sx, root_sy);
-}
-static void popup_destroy(struct sway_view_child *child) {
-        if (!sway_assert(child->impl == &popup_impl,
-                        "Expected an xdg_shell popup")) {
-                return;
-        }
-        struct sway_xdg_popup *popup = (struct sway_xdg_popup *)child;
-        wl_list_remove(&popup->new_popup.link);
-        wl_list_remove(&popup->destroy.link);
-        free(popup);
-}
-static const struct sway_view_child_impl popup_impl = {
-        .get_root_coords = popup_get_root_coords,
-        .destroy = popup_destroy,
-};
 static struct sway_xdg_popup *popup_create(
-        struct wlr_xdg_popup *wlr_popup, struct sway_view *view);
+        struct wlr_xdg_popup *wlr_popup, struct sway_view *view,
+        struct wlr_scene_tree *parent);
 static void popup_handle_new_popup(struct wl_listener *listener, void *data) {
        struct sway_xdg_popup *popup =
                wl_container_of(listener, popup, new_popup);
        struct wlr_xdg_popup *wlr_popup = data;
-        popup_create(wlr_popup, popup->child.view);
+        popup_create(wlr_popup, popup->view, popup->xdg_surface_tree);
 }
 static void popup_handle_destroy(struct wl_listener *listener, void *data) {
        struct sway_xdg_popup *popup = wl_container_of(listener, popup, destroy);
-        view_child_destroy(&popup->child);
+        wl_list_remove(&popup->new_popup.link);
+        wl_list_remove(&popup->destroy.link);
+        wl_list_remove(&popup->surface_commit.link);
+        wl_list_remove(&popup->reposition.link);
+        wlr_scene_node_destroy(&popup->scene_tree->node);
+        free(popup);
 }
 static void popup_unconstrain(struct sway_xdg_popup *popup) {
-        struct sway_view *view = popup->child.view;
+        struct sway_view *view = popup->view;
-        struct wlr_xdg_popup *wlr_popup = popup->wlr_xdg_surface->popup;
+        struct wlr_xdg_popup *wlr_popup = popup->wlr_xdg_popup;
+        struct sway_workspace *workspace = view->container->pending.workspace;
+        if (!workspace) {
+                // is null if in the scratchpad
+                return;
+        }
-        struct sway_output *output = view->container->pending.workspace->output;
+        struct sway_output *output = workspace->output;
        // the output box expressed in the coordinate system of the toplevel parent
        // of the popup
        struct wlr_box output_toplevel_sx_box = {
-                .x = output->lx - view->container->pending.content_x,
+                .x = output->lx - view->container->pending.content_x + view->geometry.x,
-                .y = output->ly - view->container->pending.content_y,
+                .y = output->ly - view->container->pending.content_y + view->geometry.y,
                .width = output->width,
                .height = output->height,
        };
@@ -84,32 +64,72 @@ static void popup_unconstrain(struct sway_xdg_popup *popup) {
        wlr_xdg_popup_unconstrain_from_box(wlr_popup, &output_toplevel_sx_box);
 }
-static struct sway_xdg_popup *popup_create(
+static void popup_handle_surface_commit(struct wl_listener *listener, void *data) {
-                struct wlr_xdg_popup *wlr_popup, struct sway_view *view) {
+        struct sway_xdg_popup *popup = wl_container_of(listener, popup, surface_commit);
+        if (popup->wlr_xdg_popup->base->initial_commit) {
+                popup_unconstrain(popup);
+        }
+}
+static void popup_handle_reposition(struct wl_listener *listener, void *data) {
+        struct sway_xdg_popup *popup = wl_container_of(listener, popup, reposition);
+        popup_unconstrain(popup);
+}
+static struct sway_xdg_popup *popup_create(struct wlr_xdg_popup *wlr_popup,
+                struct sway_view *view, struct wlr_scene_tree *parent) {
        struct wlr_xdg_surface *xdg_surface = wlr_popup->base;
-        struct sway_xdg_popup *popup =
+        struct sway_xdg_popup *popup = calloc(1, sizeof(struct sway_xdg_popup));
-                calloc(1, sizeof(struct sway_xdg_popup));
+        if (!popup) {
-        if (popup == NULL) {
+                return NULL;
+        }
+        popup->wlr_xdg_popup = wlr_popup;
+        popup->view = view;
+        popup->scene_tree = wlr_scene_tree_create(parent);
+        if (!popup->scene_tree) {
+                free(popup);
+                return NULL;
+        }
+        popup->xdg_surface_tree = wlr_scene_xdg_surface_create(
+                popup->scene_tree, xdg_surface);
+        if (!popup->xdg_surface_tree) {
+                wlr_scene_node_destroy(&popup->scene_tree->node);
+                free(popup);
                return NULL;
        }
-        view_child_init(&popup->child, &popup_impl, view, xdg_surface->surface);
-        popup->wlr_xdg_surface = xdg_surface;
+        popup->desc.relative = &view->content_tree->node;
+        popup->desc.view = view;
+        if (!scene_descriptor_assign(&popup->scene_tree->node,
+                        SWAY_SCENE_DESC_POPUP, &popup->desc)) {
+                sway_log(SWAY_ERROR, "Failed to allocate a popup scene descriptor");
+                wlr_scene_node_destroy(&popup->scene_tree->node);
+                free(popup);
+                return NULL;
+        }
+        popup->wlr_xdg_popup = xdg_surface->popup;
+        struct sway_xdg_shell_view *shell_view =
+                wl_container_of(view, shell_view, view);
+        xdg_surface->data = shell_view;
+        wl_signal_add(&xdg_surface->surface->events.commit, &popup->surface_commit);
+        popup->surface_commit.notify = popup_handle_surface_commit;
        wl_signal_add(&xdg_surface->events.new_popup, &popup->new_popup);
        popup->new_popup.notify = popup_handle_new_popup;
-        wl_signal_add(&xdg_surface->events.destroy, &popup->destroy);
+        wl_signal_add(&wlr_popup->events.reposition, &popup->reposition);
+        popup->reposition.notify = popup_handle_reposition;
+        wl_signal_add(&wlr_popup->events.destroy, &popup->destroy);
        popup->destroy.notify = popup_handle_destroy;
-        wl_signal_add(&xdg_surface->events.map, &popup->child.surface_map);
-        wl_signal_add(&xdg_surface->events.unmap, &popup->child.surface_unmap);
-        popup_unconstrain(popup);
        return popup;
 }
 static struct sway_xdg_shell_view *xdg_shell_view_from_view(
                struct sway_view *view) {
        if (!sway_assert(view->type == SWAY_VIEW_XDG_SHELL,
@@ -122,7 +142,7 @@ static struct sway_xdg_shell_view *xdg_shell_view_from_view(
 static void get_constraints(struct sway_view *view, double *min_width,
                double *max_width, double *min_height, double *max_height) {
        struct wlr_xdg_toplevel_state *state =
-                &view->wlr_xdg_surface->toplevel->current;
+                &view->wlr_xdg_toplevel->current;
        *min_width = state->min_width > 0 ? state->min_width : DBL_MIN;
        *max_width = state->max_width > 0 ? state->max_width : DBL_MAX;
        *min_height = state->min_height > 0 ? state->min_height : DBL_MIN;
@@ -136,9 +156,9 @@ static const char *get_string_prop(struct sway_view *view,
        }
        switch (prop) {
        case VIEW_PROP_TITLE:
-                return view->wlr_xdg_surface->toplevel->title;
+                return view->wlr_xdg_toplevel->title;
        case VIEW_PROP_APP_ID:
-                return view->wlr_xdg_surface->toplevel->app_id;
+                return view->wlr_xdg_toplevel->app_id;
        default:
                return NULL;
        }
@@ -151,50 +171,52 @@ static uint32_t configure(struct sway_view *view, double lx, double ly,
        if (xdg_shell_view == NULL) {
                return 0;
        }
-        return wlr_xdg_toplevel_set_size(view->wlr_xdg_surface, width, height);
+        return wlr_xdg_toplevel_set_size(view->wlr_xdg_toplevel,
+                width, height);
 }
 static void set_activated(struct sway_view *view, bool activated) {
        if (xdg_shell_view_from_view(view) == NULL) {
                return;
        }
-        struct wlr_xdg_surface *surface = view->wlr_xdg_surface;
+        wlr_xdg_toplevel_set_activated(view->wlr_xdg_toplevel, activated);
-        if (surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
-                wlr_xdg_toplevel_set_activated(surface, activated);
-        }
 }
 static void set_tiled(struct sway_view *view, bool tiled) {
        if (xdg_shell_view_from_view(view) == NULL) {
                return;
        }
-        struct wlr_xdg_surface *surface = view->wlr_xdg_surface;
+        if (wl_resource_get_version(view->wlr_xdg_toplevel->resource) >=
-        enum wlr_edges edges = WLR_EDGE_NONE;
+                        XDG_TOPLEVEL_STATE_TILED_LEFT_SINCE_VERSION) {
-        if (tiled) {
+                enum wlr_edges edges = WLR_EDGE_NONE;
-                edges = WLR_EDGE_LEFT | WLR_EDGE_RIGHT | WLR_EDGE_TOP |
+                if (tiled) {
-                                WLR_EDGE_BOTTOM;
+                        edges = WLR_EDGE_LEFT | WLR_EDGE_RIGHT | WLR_EDGE_TOP |
+                                        WLR_EDGE_BOTTOM;
+                }
+                wlr_xdg_toplevel_set_tiled(view->wlr_xdg_toplevel, edges);
+        } else {
+                // The version is too low for the tiled state; configure as maximized instead
+                // to stop the client from drawing decorations outside of the toplevel geometry.
+                wlr_xdg_toplevel_set_maximized(view->wlr_xdg_toplevel, tiled);
        }
-        wlr_xdg_toplevel_set_tiled(surface, edges);
 }
 static void set_fullscreen(struct sway_view *view, bool fullscreen) {
        if (xdg_shell_view_from_view(view) == NULL) {
                return;
        }
-        struct wlr_xdg_surface *surface = view->wlr_xdg_surface;
+        wlr_xdg_toplevel_set_fullscreen(view->wlr_xdg_toplevel, fullscreen);
-        wlr_xdg_toplevel_set_fullscreen(surface, fullscreen);
 }
 static void set_resizing(struct sway_view *view, bool resizing) {
        if (xdg_shell_view_from_view(view) == NULL) {
                return;
        }
-        struct wlr_xdg_surface *surface = view->wlr_xdg_surface;
+        wlr_xdg_toplevel_set_resizing(view->wlr_xdg_toplevel, resizing);
-        wlr_xdg_toplevel_set_resizing(surface, resizing);
 }
 static bool wants_floating(struct sway_view *view) {
-        struct wlr_xdg_toplevel *toplevel = view->wlr_xdg_surface->toplevel;
+        struct wlr_xdg_toplevel *toplevel = view->wlr_xdg_toplevel;
        struct wlr_xdg_toplevel_state *state = &toplevel->current;
        return (state->min_width != 0 && state->min_height != 0
                && (state->min_width == state->max_width
@@ -202,35 +224,17 @@ static bool wants_floating(struct sway_view *view) {
                || toplevel->parent;
 }
-static void for_each_surface(struct sway_view *view,
-                wlr_surface_iterator_func_t iterator, void *user_data) {
-        if (xdg_shell_view_from_view(view) == NULL) {
-                return;
-        }
-        wlr_xdg_surface_for_each_surface(view->wlr_xdg_surface, iterator,
-                user_data);
-}
-static void for_each_popup_surface(struct sway_view *view,
-                wlr_surface_iterator_func_t iterator, void *user_data) {
-        if (xdg_shell_view_from_view(view) == NULL) {
-                return;
-        }
-        wlr_xdg_surface_for_each_popup_surface(view->wlr_xdg_surface, iterator,
-                user_data);
-}
 static bool is_transient_for(struct sway_view *child,
                struct sway_view *ancestor) {
        if (xdg_shell_view_from_view(child) == NULL) {
                return false;
        }
-        struct wlr_xdg_surface *surface = child->wlr_xdg_surface;
+        struct wlr_xdg_toplevel *toplevel = child->wlr_xdg_toplevel;
-        while (surface && surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
+        while (toplevel) {
-                if (surface->toplevel->parent == ancestor->wlr_xdg_surface) {
+                if (toplevel->parent == ancestor->wlr_xdg_toplevel) {
                        return true;
                }
-                surface = surface->toplevel->parent;
+                toplevel = toplevel->parent;
        }
        return false;
 }
@@ -239,17 +243,13 @@ static void _close(struct sway_view *view) {
        if (xdg_shell_view_from_view(view) == NULL) {
                return;
        }
-        struct wlr_xdg_surface *surface = view->wlr_xdg_surface;
+        wlr_xdg_toplevel_send_close(view->wlr_xdg_toplevel);
-        if (surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL
-                        && surface->toplevel) {
-                wlr_xdg_toplevel_send_close(surface);
-        }
 }
 static void close_popups(struct sway_view *view) {
        struct wlr_xdg_popup *popup, *tmp;
-        wl_list_for_each_safe(popup, tmp, &view->wlr_xdg_surface->popups, link) {
+        wl_list_for_each_safe(popup, tmp, &view->wlr_xdg_toplevel->base->popups, link) {
-                wlr_xdg_popup_destroy(popup->base);
+                wlr_xdg_popup_destroy(popup);
        }
 }
@@ -271,8 +271,6 @@ static const struct sway_view_impl view_impl = {
        .set_fullscreen = set_fullscreen,
        .set_resizing = set_resizing,
        .wants_floating = wants_floating,
-        .for_each_surface = for_each_surface,
-        .for_each_popup_surface = for_each_popup_surface,
        .is_transient_for = is_transient_for,
        .close = _close,
        .close_popups = close_popups,
@@ -283,7 +281,21 @@ static void handle_commit(struct wl_listener *listener, void *data) {
        struct sway_xdg_shell_view *xdg_shell_view =
                wl_container_of(listener, xdg_shell_view, commit);
        struct sway_view *view = &xdg_shell_view->view;
-        struct wlr_xdg_surface *xdg_surface = view->wlr_xdg_surface;
+        struct wlr_xdg_surface *xdg_surface = view->wlr_xdg_toplevel->base;
+        if (xdg_surface->initial_commit) {
+                if (view->xdg_decoration != NULL) {
+                        set_xdg_decoration_mode(view->xdg_decoration);
+                }
+                // XXX: https://github.com/swaywm/sway/issues/2176
+                wlr_xdg_surface_schedule_configure(xdg_surface);
+                // TODO: wlr_xdg_toplevel_set_bounds()
+                return;
+        }
+        if (!xdg_surface->surface->mapped) {
+                return;
+        }
        struct wlr_box new_geo;
        wlr_xdg_surface_get_geometry(xdg_surface, &new_geo);
@@ -296,23 +308,32 @@ static void handle_commit(struct wl_listener *listener, void *data) {
                // The client changed its surface size in this commit. For floating
                // containers, we resize the container to match. For tiling containers,
                // we only recenter the surface.
-                desktop_damage_view(view);
                memcpy(&view->geometry, &new_geo, sizeof(struct wlr_box));
                if (container_is_floating(view->container)) {
                        view_update_size(view);
+                        // Only set the toplevel size the current container actually has a size.
+                        if (view->container->current.width) {
+                                wlr_xdg_toplevel_set_size(view->wlr_xdg_toplevel, view->geometry.width,
+                                        view->geometry.height);
+                        }
                        transaction_commit_dirty_client();
-                } else {
-                        view_center_surface(view);
                }
-                desktop_damage_view(view);
+                view_center_and_clip_surface(view);
        }
        if (view->container->node.instruction) {
-                transaction_notify_view_ready_by_serial(view,
+                bool successful = transaction_notify_view_ready_by_serial(view,
-                                xdg_surface->configure_serial);
+                                xdg_surface->current.configure_serial);
+                // If we saved the view and this commit isn't what we're looking for
+                // that means the user will never actually see the buffers submitted to
+                // us here. Just send frame done events to these surfaces so they can
+                // commit another time for us.
+                if (view->saved_surface_tree && !successful) {
+                        view_send_frame_done(view);
+                }
        }
-        view_damage_from(view);
 }
 static void handle_set_title(struct wl_listener *listener, void *data) {
@@ -327,6 +348,7 @@ static void handle_set_app_id(struct wl_listener *listener, void *data) {
        struct sway_xdg_shell_view *xdg_shell_view =
                wl_container_of(listener, xdg_shell_view, set_app_id);
        struct sway_view *view = &xdg_shell_view->view;
+        view_update_app_id(view);
        view_execute_criteria(view);
 }
@@ -334,29 +356,39 @@ static void handle_new_popup(struct wl_listener *listener, void *data) {
        struct sway_xdg_shell_view *xdg_shell_view =
                wl_container_of(listener, xdg_shell_view, new_popup);
        struct wlr_xdg_popup *wlr_popup = data;
-        popup_create(wlr_popup, &xdg_shell_view->view);
+        struct sway_xdg_popup *popup = popup_create(wlr_popup,
+                &xdg_shell_view->view, root->layers.popup);
+        if (!popup) {
+                return;
+        }
+        int lx, ly;
+        wlr_scene_node_coords(&popup->view->content_tree->node, &lx, &ly);
+        wlr_scene_node_set_position(&popup->scene_tree->node, lx, ly);
+}
+static void handle_request_maximize(struct wl_listener *listener, void *data) {
+        struct sway_xdg_shell_view *xdg_shell_view =
+                wl_container_of(listener, xdg_shell_view, request_maximize);
+        struct wlr_xdg_toplevel *toplevel = xdg_shell_view->view.wlr_xdg_toplevel;
+        wlr_xdg_surface_schedule_configure(toplevel->base);
 }
 static void handle_request_fullscreen(struct wl_listener *listener, void *data) {
        struct sway_xdg_shell_view *xdg_shell_view =
                wl_container_of(listener, xdg_shell_view, request_fullscreen);
-        struct wlr_xdg_toplevel_set_fullscreen_event *e = data;
+        struct wlr_xdg_toplevel *toplevel = xdg_shell_view->view.wlr_xdg_toplevel;
-        struct wlr_xdg_surface *xdg_surface =
-                xdg_shell_view->view.wlr_xdg_surface;
        struct sway_view *view = &xdg_shell_view->view;
-        if (!sway_assert(xdg_surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL,
+        if (!toplevel->base->surface->mapped) {
-                                "xdg_shell requested fullscreen of surface with role %i",
-                                xdg_surface->role)) {
-                return;
-        }
-        if (!xdg_surface->mapped) {
                return;
        }
        struct sway_container *container = view->container;
-        if (e->fullscreen && e->output && e->output->data) {
+        struct wlr_xdg_toplevel_requested *req = &toplevel->requested;
-                struct sway_output *output = e->output->data;
+        if (req->fullscreen && req->fullscreen_output && req->fullscreen_output->data) {
+                struct sway_output *output = req->fullscreen_output->data;
                struct sway_workspace *ws = output_get_active_workspace(output);
                if (ws && !container_is_scratchpad_hidden(container) &&
                                container->pending.workspace != ws) {
@@ -368,22 +400,18 @@ static void handle_request_fullscreen(struct wl_listener *listener, void *data)
                }
        }
-        container_set_fullscreen(container, e->fullscreen);
+        container_set_fullscreen(container, req->fullscreen);
        arrange_root();
        transaction_commit_dirty();
 }
-static void handle_request_maximize(struct wl_listener *listener, void *data) {
-        struct wlr_xdg_surface *surface = data;
-        wlr_xdg_surface_schedule_configure(surface);
-}
 static void handle_request_move(struct wl_listener *listener, void *data) {
        struct sway_xdg_shell_view *xdg_shell_view =
                wl_container_of(listener, xdg_shell_view, request_move);
        struct sway_view *view = &xdg_shell_view->view;
-        if (!container_is_floating(view->container)) {
+        if (!container_is_floating(view->container) ||
+                        view->container->pending.fullscreen_mode) {
                return;
        }
        struct wlr_xdg_toplevel_move_event *e = data;
@@ -418,10 +446,9 @@ static void handle_unmap(struct wl_listener *listener, void *data) {
        view_unmap(view);
-        wl_list_remove(&xdg_shell_view->commit.link);
        wl_list_remove(&xdg_shell_view->new_popup.link);
-        wl_list_remove(&xdg_shell_view->request_fullscreen.link);
        wl_list_remove(&xdg_shell_view->request_maximize.link);
+        wl_list_remove(&xdg_shell_view->request_fullscreen.link);
        wl_list_remove(&xdg_shell_view->request_move.link);
        wl_list_remove(&xdg_shell_view->request_resize.link);
        wl_list_remove(&xdg_shell_view->set_title.link);
@@ -432,62 +459,61 @@ static void handle_map(struct wl_listener *listener, void *data) {
        struct sway_xdg_shell_view *xdg_shell_view =
                wl_container_of(listener, xdg_shell_view, map);
        struct sway_view *view = &xdg_shell_view->view;
-        struct wlr_xdg_surface *xdg_surface = view->wlr_xdg_surface;
+        struct wlr_xdg_toplevel *toplevel = view->wlr_xdg_toplevel;
-        view->natural_width = view->wlr_xdg_surface->geometry.width;
+        view->natural_width = toplevel->base->current.geometry.width;
-        view->natural_height = view->wlr_xdg_surface->geometry.height;
+        view->natural_height = toplevel->base->current.geometry.height;
        if (!view->natural_width && !view->natural_height) {
-                view->natural_width = view->wlr_xdg_surface->surface->current.width;
+                view->natural_width = toplevel->base->surface->current.width;
-                view->natural_height = view->wlr_xdg_surface->surface->current.height;
+                view->natural_height = toplevel->base->surface->current.height;
        }
        bool csd = false;
-        if (!view->xdg_decoration) {
+        if (view->xdg_decoration) {
+                enum wlr_xdg_toplevel_decoration_v1_mode mode =
+                        view->xdg_decoration->wlr_xdg_decoration->requested_mode;
+                csd = mode == WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE;
+        } else {
                struct sway_server_decoration *deco =
-                                decoration_from_surface(xdg_surface->surface);
+                                decoration_from_surface(toplevel->base->surface);
                csd = !deco || deco->wlr_server_decoration->mode ==
                        WLR_SERVER_DECORATION_MANAGER_MODE_CLIENT;
        }
-        view_map(view, view->wlr_xdg_surface->surface,
+        view_map(view, toplevel->base->surface,
-                xdg_surface->toplevel->client_pending.fullscreen,
+                toplevel->requested.fullscreen,
-                xdg_surface->toplevel->client_pending.fullscreen_output,
+                toplevel->requested.fullscreen_output,
                csd);
        transaction_commit_dirty();
-        xdg_shell_view->commit.notify = handle_commit;
-        wl_signal_add(&xdg_surface->surface->events.commit,
-                &xdg_shell_view->commit);
        xdg_shell_view->new_popup.notify = handle_new_popup;
-        wl_signal_add(&xdg_surface->events.new_popup,
+        wl_signal_add(&toplevel->base->events.new_popup,
                &xdg_shell_view->new_popup);
-        xdg_shell_view->request_fullscreen.notify = handle_request_fullscreen;
-        wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen,
-                        &xdg_shell_view->request_fullscreen);
        xdg_shell_view->request_maximize.notify = handle_request_maximize;
-        wl_signal_add(&xdg_surface->toplevel->events.request_maximize,
+        wl_signal_add(&toplevel->events.request_maximize,
                        &xdg_shell_view->request_maximize);
+        xdg_shell_view->request_fullscreen.notify = handle_request_fullscreen;
+        wl_signal_add(&toplevel->events.request_fullscreen,
+                        &xdg_shell_view->request_fullscreen);
        xdg_shell_view->request_move.notify = handle_request_move;
-        wl_signal_add(&xdg_surface->toplevel->events.request_move,
+        wl_signal_add(&toplevel->events.request_move,
                        &xdg_shell_view->request_move);
        xdg_shell_view->request_resize.notify = handle_request_resize;
-        wl_signal_add(&xdg_surface->toplevel->events.request_resize,
+        wl_signal_add(&toplevel->events.request_resize,
                        &xdg_shell_view->request_resize);
        xdg_shell_view->set_title.notify = handle_set_title;
-        wl_signal_add(&xdg_surface->toplevel->events.set_title,
+        wl_signal_add(&toplevel->events.set_title,
                        &xdg_shell_view->set_title);
        xdg_shell_view->set_app_id.notify = handle_set_app_id;
-        wl_signal_add(&xdg_surface->toplevel->events.set_app_id,
+        wl_signal_add(&toplevel->events.set_app_id,
                        &xdg_shell_view->set_app_id);
 }
@@ -501,7 +527,8 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
        wl_list_remove(&xdg_shell_view->destroy.link);
        wl_list_remove(&xdg_shell_view->map.link);
        wl_list_remove(&xdg_shell_view->unmap.link);
-        view->wlr_xdg_surface = NULL;
+        wl_list_remove(&xdg_shell_view->commit.link);
+        view->wlr_xdg_toplevel = NULL;
        if (view->xdg_decoration) {
                view->xdg_decoration->view = NULL;
        }
@@ -513,17 +540,12 @@ struct sway_view *view_from_wlr_xdg_surface(
        return xdg_surface->data;
 }
-void handle_xdg_shell_surface(struct wl_listener *listener, void *data) {
+void handle_xdg_shell_toplevel(struct wl_listener *listener, void *data) {
-        struct wlr_xdg_surface *xdg_surface = data;
+        struct wlr_xdg_toplevel *xdg_toplevel = data;
-        if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP) {
-                sway_log(SWAY_DEBUG, "New xdg_shell popup");
-                return;
-        }
        sway_log(SWAY_DEBUG, "New xdg_shell toplevel title='%s' app_id='%s'",
-                xdg_surface->toplevel->title, xdg_surface->toplevel->app_id);
+                xdg_toplevel->title, xdg_toplevel->app_id);
-        wlr_xdg_surface_ping(xdg_surface);
+        wlr_xdg_surface_ping(xdg_toplevel->base);
        struct sway_xdg_shell_view *xdg_shell_view =
                calloc(1, sizeof(struct sway_xdg_shell_view));
@@ -531,17 +553,29 @@ void handle_xdg_shell_surface(struct wl_listener *listener, void *data) {
                return;
        }
-        view_init(&xdg_shell_view->view, SWAY_VIEW_XDG_SHELL, &view_impl);
+        if (!view_init(&xdg_shell_view->view, SWAY_VIEW_XDG_SHELL, &view_impl)) {
-        xdg_shell_view->view.wlr_xdg_surface = xdg_surface;
+                free(xdg_shell_view);
+                return;
+        }
+        xdg_shell_view->view.wlr_xdg_toplevel = xdg_toplevel;
        xdg_shell_view->map.notify = handle_map;
-        wl_signal_add(&xdg_surface->events.map, &xdg_shell_view->map);
+        wl_signal_add(&xdg_toplevel->base->surface->events.map, &xdg_shell_view->map);
        xdg_shell_view->unmap.notify = handle_unmap;
-        wl_signal_add(&xdg_surface->events.unmap, &xdg_shell_view->unmap);
+        wl_signal_add(&xdg_toplevel->base->surface->events.unmap, &xdg_shell_view->unmap);
+        xdg_shell_view->commit.notify = handle_commit;
+        wl_signal_add(&xdg_toplevel->base->surface->events.commit,
+                &xdg_shell_view->commit);
        xdg_shell_view->destroy.notify = handle_destroy;
-        wl_signal_add(&xdg_surface->events.destroy, &xdg_shell_view->destroy);
+        wl_signal_add(&xdg_toplevel->events.destroy, &xdg_shell_view->destroy);
+        wlr_scene_xdg_surface_create(xdg_shell_view->view.content_tree, xdg_toplevel->base);
+        xdg_toplevel->base->data = xdg_shell_view;
-        xdg_surface->data = xdg_shell_view;
+        wlr_xdg_toplevel_set_wm_capabilities(xdg_toplevel,
+                XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN);
 }
diff --git a/sway/desktop/xwayland.c b/sway/desktop/xwayland.c
index 66cb3b02..270cf08f 100644
--- a/sway/desktop/xwayland.c
+++ b/sway/desktop/xwayland.c
@@ -1,20 +1,23 @@
-#define _POSIX_C_SOURCE 199309L
 #include <float.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <wayland-server-core.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_output.h>
+#include <wlr/types/wlr_xdg_activation_v1.h>
+#include <wlr/types/wlr_scene.h>
 #include <wlr/xwayland.h>
+#include <xcb/xcb_icccm.h>
 #include "log.h"
-#include "sway/desktop.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/seat.h"
 #include "sway/output.h"
+#include "sway/scene_descriptor.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/container.h"
+#include "sway/server.h"
 #include "sway/tree/view.h"
 #include "sway/tree/workspace.h"
@@ -42,29 +45,12 @@ static void unmanaged_handle_request_configure(struct wl_listener *listener,
                ev->width, ev->height);
 }
-static void unmanaged_handle_commit(struct wl_listener *listener, void *data) {
-        struct sway_xwayland_unmanaged *surface =
-                wl_container_of(listener, surface, commit);
-        struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
-        desktop_damage_surface(xsurface->surface, surface->lx, surface->ly,
-                false);
-}
 static void unmanaged_handle_set_geometry(struct wl_listener *listener, void *data) {
        struct sway_xwayland_unmanaged *surface =
                wl_container_of(listener, surface, set_geometry);
        struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
-        if (xsurface->x != surface->lx || xsurface->y != surface->ly) {
+        wlr_scene_node_set_position(&surface->surface_scene->buffer->node, xsurface->x, xsurface->y);
-                // Surface has moved
-                desktop_damage_surface(xsurface->surface, surface->lx, surface->ly,
-                        true);
-                surface->lx = xsurface->x;
-                surface->ly = xsurface->y;
-                desktop_damage_surface(xsurface->surface, surface->lx, surface->ly,
-                        true);
-        }
 }
 static void unmanaged_handle_map(struct wl_listener *listener, void *data) {
@@ -72,17 +58,18 @@ static void unmanaged_handle_map(struct wl_listener *listener, void *data) {
                wl_container_of(listener, surface, map);
        struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
-        wl_list_insert(root->xwayland_unmanaged.prev, &surface->link);
+        surface->surface_scene = wlr_scene_surface_create(root->layers.unmanaged,
+                xsurface->surface);
-        wl_signal_add(&xsurface->events.set_geometry, &surface->set_geometry);
-        surface->set_geometry.notify = unmanaged_handle_set_geometry;
-        wl_signal_add(&xsurface->surface->events.commit, &surface->commit);
+        if (surface->surface_scene) {
-        surface->commit.notify = unmanaged_handle_commit;
+                scene_descriptor_assign(&surface->surface_scene->buffer->node,
+                        SWAY_SCENE_DESC_XWAYLAND_UNMANAGED, surface);
+                wlr_scene_node_set_position(&surface->surface_scene->buffer->node,
+                        xsurface->x, xsurface->y);
-        surface->lx = xsurface->x;
+                wl_signal_add(&xsurface->events.set_geometry, &surface->set_geometry);
-        surface->ly = xsurface->y;
+                surface->set_geometry.notify = unmanaged_handle_set_geometry;
-        desktop_damage_surface(xsurface->surface, surface->lx, surface->ly, true);
+        }
        if (wlr_xwayland_or_surface_wants_focus(xsurface)) {
                struct sway_seat *seat = input_manager_current_seat();
@@ -96,10 +83,13 @@ static void unmanaged_handle_unmap(struct wl_listener *listener, void *data) {
        struct sway_xwayland_unmanaged *surface =
                wl_container_of(listener, surface, unmap);
        struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
-        desktop_damage_surface(xsurface->surface, xsurface->x, xsurface->y, true);
-        wl_list_remove(&surface->link);
+        if (surface->surface_scene) {
-        wl_list_remove(&surface->set_geometry.link);
+                wl_list_remove(&surface->set_geometry.link);
-        wl_list_remove(&surface->commit.link);
+                wlr_scene_node_destroy(&surface->surface_scene->buffer->node);
+                surface->surface_scene = NULL;
+        }
        struct sway_seat *seat = input_manager_current_seat();
        if (seat->wlr_seat->keyboard_state.focused_surface == xsurface->surface) {
@@ -121,18 +111,53 @@ static void unmanaged_handle_unmap(struct wl_listener *listener, void *data) {
        }
 }
+static void unmanaged_handle_request_activate(struct wl_listener *listener, void *data) {
+        struct sway_xwayland_unmanaged *surface =
+                wl_container_of(listener, surface, request_activate);
+        struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
+                return;
+        }
+        struct sway_seat *seat = input_manager_current_seat();
+        struct sway_container *focus = seat_get_focused_container(seat);
+        if (focus && focus->view && focus->view->pid != xsurface->pid) {
+                return;
+        }
+        seat_set_focus_surface(seat, xsurface->surface, false);
+}
+static void unmanaged_handle_associate(struct wl_listener *listener, void *data) {
+        struct sway_xwayland_unmanaged *surface =
+                wl_container_of(listener, surface, associate);
+        struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
+        wl_signal_add(&xsurface->surface->events.map, &surface->map);
+        surface->map.notify = unmanaged_handle_map;
+        wl_signal_add(&xsurface->surface->events.unmap, &surface->unmap);
+        surface->unmap.notify = unmanaged_handle_unmap;
+}
+static void unmanaged_handle_dissociate(struct wl_listener *listener, void *data) {
+        struct sway_xwayland_unmanaged *surface =
+                wl_container_of(listener, surface, dissociate);
+        wl_list_remove(&surface->map.link);
+        wl_list_remove(&surface->unmap.link);
+}
 static void unmanaged_handle_destroy(struct wl_listener *listener, void *data) {
        struct sway_xwayland_unmanaged *surface =
                wl_container_of(listener, surface, destroy);
        wl_list_remove(&surface->request_configure.link);
-        wl_list_remove(&surface->map.link);
+        wl_list_remove(&surface->associate.link);
-        wl_list_remove(&surface->unmap.link);
+        wl_list_remove(&surface->dissociate.link);
        wl_list_remove(&surface->destroy.link);
        wl_list_remove(&surface->override_redirect.link);
+        wl_list_remove(&surface->request_activate.link);
        free(surface);
 }
 static void handle_map(struct wl_listener *listener, void *data);
+static void handle_associate(struct wl_listener *listener, void *data);
 struct sway_xwayland_view *create_xwayland_view(struct wlr_xwayland_surface *xsurface);
@@ -141,14 +166,22 @@ static void unmanaged_handle_override_redirect(struct wl_listener *listener, voi
                wl_container_of(listener, surface, override_redirect);
        struct wlr_xwayland_surface *xsurface = surface->wlr_xwayland_surface;
-        bool mapped = xsurface->mapped;
+        bool associated = xsurface->surface != NULL;
+        bool mapped = associated && xsurface->surface->mapped;
        if (mapped) {
                unmanaged_handle_unmap(&surface->unmap, NULL);
        }
+        if (associated) {
+                unmanaged_handle_dissociate(&surface->dissociate, NULL);
+        }
        unmanaged_handle_destroy(&surface->destroy, NULL);
        xsurface->data = NULL;
        struct sway_xwayland_view *xwayland_view = create_xwayland_view(xsurface);
+        if (associated) {
+                handle_associate(&xwayland_view->associate, NULL);
+        }
        if (mapped) {
                handle_map(&xwayland_view->map, xsurface);
        }
@@ -168,14 +201,16 @@ static struct sway_xwayland_unmanaged *create_unmanaged(
        wl_signal_add(&xsurface->events.request_configure,
                &surface->request_configure);
        surface->request_configure.notify = unmanaged_handle_request_configure;
-        wl_signal_add(&xsurface->events.map, &surface->map);
+        wl_signal_add(&xsurface->events.associate, &surface->associate);
-        surface->map.notify = unmanaged_handle_map;
+        surface->associate.notify = unmanaged_handle_associate;
-        wl_signal_add(&xsurface->events.unmap, &surface->unmap);
+        wl_signal_add(&xsurface->events.dissociate, &surface->dissociate);
-        surface->unmap.notify = unmanaged_handle_unmap;
+        surface->dissociate.notify = unmanaged_handle_dissociate;
        wl_signal_add(&xsurface->events.destroy, &surface->destroy);
        surface->destroy.notify = unmanaged_handle_destroy;
        wl_signal_add(&xsurface->events.set_override_redirect, &surface->override_redirect);
        surface->override_redirect.notify = unmanaged_handle_override_redirect;
+        wl_signal_add(&xsurface->events.request_activate, &surface->request_activate);
+        surface->request_activate.notify = unmanaged_handle_request_activate;
        return surface;
 }
@@ -254,6 +289,7 @@ static void set_activated(struct sway_view *view, bool activated) {
        }
        wlr_xwayland_surface_activate(surface, activated);
+        wlr_xwayland_surface_restack(surface, NULL, XCB_STACK_MODE_ABOVE);
 }
 static void set_tiled(struct sway_view *view, bool tiled) {
@@ -293,7 +329,7 @@ static bool wants_floating(struct sway_view *view) {
                }
        }
-        struct wlr_xwayland_surface_size_hints *size_hints = surface->size_hints;
+        xcb_size_hints_t *size_hints = surface->size_hints;
        if (size_hints != NULL &&
                        size_hints->min_width > 0 && size_hints->min_height > 0 &&
                        (size_hints->max_width == size_hints->min_width ||
@@ -347,7 +383,7 @@ static void destroy(struct sway_view *view) {
 static void get_constraints(struct sway_view *view, double *min_width,
                double *max_width, double *min_height, double *max_height) {
        struct wlr_xwayland_surface *surface = view->wlr_xwayland_surface;
-        struct wlr_xwayland_surface_size_hints *size_hints = surface->size_hints;
+        xcb_size_hints_t *size_hints = surface->size_hints;
        if (size_hints == NULL) {
                *min_width = DBL_MIN;
@@ -377,17 +413,6 @@ static const struct sway_view_impl view_impl = {
        .destroy = destroy,
 };
-static void get_geometry(struct sway_view *view, struct wlr_box *box) {
-        box->x = box->y = 0;
-        if (view->surface) {
-                box->width = view->surface->current.width;
-                box->height = view->surface->current.height;
-        } else {
-                box->width = 0;
-                box->height = 0;
-        }
-}
 static void handle_commit(struct wl_listener *listener, void *data) {
        struct sway_xwayland_view *xwayland_view =
                wl_container_of(listener, xwayland_view, commit);
@@ -395,34 +420,38 @@ static void handle_commit(struct wl_listener *listener, void *data) {
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
        struct wlr_surface_state *state = &xsurface->surface->current;
-        struct wlr_box new_geo;
+        struct wlr_box new_geo = {0};
-        get_geometry(view, &new_geo);
+        new_geo.width = state->width;
+        new_geo.height = state->height;
        bool new_size = new_geo.width != view->geometry.width ||
-                        new_geo.height != view->geometry.height ||
+                        new_geo.height != view->geometry.height;
-                        new_geo.x != view->geometry.x ||
-                        new_geo.y != view->geometry.y;
        if (new_size) {
                // The client changed its surface size in this commit. For floating
                // containers, we resize the container to match. For tiling containers,
                // we only recenter the surface.
-                desktop_damage_view(view);
                memcpy(&view->geometry, &new_geo, sizeof(struct wlr_box));
                if (container_is_floating(view->container)) {
                        view_update_size(view);
                        transaction_commit_dirty_client();
-                } else {
-                        view_center_surface(view);
                }
-                desktop_damage_view(view);
+                view_center_and_clip_surface(view);
        }
        if (view->container->node.instruction) {
-                transaction_notify_view_ready_by_geometry(view,
+                bool successful = transaction_notify_view_ready_by_geometry(view,
                                xsurface->x, xsurface->y, state->width, state->height);
-        }
-        view_damage_from(view);
+                // If we saved the view and this commit isn't what we're looking for
+                // that means the user will never actually see the buffers submitted to
+                // us here. Just send frame done events to these surfaces so they can
+                // commit another time for us.
+                if (view->saved_surface_tree && !successful) {
+                        view_send_frame_done(view);
+                }
+        }
 }
 static void handle_destroy(struct wl_listener *listener, void *data) {
@@ -435,6 +464,8 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
                wl_list_remove(&xwayland_view->commit.link);
        }
+        xwayland_view->view.wlr_xwayland_surface = NULL;
        wl_list_remove(&xwayland_view->destroy.link);
        wl_list_remove(&xwayland_view->request_configure.link);
        wl_list_remove(&xwayland_view->request_fullscreen.link);
@@ -445,11 +476,12 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
        wl_list_remove(&xwayland_view->set_title.link);
        wl_list_remove(&xwayland_view->set_class.link);
        wl_list_remove(&xwayland_view->set_role.link);
+        wl_list_remove(&xwayland_view->set_startup_id.link);
        wl_list_remove(&xwayland_view->set_window_type.link);
        wl_list_remove(&xwayland_view->set_hints.link);
        wl_list_remove(&xwayland_view->set_decorations.link);
-        wl_list_remove(&xwayland_view->map.link);
+        wl_list_remove(&xwayland_view->associate.link);
-        wl_list_remove(&xwayland_view->unmap.link);
+        wl_list_remove(&xwayland_view->dissociate.link);
        wl_list_remove(&xwayland_view->override_redirect.link);
        view_begin_destroy(&xwayland_view->view);
 }
@@ -463,16 +495,28 @@ static void handle_unmap(struct wl_listener *listener, void *data) {
                return;
        }
+        wl_list_remove(&xwayland_view->commit.link);
+        wl_list_remove(&xwayland_view->surface_tree_destroy.link);
+        if (xwayland_view->surface_tree) {
+                wlr_scene_node_destroy(&xwayland_view->surface_tree->node);
+                xwayland_view->surface_tree = NULL;
+        }
        view_unmap(view);
+}
-        wl_list_remove(&xwayland_view->commit.link);
+static void handle_surface_tree_destroy(struct wl_listener *listener, void *data) {
+        struct sway_xwayland_view *xwayland_view = wl_container_of(listener, xwayland_view,
+                surface_tree_destroy);
+        xwayland_view->surface_tree = NULL;
 }
 static void handle_map(struct wl_listener *listener, void *data) {
        struct sway_xwayland_view *xwayland_view =
                wl_container_of(listener, xwayland_view, map);
-        struct wlr_xwayland_surface *xsurface = data;
        struct sway_view *view = &xwayland_view->view;
+        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
        view->natural_width = xsurface->width;
        view->natural_height = xsurface->height;
@@ -485,23 +529,42 @@ static void handle_map(struct wl_listener *listener, void *data) {
        // Put it back into the tree
        view_map(view, xsurface->surface, xsurface->fullscreen, NULL, false);
+        xwayland_view->surface_tree = wlr_scene_subsurface_tree_create(
+                xwayland_view->view.content_tree, xsurface->surface);
+        if (xwayland_view->surface_tree) {
+                xwayland_view->surface_tree_destroy.notify = handle_surface_tree_destroy;
+                wl_signal_add(&xwayland_view->surface_tree->node.events.destroy,
+                        &xwayland_view->surface_tree_destroy);
+        }
        transaction_commit_dirty();
 }
+static void handle_dissociate(struct wl_listener *listener, void *data);
 static void handle_override_redirect(struct wl_listener *listener, void *data) {
        struct sway_xwayland_view *xwayland_view =
                wl_container_of(listener, xwayland_view, override_redirect);
-        struct wlr_xwayland_surface *xsurface = data;
        struct sway_view *view = &xwayland_view->view;
+        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        bool mapped = xsurface->mapped;
+        bool associated = xsurface->surface != NULL;
+        bool mapped = associated && xsurface->surface->mapped;
        if (mapped) {
                handle_unmap(&xwayland_view->unmap, NULL);
        }
+        if (associated) {
+                handle_dissociate(&xwayland_view->dissociate, NULL);
+        }
        handle_destroy(&xwayland_view->destroy, view);
        xsurface->data = NULL;
        struct sway_xwayland_unmanaged *unmanaged = create_unmanaged(xsurface);
+        if (associated) {
+                unmanaged_handle_associate(&unmanaged->associate, NULL);
+        }
        if (mapped) {
                unmanaged_handle_map(&unmanaged->map, xsurface);
        }
@@ -513,7 +576,7 @@ static void handle_request_configure(struct wl_listener *listener, void *data) {
        struct wlr_xwayland_surface_configure_event *ev = data;
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                wlr_xwayland_surface_configure(xsurface, ev->x, ev->y,
                        ev->width, ev->height);
                return;
@@ -542,7 +605,7 @@ static void handle_request_fullscreen(struct wl_listener *listener, void *data)
                wl_container_of(listener, xwayland_view, request_fullscreen);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
        container_set_fullscreen(view->container, xsurface->fullscreen);
@@ -556,7 +619,7 @@ static void handle_request_minimize(struct wl_listener *listener, void *data) {
                wl_container_of(listener, xwayland_view, request_minimize);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
@@ -571,10 +634,11 @@ static void handle_request_move(struct wl_listener *listener, void *data) {
                wl_container_of(listener, xwayland_view, request_move);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
-        if (!container_is_floating(view->container)) {
+        if (!container_is_floating(view->container) ||
+                        view->container->pending.fullscreen_mode) {
                return;
        }
        struct sway_seat *seat = input_manager_current_seat();
@@ -586,7 +650,7 @@ static void handle_request_resize(struct wl_listener *listener, void *data) {
                wl_container_of(listener, xwayland_view, request_resize);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
        if (!container_is_floating(view->container)) {
@@ -602,10 +666,10 @@ static void handle_request_activate(struct wl_listener *listener, void *data) {
                wl_container_of(listener, xwayland_view, request_activate);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
-        view_request_activate(view);
+        view_request_activate(view, NULL);
        transaction_commit_dirty();
 }
@@ -615,7 +679,7 @@ static void handle_set_title(struct wl_listener *listener, void *data) {
                wl_container_of(listener, xwayland_view, set_title);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
        view_update_title(view, false);
@@ -627,7 +691,7 @@ static void handle_set_class(struct wl_listener *listener, void *data) {
                wl_container_of(listener, xwayland_view, set_class);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
        view_execute_criteria(view);
@@ -638,18 +702,43 @@ static void handle_set_role(struct wl_listener *listener, void *data) {
                wl_container_of(listener, xwayland_view, set_role);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
        view_execute_criteria(view);
 }
+static void handle_set_startup_id(struct wl_listener *listener, void *data) {
+        struct sway_xwayland_view *xwayland_view =
+                wl_container_of(listener, xwayland_view, set_startup_id);
+        struct sway_view *view = &xwayland_view->view;
+        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
+        if (xsurface->startup_id == NULL) {
+                return;
+        }
+        struct wlr_xdg_activation_token_v1 *token =
+                wlr_xdg_activation_v1_find_token(
+                                server.xdg_activation_v1, xsurface->startup_id);
+        if (token == NULL) {
+                // Tried to activate with an unknown or expired token
+                return;
+        }
+        struct launcher_ctx *ctx = token->data;
+        if (token->data == NULL) {
+                // TODO: support external launchers in X
+                return;
+        }
+        view_assign_ctx(view, ctx);
+}
 static void handle_set_window_type(struct wl_listener *listener, void *data) {
        struct sway_xwayland_view *xwayland_view =
                wl_container_of(listener, xwayland_view, set_window_type);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
        view_execute_criteria(view);
@@ -660,20 +749,39 @@ static void handle_set_hints(struct wl_listener *listener, void *data) {
                wl_container_of(listener, xwayland_view, set_hints);
        struct sway_view *view = &xwayland_view->view;
        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
-        if (!xsurface->mapped) {
+        if (xsurface->surface == NULL || !xsurface->surface->mapped) {
                return;
        }
-        if (!xsurface->hints_urgency && view->urgent_timer) {
+        const bool hints_urgency = xcb_icccm_wm_hints_get_urgency(xsurface->hints);
+        if (!hints_urgency && view->urgent_timer) {
                // The view is in the timeout period. We'll ignore the request to
                // unset urgency so that the view remains urgent until the timer clears
                // it.
                return;
        }
        if (view->allow_request_urgent) {
-                view_set_urgent(view, (bool)xsurface->hints_urgency);
+                view_set_urgent(view, hints_urgency);
        }
 }
+static void handle_associate(struct wl_listener *listener, void *data) {
+        struct sway_xwayland_view *xwayland_view =
+                wl_container_of(listener, xwayland_view, associate);
+        struct wlr_xwayland_surface *xsurface =
+                xwayland_view->view.wlr_xwayland_surface;
+        wl_signal_add(&xsurface->surface->events.unmap, &xwayland_view->unmap);
+        xwayland_view->unmap.notify = handle_unmap;
+        wl_signal_add(&xsurface->surface->events.map, &xwayland_view->map);
+        xwayland_view->map.notify = handle_map;
+}
+static void handle_dissociate(struct wl_listener *listener, void *data) {
+        struct sway_xwayland_view *xwayland_view =
+                wl_container_of(listener, xwayland_view, dissociate);
+        wl_list_remove(&xwayland_view->map.link);
+        wl_list_remove(&xwayland_view->unmap.link);
+}
 struct sway_view *view_from_wlr_xwayland_surface(
                struct wlr_xwayland_surface *xsurface) {
        return xsurface->data;
@@ -689,7 +797,10 @@ struct sway_xwayland_view *create_xwayland_view(struct wlr_xwayland_surface *xsu
                return NULL;
        }
-        view_init(&xwayland_view->view, SWAY_VIEW_XWAYLAND, &view_impl);
+        if (!view_init(&xwayland_view->view, SWAY_VIEW_XWAYLAND, &view_impl)) {
+                free(xwayland_view);
+                return NULL;
+        }
        xwayland_view->view.wlr_xwayland_surface = xsurface;
        wl_signal_add(&xsurface->events.destroy, &xwayland_view->destroy);
@@ -728,6 +839,10 @@ struct sway_xwayland_view *create_xwayland_view(struct wlr_xwayland_surface *xsu
        wl_signal_add(&xsurface->events.set_role, &xwayland_view->set_role);
        xwayland_view->set_role.notify = handle_set_role;
+        wl_signal_add(&xsurface->events.set_startup_id,
+                        &xwayland_view->set_startup_id);
+        xwayland_view->set_startup_id.notify = handle_set_startup_id;
        wl_signal_add(&xsurface->events.set_window_type,
                        &xwayland_view->set_window_type);
        xwayland_view->set_window_type.notify = handle_set_window_type;
@@ -739,11 +854,11 @@ struct sway_xwayland_view *create_xwayland_view(struct wlr_xwayland_surface *xsu
                        &xwayland_view->set_decorations);
        xwayland_view->set_decorations.notify = handle_set_decorations;
-        wl_signal_add(&xsurface->events.unmap, &xwayland_view->unmap);
+        wl_signal_add(&xsurface->events.associate, &xwayland_view->associate);
-        xwayland_view->unmap.notify = handle_unmap;
+        xwayland_view->associate.notify = handle_associate;
-        wl_signal_add(&xsurface->events.map, &xwayland_view->map);
+        wl_signal_add(&xsurface->events.dissociate, &xwayland_view->dissociate);
-        xwayland_view->map.notify = handle_map;
+        xwayland_view->dissociate.notify = handle_dissociate;
        wl_signal_add(&xsurface->events.set_override_redirect,
                        &xwayland_view->override_redirect);
diff --git a/sway/input/cursor.c b/sway/input/cursor.c
index 2fe5b202..0b4a36d9 100644
--- a/sway/input/cursor.c
+++ b/sway/input/cursor.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <math.h>
 #include <libevdev/libevdev.h>
@@ -7,8 +6,9 @@
 #include <time.h>
 #include <strings.h>
 #include <wlr/types/wlr_cursor.h>
-#include <wlr/types/wlr_idle.h>
+#include <wlr/types/wlr_cursor_shape_v1.h>
 #include <wlr/types/wlr_pointer.h>
+#include <wlr/types/wlr_relative_pointer_v1.h>
 #include <wlr/types/wlr_touch.h>
 #include <wlr/types/wlr_tablet_v2.h>
 #include <wlr/types/wlr_tablet_pad.h>
@@ -19,12 +19,12 @@
 #include "log.h"
 #include "util.h"
 #include "sway/commands.h"
-#include "sway/desktop.h"
 #include "sway/input/cursor.h"
 #include "sway/input/keyboard.h"
 #include "sway/input/tablet.h"
 #include "sway/layers.h"
 #include "sway/output.h"
+#include "sway/scene_descriptor.h"
 #include "sway/tree/container.h"
 #include "sway/tree/root.h"
 #include "sway/tree/view.h"
@@ -37,45 +37,6 @@ static uint32_t get_current_time_msec(void) {
        return now.tv_sec * 1000 + now.tv_nsec / 1000000;
 }
-static struct wlr_surface *layer_surface_at(struct sway_output *output,
-                struct wl_list *layer, double ox, double oy, double *sx, double *sy) {
-        struct sway_layer_surface *sway_layer;
-        wl_list_for_each_reverse(sway_layer, layer, link) {
-                double _sx = ox - sway_layer->geo.x;
-                double _sy = oy - sway_layer->geo.y;
-                struct wlr_surface *sub = wlr_layer_surface_v1_surface_at(
-                        sway_layer->layer_surface, _sx, _sy, sx, sy);
-                if (sub) {
-                        return sub;
-                }
-        }
-        return NULL;
-}
-static bool surface_is_xdg_popup(struct wlr_surface *surface) {
-    if (wlr_surface_is_xdg_surface(surface)) {
-        struct wlr_xdg_surface *xdg_surface =
-            wlr_xdg_surface_from_wlr_surface(surface);
-        return xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP;
-    }
-    return false;
-}
-static struct wlr_surface *layer_surface_popup_at(struct sway_output *output,
-                struct wl_list *layer, double ox, double oy, double *sx, double *sy) {
-        struct sway_layer_surface *sway_layer;
-        wl_list_for_each_reverse(sway_layer, layer, link) {
-                double _sx = ox - sway_layer->geo.x;
-                double _sy = oy - sway_layer->geo.y;
-                struct wlr_surface *sub = wlr_layer_surface_v1_surface_at(
-                        sway_layer->layer_surface, _sx, _sy, sx, sy);
-                if (sub && surface_is_xdg_popup(sub)) {
-                        return sub;
-                }
-        }
-        return NULL;
-}
 /**
 * Returns the node at the cursor's position. If there is a surface at that
 * location, it is stored in **surface (it may not be a view).
@@ -83,116 +44,101 @@ static struct wlr_surface *layer_surface_popup_at(struct sway_output *output,
 struct sway_node *node_at_coords(
                struct sway_seat *seat, double lx, double ly,
                struct wlr_surface **surface, double *sx, double *sy) {
-        // check for unmanaged views first
+        struct wlr_scene_node *scene_node = NULL;
-#if HAVE_XWAYLAND
-        struct wl_list *unmanaged = &root->xwayland_unmanaged;
+        struct wlr_scene_node *node;
-        struct sway_xwayland_unmanaged *unmanaged_surface;
+        wl_list_for_each_reverse(node, &root->layer_tree->children, link) {
-        wl_list_for_each_reverse(unmanaged_surface, unmanaged, link) {
+                struct wlr_scene_tree *layer = wlr_scene_tree_from_node(node);
-                struct wlr_xwayland_surface *xsurface =
-                        unmanaged_surface->wlr_xwayland_surface;
+                bool non_interactive = scene_descriptor_try_get(&layer->node,
+                        SWAY_SCENE_DESC_NON_INTERACTIVE);
-                double _sx = lx - unmanaged_surface->lx;
+                if (non_interactive) {
-                double _sy = ly - unmanaged_surface->ly;
+                        continue;
-                if (wlr_surface_point_accepts_input(xsurface->surface, _sx, _sy)) {
+                }
-                        *surface = xsurface->surface;
-                        *sx = _sx;
+                scene_node = wlr_scene_node_at(&layer->node, lx, ly, sx, sy);
-                        *sy = _sy;
+                if (scene_node) {
-                        return NULL;
+                        break;
                }
        }
+        if (scene_node) {
+                // determine what wlr_surface we clicked on
+                if (scene_node->type == WLR_SCENE_NODE_BUFFER) {
+                        struct wlr_scene_buffer *scene_buffer =
+                                wlr_scene_buffer_from_node(scene_node);
+                        struct wlr_scene_surface *scene_surface =
+                                wlr_scene_surface_try_from_buffer(scene_buffer);
+                        if (scene_surface) {
+                                *surface = scene_surface->surface;
+                        }
+                }
+                // determine what container we clicked on
+                struct wlr_scene_node *current = scene_node;
+                while (true) {
+                        struct sway_container *con = scene_descriptor_try_get(current,
+                                SWAY_SCENE_DESC_CONTAINER);
+                        if (!con) {
+                                struct sway_view *view = scene_descriptor_try_get(current,
+                                        SWAY_SCENE_DESC_VIEW);
+                                if (view) {
+                                        con = view->container;
+                                }
+                        }
+                        if (!con) {
+                                struct sway_popup_desc *popup =
+                                        scene_descriptor_try_get(current, SWAY_SCENE_DESC_POPUP);
+                                if (popup && popup->view) {
+                                        con = popup->view->container;
+                                }
+                        }
+                        if (con && (!con->view || con->view->surface)) {
+                                return &con->node;
+                        }
+                        if (scene_descriptor_try_get(current, SWAY_SCENE_DESC_LAYER_SHELL)) {
+                                // We don't want to feed through the current workspace on
+                                // layer shells
+                                return NULL;
+                        }
+#if WLR_HAS_XWAYLAND
+                        if (scene_descriptor_try_get(current, SWAY_SCENE_DESC_XWAYLAND_UNMANAGED)) {
+                                return NULL;
+                        }
 #endif
-        // find the output the cursor is on
+                        if (!current->parent) {
+                                break;
+                        }
+                        current = &current->parent->node;
+                }
+        }
+        // if we aren't on a container, determine what workspace we are on
        struct wlr_output *wlr_output = wlr_output_layout_output_at(
                        root->output_layout, lx, ly);
        if (wlr_output == NULL) {
                return NULL;
        }
        struct sway_output *output = wlr_output->data;
        if (!output || !output->enabled) {
                // output is being destroyed or is being enabled
                return NULL;
        }
-        double ox = lx, oy = ly;
-        wlr_output_layout_output_coords(root->output_layout, wlr_output, &ox, &oy);
-        if (root->fullscreen_global) {
-                // Try fullscreen container
-                struct sway_container *con = tiling_container_at(
-                                &root->fullscreen_global->node, lx, ly, surface, sx, sy);
-                if (con) {
-                        return &con->node;
-                }
-                return NULL;
-        }
-        // find the focused workspace on the output for this seat
        struct sway_workspace *ws = output_get_active_workspace(output);
        if (!ws) {
                return NULL;
        }
-        if ((*surface = layer_surface_at(output,
-                                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
-                                ox, oy, sx, sy))) {
-                return NULL;
-        }
-        if (ws->fullscreen) {
-                // Try transient containers
-                for (int i = 0; i < ws->floating->length; ++i) {
-                        struct sway_container *floater = ws->floating->items[i];
-                        if (container_is_transient_for(floater, ws->fullscreen)) {
-                                struct sway_container *con = tiling_container_at(
-                                                &floater->node, lx, ly, surface, sx, sy);
-                                if (con) {
-                                        return &con->node;
-                                }
-                        }
-                }
-                // Try fullscreen container
-                struct sway_container *con =
-                        tiling_container_at(&ws->fullscreen->node, lx, ly, surface, sx, sy);
-                if (con) {
-                        return &con->node;
-                }
-                return NULL;
-        }
-        if ((*surface = layer_surface_popup_at(output,
-                                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
-                                ox, oy, sx, sy))) {
-                return NULL;
-        }
-        if ((*surface = layer_surface_popup_at(output,
-                                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
-                                ox, oy, sx, sy))) {
-                return NULL;
-        }
-        if ((*surface = layer_surface_popup_at(output,
-                                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
-                                ox, oy, sx, sy))) {
-                return NULL;
-        }
-        if ((*surface = layer_surface_at(output,
-                                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
-                                ox, oy, sx, sy))) {
-                return NULL;
-        }
-        struct sway_container *c;
-        if ((c = container_at(ws, lx, ly, surface, sx, sy))) {
-                return &c->node;
-        }
-        if ((*surface = layer_surface_at(output,
-                                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
-                                ox, oy, sx, sy))) {
-                return NULL;
-        }
-        if ((*surface = layer_surface_at(output,
-                                &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
-                                ox, oy, sx, sy))) {
-                return NULL;
-        }
        return &ws->node;
 }
@@ -218,7 +164,7 @@ void cursor_update_image(struct sway_cursor *cursor,
                // Try a node's resize edge
                enum wlr_edges edge = find_resize_edge(node->sway_container, NULL, cursor);
                if (edge == WLR_EDGE_NONE) {
-                        cursor_set_image(cursor, "left_ptr", NULL);
+                        cursor_set_image(cursor, "default", NULL);
                } else if (container_is_floating(node->sway_container)) {
                        cursor_set_image(cursor, wlr_xcursor_get_resize_name(edge), NULL);
                } else {
@@ -229,12 +175,12 @@ void cursor_update_image(struct sway_cursor *cursor,
                        }
                }
        } else {
-                cursor_set_image(cursor, "left_ptr", NULL);
+                cursor_set_image(cursor, "default", NULL);
        }
 }
 static void cursor_hide(struct sway_cursor *cursor) {
-        wlr_cursor_set_image(cursor->cursor, NULL, 0, 0, 0, 0, 0, 0);
+        wlr_cursor_unset_image(cursor->cursor);
        cursor->hidden = true;
        wlr_seat_pointer_notify_clear_focus(cursor->seat->wlr_seat);
 }
@@ -297,7 +243,7 @@ static enum sway_input_idle_source idle_source_from_device(
                return IDLE_SOURCE_POINTER;
        case WLR_INPUT_DEVICE_TOUCH:
                return IDLE_SOURCE_TOUCH;
-        case WLR_INPUT_DEVICE_TABLET_TOOL:
+        case WLR_INPUT_DEVICE_TABLET:
                return IDLE_SOURCE_TABLET_TOOL;
        case WLR_INPUT_DEVICE_TABLET_PAD:
                return IDLE_SOURCE_TABLET_PAD;
@@ -346,7 +292,7 @@ void cursor_unhide(struct sway_cursor *cursor) {
        wl_event_source_timer_update(cursor->hide_source, cursor_get_timeout(cursor));
 }
-static void pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
+void pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
                struct wlr_input_device *device, double dx, double dy,
                double dx_unaccel, double dy_unaccel) {
        wlr_relative_pointer_manager_v1_send_relative_motion(
@@ -383,33 +329,34 @@ static void pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
 static void handle_pointer_motion_relative(
                struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(listener, cursor, motion);
-        struct wlr_event_pointer_motion *e = data;
+        struct wlr_pointer_motion_event *e = data;
-        cursor_handle_activity_from_device(cursor, e->device);
+        cursor_handle_activity_from_device(cursor, &e->pointer->base);
-        pointer_motion(cursor, e->time_msec, e->device, e->delta_x, e->delta_y,
+        pointer_motion(cursor, e->time_msec, &e->pointer->base, e->delta_x,
-                        e->unaccel_dx, e->unaccel_dy);
+                e->delta_y, e->unaccel_dx, e->unaccel_dy);
 }
 static void handle_pointer_motion_absolute(
                struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor =
                wl_container_of(listener, cursor, motion_absolute);
-        struct wlr_event_pointer_motion_absolute *event = data;
+        struct wlr_pointer_motion_absolute_event *event = data;
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
        double lx, ly;
-        wlr_cursor_absolute_to_layout_coords(cursor->cursor, event->device,
+        wlr_cursor_absolute_to_layout_coords(cursor->cursor, &event->pointer->base,
                        event->x, event->y, &lx, &ly);
        double dx = lx - cursor->cursor->x;
        double dy = ly - cursor->cursor->y;
-        pointer_motion(cursor, event->time_msec, event->device, dx, dy, dx, dy);
+        pointer_motion(cursor, event->time_msec, &event->pointer->base, dx, dy,
+                dx, dy);
 }
 void dispatch_cursor_button(struct sway_cursor *cursor,
                struct wlr_input_device *device, uint32_t time_msec, uint32_t button,
-                enum wlr_button_state state) {
+                enum wl_pointer_button_state state) {
        if (time_msec == 0) {
                time_msec = get_current_time_msec();
        }
@@ -419,9 +366,9 @@ void dispatch_cursor_button(struct sway_cursor *cursor,
 static void handle_pointer_button(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(listener, cursor, button);
-        struct wlr_event_pointer_button *event = data;
+        struct wlr_pointer_button_event *event = data;
-        if (event->state == WLR_BUTTON_PRESSED) {
+        if (event->state == WL_POINTER_BUTTON_STATE_PRESSED) {
                cursor->pressed_button_count++;
        } else {
                if (cursor->pressed_button_count > 0) {
@@ -431,20 +378,20 @@ static void handle_pointer_button(struct wl_listener *listener, void *data) {
                }
        }
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
-        dispatch_cursor_button(cursor, event->device,
+        dispatch_cursor_button(cursor, &event->pointer->base,
                        event->time_msec, event->button, event->state);
 }
 void dispatch_cursor_axis(struct sway_cursor *cursor,
-                struct wlr_event_pointer_axis *event) {
+                struct wlr_pointer_axis_event *event) {
        seatop_pointer_axis(cursor->seat, event);
 }
 static void handle_pointer_axis(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(listener, cursor, axis);
-        struct wlr_event_pointer_axis *event = data;
+        struct wlr_pointer_axis_event *event = data;
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
        dispatch_cursor_axis(cursor, event);
 }
@@ -455,93 +402,76 @@ static void handle_pointer_frame(struct wl_listener *listener, void *data) {
 static void handle_touch_down(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(listener, cursor, touch_down);
-        struct wlr_event_touch_down *event = data;
+        struct wlr_touch_down_event *event = data;
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->touch->base);
        cursor_hide(cursor);
        struct sway_seat *seat = cursor->seat;
-        struct wlr_seat *wlr_seat = seat->wlr_seat;
-        struct wlr_surface *surface = NULL;
        double lx, ly;
-        wlr_cursor_absolute_to_layout_coords(cursor->cursor, event->device,
+        wlr_cursor_absolute_to_layout_coords(cursor->cursor, &event->touch->base,
                        event->x, event->y, &lx, &ly);
-        double sx, sy;
-        struct sway_node *focused_node = node_at_coords(seat, lx, ly, &surface, &sx, &sy);
        seat->touch_id = event->touch_id;
        seat->touch_x = lx;
        seat->touch_y = ly;
-        if (surface && wlr_surface_accepts_touch(wlr_seat, surface)) {
+        seatop_touch_down(seat, event, lx, ly);
-                if (seat_is_input_allowed(seat, surface)) {
+}
-                        wlr_seat_touch_notify_down(wlr_seat, surface, event->time_msec,
-                                        event->touch_id, sx, sy);
-                        if (focused_node) {
+static void handle_touch_up(struct wl_listener *listener, void *data) {
-                            seat_set_focus(seat, focused_node);
+        struct sway_cursor *cursor = wl_container_of(listener, cursor, touch_up);
-                        }
+        struct wlr_touch_up_event *event = data;
+        cursor_handle_activity_from_device(cursor, &event->touch->base);
+        struct sway_seat *seat = cursor->seat;
+        if (cursor->simulating_pointer_from_touch) {
+                if (cursor->pointer_touch_id == cursor->seat->touch_id) {
+                        cursor->pointer_touch_up = true;
+                        dispatch_cursor_button(cursor, &event->touch->base,
+                                event->time_msec, BTN_LEFT, WL_POINTER_BUTTON_STATE_RELEASED);
                }
-        } else if (!cursor->simulating_pointer_from_touch &&
+        } else {
-                        (!surface || seat_is_input_allowed(seat, surface))) {
+                seatop_touch_up(seat, event);
-                // Fallback to cursor simulation.
-                // The pointer_touch_id state is needed, so drags are not aborted when over
-                // a surface supporting touch and multi touch events don't interfere.
-                cursor->simulating_pointer_from_touch = true;
-                cursor->pointer_touch_id = seat->touch_id;
-                double dx, dy;
-                dx = lx - cursor->cursor->x;
-                dy = ly - cursor->cursor->y;
-                pointer_motion(cursor, event->time_msec, event->device, dx, dy, dx, dy);
-                dispatch_cursor_button(cursor, event->device, event->time_msec,
-                                BTN_LEFT, WLR_BUTTON_PRESSED);
        }
 }
-static void handle_touch_up(struct wl_listener *listener, void *data) {
+static void handle_touch_cancel(struct wl_listener *listener, void *data) {
-        struct sway_cursor *cursor = wl_container_of(listener, cursor, touch_up);
+        struct sway_cursor *cursor = wl_container_of(listener, cursor, touch_cancel);
-        struct wlr_event_touch_up *event = data;
+        struct wlr_touch_cancel_event *event = data;
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->touch->base);
-        struct wlr_seat *wlr_seat = cursor->seat->wlr_seat;
+        struct sway_seat *seat = cursor->seat;
        if (cursor->simulating_pointer_from_touch) {
                if (cursor->pointer_touch_id == cursor->seat->touch_id) {
                        cursor->pointer_touch_up = true;
-                        dispatch_cursor_button(cursor, event->device, event->time_msec,
+                        dispatch_cursor_button(cursor, &event->touch->base,
-                                        BTN_LEFT, WLR_BUTTON_RELEASED);
+                                event->time_msec, BTN_LEFT, WL_POINTER_BUTTON_STATE_RELEASED);
                }
        } else {
-                wlr_seat_touch_notify_up(wlr_seat, event->time_msec, event->touch_id);
+                seatop_touch_cancel(seat, event);
        }
 }
 static void handle_touch_motion(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor =
                wl_container_of(listener, cursor, touch_motion);
-        struct wlr_event_touch_motion *event = data;
+        struct wlr_touch_motion_event *event = data;
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->touch->base);
        struct sway_seat *seat = cursor->seat;
-        struct wlr_seat *wlr_seat = seat->wlr_seat;
-        struct wlr_surface *surface = NULL;
        double lx, ly;
-        wlr_cursor_absolute_to_layout_coords(cursor->cursor, event->device,
+        wlr_cursor_absolute_to_layout_coords(cursor->cursor, &event->touch->base,
                        event->x, event->y, &lx, &ly);
-        double sx, sy;
-        node_at_coords(cursor->seat, lx, ly, &surface, &sx, &sy);
        if (seat->touch_id == event->touch_id) {
                seat->touch_x = lx;
                seat->touch_y = ly;
-                struct sway_drag_icon *drag_icon;
+                drag_icons_update_position(seat);
-                wl_list_for_each(drag_icon, &root->drag_icons, link) {
-                        if (drag_icon->seat == seat) {
-                                drag_icon_update_position(drag_icon);
-                        }
-                }
        }
        if (cursor->simulating_pointer_from_touch) {
@@ -549,11 +479,11 @@ static void handle_touch_motion(struct wl_listener *listener, void *data) {
                        double dx, dy;
                        dx = lx - cursor->cursor->x;
                        dy = ly - cursor->cursor->y;
-                        pointer_motion(cursor, event->time_msec, event->device, dx, dy, dx, dy);
+                        pointer_motion(cursor, event->time_msec, &event->touch->base,
+                                dx, dy, dx, dy);
                }
-        } else if (surface) {
+        } else {
-                wlr_seat_touch_notify_motion(wlr_seat, event->time_msec,
+                seatop_touch_motion(seat, event, lx, ly);
-                        event->touch_id, sx, sy);
        }
 }
@@ -588,14 +518,15 @@ static void apply_mapping_from_region(struct wlr_input_device *device,
        double x1 = region->x1, x2 = region->x2;
        double y1 = region->y1, y2 = region->y2;
-        if (region->mm) {
+        if (region->mm && device->type == WLR_INPUT_DEVICE_TABLET) {
-                if (device->width_mm == 0 || device->height_mm == 0) {
+                struct wlr_tablet *tablet = wlr_tablet_from_input_device(device);
+                if (tablet->width_mm == 0 || tablet->height_mm == 0) {
                        return;
                }
-                x1 /= device->width_mm;
+                x1 /= tablet->width_mm;
-                x2 /= device->width_mm;
+                x2 /= tablet->width_mm;
-                y1 /= device->height_mm;
+                y1 /= tablet->height_mm;
-                y2 /= device->height_mm;
+                y2 /= tablet->height_mm;
        }
        *x = apply_mapping_from_coord(x1, x2, *x);
@@ -657,8 +588,8 @@ static void handle_tablet_tool_position(struct sway_cursor *cursor,
 static void handle_tool_axis(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(listener, cursor, tool_axis);
-        struct wlr_event_tablet_tool_axis *event = data;
+        struct wlr_tablet_tool_axis_event *event = data;
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->tablet->base);
        struct sway_tablet_tool *sway_tool = event->tool->data;
        if (!sway_tool) {
@@ -713,8 +644,8 @@ static void handle_tool_axis(struct wl_listener *listener, void *data) {
 static void handle_tool_tip(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(listener, cursor, tool_tip);
-        struct wlr_event_tablet_tool_tip *event = data;
+        struct wlr_tablet_tool_tip_event *event = data;
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->tablet->base);
        struct sway_tablet_tool *sway_tool = event->tool->data;
        struct wlr_tablet_v2_tablet *tablet_v2 = sway_tool->tablet->tablet_v2;
@@ -729,8 +660,8 @@ static void handle_tool_tip(struct wl_listener *listener, void *data) {
        if (cursor->simulating_pointer_from_tool_tip &&
                        event->state == WLR_TABLET_TOOL_TIP_UP) {
                cursor->simulating_pointer_from_tool_tip = false;
-                dispatch_cursor_button(cursor, event->device, event->time_msec,
+                dispatch_cursor_button(cursor, &event->tablet->base, event->time_msec,
-                        BTN_LEFT, WLR_BUTTON_RELEASED);
+                        BTN_LEFT, WL_POINTER_BUTTON_STATE_RELEASED);
                wlr_seat_pointer_notify_frame(cursor->seat->wlr_seat);
        } else if (!surface || !wlr_surface_accepts_tablet_v2(tablet_v2, surface)) {
                // If we started holding the tool tip down on a surface that accepts
@@ -741,8 +672,8 @@ static void handle_tool_tip(struct wl_listener *listener, void *data) {
                                WLR_TABLET_TOOL_TIP_UP);
                } else {
                        cursor->simulating_pointer_from_tool_tip = true;
-                        dispatch_cursor_button(cursor, event->device, event->time_msec,
+                        dispatch_cursor_button(cursor, &event->tablet->base,
-                                BTN_LEFT, WLR_BUTTON_PRESSED);
+                                event->time_msec, BTN_LEFT, WL_POINTER_BUTTON_STATE_PRESSED);
                        wlr_seat_pointer_notify_frame(cursor->seat->wlr_seat);
                }
        } else {
@@ -764,12 +695,13 @@ static struct sway_tablet *get_tablet_for_device(struct sway_cursor *cursor,
 static void handle_tool_proximity(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor =
                wl_container_of(listener, cursor, tool_proximity);
-        struct wlr_event_tablet_tool_proximity *event = data;
+        struct wlr_tablet_tool_proximity_event *event = data;
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->tablet->base);
        struct wlr_tablet_tool *tool = event->tool;
        if (!tool->data) {
-                struct sway_tablet *tablet = get_tablet_for_device(cursor, event->device);
+                struct sway_tablet *tablet = get_tablet_for_device(cursor,
+                        &event->tablet->base);
                if (!tablet) {
                        sway_log(SWAY_ERROR, "no tablet for tablet tool");
                        return;
@@ -794,8 +726,8 @@ static void handle_tool_proximity(struct wl_listener *listener, void *data) {
 static void handle_tool_button(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(listener, cursor, tool_button);
-        struct wlr_event_tablet_tool_button *event = data;
+        struct wlr_tablet_tool_button_event *event = data;
-        cursor_handle_activity_from_device(cursor, event->device);
+        cursor_handle_activity_from_device(cursor, &event->tablet->base);
        struct sway_tablet_tool *sway_tool = event->tool->data;
        if (!sway_tool) {
@@ -810,31 +742,71 @@ static void handle_tool_button(struct wl_listener *listener, void *data) {
        node_at_coords(cursor->seat, cursor->cursor->x, cursor->cursor->y,
                &surface, &sx, &sy);
-        if (!surface || !wlr_surface_accepts_tablet_v2(tablet_v2, surface)) {
+        // TODO: floating resize should support graphics tablet events
+        struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(cursor->seat->wlr_seat);
+        uint32_t modifiers = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;
+        bool mod_pressed = modifiers & config->floating_mod;
+        bool surface_supports_tablet_events =
+                surface && wlr_surface_accepts_tablet_v2(tablet_v2, surface);
+        // Simulate pointer when:
+        // 1. The modifier key is pressed, OR
+        // 2. The surface under the cursor does not support tablet events.
+        bool should_simulate_pointer = mod_pressed || !surface_supports_tablet_events;
+        // Similar to tool tip, we need to selectively simulate mouse events, but we
+        // want to make sure that it is always consistent. Because all tool buttons
+        // currently map to BTN_RIGHT, we need to keep count of how many tool
+        // buttons are currently pressed down so we can send consistent events.
+        //
+        // The logic follows:
+        // - If we are already simulating the pointer, we should continue to do so
+        //   until at least no tool button is held down.
+        // - If we should simulate the pointer and no tool button is currently held
+        //   down, begin simulating the pointer.
+        // - If neither of the above are true, send the tablet events.
+        if ((cursor->tool_buttons > 0 && cursor->simulating_pointer_from_tool_button)
+                || (cursor->tool_buttons == 0 && should_simulate_pointer)) {
+                cursor->simulating_pointer_from_tool_button = true;
                // TODO: the user may want to configure which tool buttons are mapped to
                // which simulated pointer buttons
                switch (event->state) {
                case WLR_BUTTON_PRESSED:
                        if (cursor->tool_buttons == 0) {
-                                dispatch_cursor_button(cursor, event->device,
+                                dispatch_cursor_button(cursor, &event->tablet->base,
-                                                event->time_msec, BTN_RIGHT, event->state);
+                                        event->time_msec, BTN_RIGHT, WL_POINTER_BUTTON_STATE_PRESSED);
                        }
-                        cursor->tool_buttons++;
                        break;
                case WLR_BUTTON_RELEASED:
-                        if (cursor->tool_buttons == 1) {
+                        if (cursor->tool_buttons <= 1) {
-                                dispatch_cursor_button(cursor, event->device,
+                                dispatch_cursor_button(cursor, &event->tablet->base,
-                                                event->time_msec, BTN_RIGHT, event->state);
+                                        event->time_msec, BTN_RIGHT, WL_POINTER_BUTTON_STATE_RELEASED);
                        }
-                        cursor->tool_buttons--;
                        break;
                }
                wlr_seat_pointer_notify_frame(cursor->seat->wlr_seat);
-                return;
+        } else {
+                cursor->simulating_pointer_from_tool_button = false;
+                wlr_tablet_v2_tablet_tool_notify_button(sway_tool->tablet_v2_tool,
+                        event->button, (enum zwp_tablet_pad_v2_button_state)event->state);
        }
-        wlr_tablet_v2_tablet_tool_notify_button(sway_tool->tablet_v2_tool,
+        // Update tool button count.
-                event->button, (enum zwp_tablet_pad_v2_button_state)event->state);
+        switch (event->state) {
+        case WLR_BUTTON_PRESSED:
+                cursor->tool_buttons++;
+                break;
+        case WLR_BUTTON_RELEASED:
+                if (cursor->tool_buttons == 0) {
+                        sway_log(SWAY_ERROR, "inconsistent tablet tool button events");
+                } else {
+                        cursor->tool_buttons--;
+                }
+                break;
+        }
 }
 static void check_constraint_region(struct sway_cursor *cursor) {
@@ -920,59 +892,68 @@ static void handle_request_pointer_set_cursor(struct wl_listener *listener,
                        event->hotspot_y, focused_client);
 }
+static void handle_pointer_hold_begin(struct wl_listener *listener, void *data) {
+        struct sway_cursor *cursor = wl_container_of(
+                        listener, cursor, hold_begin);
+        struct wlr_pointer_hold_begin_event *event = data;
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
+        seatop_hold_begin(cursor->seat, event);
+}
+static void handle_pointer_hold_end(struct wl_listener *listener, void *data) {
+        struct sway_cursor *cursor = wl_container_of(
+                        listener, cursor, hold_end);
+        struct wlr_pointer_hold_end_event *event = data;
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
+        seatop_hold_end(cursor->seat, event);
+}
 static void handle_pointer_pinch_begin(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(
                        listener, cursor, pinch_begin);
-        struct wlr_event_pointer_pinch_begin *event = data;
+        struct wlr_pointer_pinch_begin_event *event = data;
-        wlr_pointer_gestures_v1_send_pinch_begin(
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
-                        cursor->pointer_gestures, cursor->seat->wlr_seat,
+        seatop_pinch_begin(cursor->seat, event);
-                        event->time_msec, event->fingers);
 }
 static void handle_pointer_pinch_update(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(
                        listener, cursor, pinch_update);
-        struct wlr_event_pointer_pinch_update *event = data;
+        struct wlr_pointer_pinch_update_event *event = data;
-        wlr_pointer_gestures_v1_send_pinch_update(
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
-                        cursor->pointer_gestures, cursor->seat->wlr_seat,
+        seatop_pinch_update(cursor->seat, event);
-                        event->time_msec, event->dx, event->dy,
-                        event->scale, event->rotation);
 }
 static void handle_pointer_pinch_end(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(
                        listener, cursor, pinch_end);
-        struct wlr_event_pointer_pinch_end *event = data;
+        struct wlr_pointer_pinch_end_event *event = data;
-        wlr_pointer_gestures_v1_send_pinch_end(
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
-                        cursor->pointer_gestures, cursor->seat->wlr_seat,
+        seatop_pinch_end(cursor->seat, event);
-                        event->time_msec, event->cancelled);
 }
 static void handle_pointer_swipe_begin(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(
                        listener, cursor, swipe_begin);
-        struct wlr_event_pointer_swipe_begin *event = data;
+        struct wlr_pointer_swipe_begin_event *event = data;
-        wlr_pointer_gestures_v1_send_swipe_begin(
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
-                        cursor->pointer_gestures, cursor->seat->wlr_seat,
+        seatop_swipe_begin(cursor->seat, event);
-                        event->time_msec, event->fingers);
 }
 static void handle_pointer_swipe_update(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(
                        listener, cursor, swipe_update);
-        struct wlr_event_pointer_swipe_update *event = data;
+        struct wlr_pointer_swipe_update_event *event = data;
-        wlr_pointer_gestures_v1_send_swipe_update(
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
-                        cursor->pointer_gestures, cursor->seat->wlr_seat,
+        seatop_swipe_update(cursor->seat, event);
-                        event->time_msec, event->dx, event->dy);
 }
 static void handle_pointer_swipe_end(struct wl_listener *listener, void *data) {
        struct sway_cursor *cursor = wl_container_of(
                        listener, cursor, swipe_end);
-        struct wlr_event_pointer_swipe_end *event = data;
+        struct wlr_pointer_swipe_end_event *event = data;
-        wlr_pointer_gestures_v1_send_swipe_end(
+        cursor_handle_activity_from_device(cursor, &event->pointer->base);
-                        cursor->pointer_gestures, cursor->seat->wlr_seat,
+        seatop_swipe_end(cursor->seat, event);
-                        event->time_msec, event->cancelled);
 }
 static void handle_image_surface_destroy(struct wl_listener *listener,
@@ -1011,10 +992,9 @@ void cursor_set_image(struct sway_cursor *cursor, const char *image,
        }
        if (!image) {
-                wlr_cursor_set_image(cursor->cursor, NULL, 0, 0, 0, 0, 0, 0);
+                wlr_cursor_unset_image(cursor->cursor);
        } else if (!current_image || strcmp(current_image, image) != 0) {
-                wlr_xcursor_manager_set_cursor_image(cursor->xcursor_manager, image,
+                wlr_cursor_set_xcursor(cursor->cursor, cursor->xcursor_manager, image);
-                                cursor->cursor);
        }
 }
@@ -1046,6 +1026,8 @@ void sway_cursor_destroy(struct sway_cursor *cursor) {
        wl_event_source_remove(cursor->hide_source);
        wl_list_remove(&cursor->image_surface_destroy.link);
+        wl_list_remove(&cursor->hold_begin.link);
+        wl_list_remove(&cursor->hold_end.link);
        wl_list_remove(&cursor->pinch_begin.link);
        wl_list_remove(&cursor->pinch_update.link);
        wl_list_remove(&cursor->pinch_end.link);
@@ -1059,6 +1041,7 @@ void sway_cursor_destroy(struct sway_cursor *cursor) {
        wl_list_remove(&cursor->frame.link);
        wl_list_remove(&cursor->touch_down.link);
        wl_list_remove(&cursor->touch_up.link);
+        wl_list_remove(&cursor->touch_cancel.link);
        wl_list_remove(&cursor->touch_motion.link);
        wl_list_remove(&cursor->touch_frame.link);
        wl_list_remove(&cursor->tool_axis.link);
@@ -1095,19 +1078,24 @@ struct sway_cursor *sway_cursor_create(struct sway_seat *seat) {
        wl_list_init(&cursor->image_surface_destroy.link);
        cursor->image_surface_destroy.notify = handle_image_surface_destroy;
-        cursor->pointer_gestures = wlr_pointer_gestures_v1_create(server.wl_display);
+        wl_signal_add(&wlr_cursor->events.hold_begin, &cursor->hold_begin);
-        cursor->pinch_begin.notify = handle_pointer_pinch_begin;
+        cursor->hold_begin.notify = handle_pointer_hold_begin;
+        wl_signal_add(&wlr_cursor->events.hold_end, &cursor->hold_end);
+        cursor->hold_end.notify = handle_pointer_hold_end;
        wl_signal_add(&wlr_cursor->events.pinch_begin, &cursor->pinch_begin);
-        cursor->pinch_update.notify = handle_pointer_pinch_update;
+        cursor->pinch_begin.notify = handle_pointer_pinch_begin;
        wl_signal_add(&wlr_cursor->events.pinch_update, &cursor->pinch_update);
-        cursor->pinch_end.notify = handle_pointer_pinch_end;
+        cursor->pinch_update.notify = handle_pointer_pinch_update;
        wl_signal_add(&wlr_cursor->events.pinch_end, &cursor->pinch_end);
-        cursor->swipe_begin.notify = handle_pointer_swipe_begin;
+        cursor->pinch_end.notify = handle_pointer_pinch_end;
        wl_signal_add(&wlr_cursor->events.swipe_begin, &cursor->swipe_begin);
-        cursor->swipe_update.notify = handle_pointer_swipe_update;
+        cursor->swipe_begin.notify = handle_pointer_swipe_begin;
        wl_signal_add(&wlr_cursor->events.swipe_update, &cursor->swipe_update);
-        cursor->swipe_end.notify = handle_pointer_swipe_end;
+        cursor->swipe_update.notify = handle_pointer_swipe_update;
        wl_signal_add(&wlr_cursor->events.swipe_end, &cursor->swipe_end);
+        cursor->swipe_end.notify = handle_pointer_swipe_end;
        // input events
        wl_signal_add(&wlr_cursor->events.motion, &cursor->motion);
@@ -1132,6 +1120,9 @@ struct sway_cursor *sway_cursor_create(struct sway_seat *seat) {
        wl_signal_add(&wlr_cursor->events.touch_up, &cursor->touch_up);
        cursor->touch_up.notify = handle_touch_up;
+        wl_signal_add(&wlr_cursor->events.touch_cancel, &cursor->touch_cancel);
+        cursor->touch_cancel.notify = handle_touch_cancel;
        wl_signal_add(&wlr_cursor->events.touch_motion,
                &cursor->touch_motion);
        cursor->touch_motion.notify = handle_touch_motion;
@@ -1224,11 +1215,7 @@ uint32_t get_mouse_bindsym(const char *name, char **error) {
                // Get event code from name
                int code = libevdev_event_code_from_name(EV_KEY, name);
                if (code == -1) {
-                        size_t len = snprintf(NULL, 0, "Unknown event %s", name) + 1;
+                        *error = format_str("Unknown event %s", name);
-                        *error = malloc(len);
-                        if (*error) {
-                                snprintf(*error, len, "Unknown event %s", name);
-                        }
                        return 0;
                }
                return code;
@@ -1250,13 +1237,8 @@ uint32_t get_mouse_bindcode(const char *name, char **error) {
        }
        const char *event = libevdev_event_code_get_name(EV_KEY, code);
        if (!event || strncmp(event, "BTN_", strlen("BTN_")) != 0) {
-                size_t len = snprintf(NULL, 0, "Event code %d (%s) is not a button",
+                *error = format_str("Event code %d (%s) is not a button",
-                                code, event ? event : "(null)") + 1;
+                        code, event ? event : "(null)");
-                *error = malloc(len);
-                if (*error) {
-                        snprintf(*error, len, "Event code %d (%s) is not a button",
-                                        code, event ? event : "(null)");
-                }
                return 0;
        }
        return code;
@@ -1289,12 +1271,15 @@ const char *get_mouse_button_name(uint32_t button) {
 static void warp_to_constraint_cursor_hint(struct sway_cursor *cursor) {
        struct wlr_pointer_constraint_v1 *constraint = cursor->active_constraint;
-        if (constraint->current.committed &
+        if (constraint->current.cursor_hint.enabled) {
-                        WLR_POINTER_CONSTRAINT_V1_STATE_CURSOR_HINT) {
                double sx = constraint->current.cursor_hint.x;
                double sy = constraint->current.cursor_hint.y;
                struct sway_view *view = view_from_wlr_surface(constraint->surface);
+                if (!view) {
+                        return;
+                }
                struct sway_container *con = view->container;
                double lx = sx + con->pending.content_x - view->geometry.x;
@@ -1345,12 +1330,9 @@ void handle_pointer_constraint(struct wl_listener *listener, void *data) {
        sway_constraint->destroy.notify = handle_constraint_destroy;
        wl_signal_add(&constraint->events.destroy, &sway_constraint->destroy);
-        struct sway_node *focus = seat_get_focus(seat);
+        struct wlr_surface *surface = seat->wlr_seat->keyboard_state.focused_surface;
-        if (focus && focus->type == N_CONTAINER && focus->sway_container->view) {
+        if (surface && surface == constraint->surface) {
-                struct wlr_surface *surface = focus->sway_container->view->surface;
+                sway_cursor_constrain(seat->cursor, constraint);
-                if (surface == constraint->surface) {
-                        sway_cursor_constrain(seat->cursor, constraint);
-                }
        }
 }
@@ -1408,3 +1390,26 @@ void sway_cursor_constrain(struct sway_cursor *cursor,
        wl_signal_add(&constraint->surface->events.commit,
                &cursor->constraint_commit);
 }
+void handle_request_set_cursor_shape(struct wl_listener *listener, void *data) {
+        const struct wlr_cursor_shape_manager_v1_request_set_shape_event *event = data;
+        struct sway_seat *seat = event->seat_client->seat->data;
+        if (!seatop_allows_set_cursor(seat)) {
+                return;
+        }
+        struct wl_client *focused_client = NULL;
+        struct wlr_surface *focused_surface = seat->wlr_seat->pointer_state.focused_surface;
+        if (focused_surface != NULL) {
+                focused_client = wl_resource_get_client(focused_surface->resource);
+        }
+        // TODO: check cursor mode
+        if (focused_client == NULL || event->seat_client->client != focused_client) {
+                sway_log(SWAY_DEBUG, "denying request to set cursor from unfocused client");
+                return;
+        }
+        cursor_set_image(seat->cursor, wlr_cursor_shape_v1_name(event->shape), focused_client);
+}
diff --git a/sway/input/input-manager.c b/sway/input/input-manager.c
index f04a8ce0..248ca34e 100644
--- a/sway/input/input-manager.c
+++ b/sway/input/input-manager.c
@@ -1,12 +1,12 @@
-#define _POSIX_C_SOURCE 200809L
 #include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
+#include <assert.h>
+#include <wlr/config.h>
 #include <wlr/backend/libinput.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_keyboard_group.h>
-#include <wlr/types/wlr_input_inhibitor.h>
 #include <wlr/types/wlr_virtual_keyboard_v1.h>
 #include <wlr/types/wlr_virtual_pointer_v1.h>
 #include "sway/config.h"
@@ -22,6 +22,10 @@
 #include "list.h"
 #include "log.h"
+#if WLR_HAS_LIBINPUT_BACKEND
+#include <wlr/backend/libinput.h>
+#endif
 #define DEFAULT_SEAT "seat0"
 struct input_config *current_input_config = NULL;
@@ -63,8 +67,15 @@ struct sway_seat *input_manager_sway_seat_from_wlr_seat(struct wlr_seat *wlr_sea
 }
 char *input_device_get_identifier(struct wlr_input_device *device) {
-        int vendor = device->vendor;
+        int vendor = 0, product = 0;
-        int product = device->product;
+#if WLR_HAS_LIBINPUT_BACKEND
+        if (wlr_input_device_is_libinput(device)) {
+                struct libinput_device *libinput_dev = wlr_libinput_get_device_handle(device);
+                vendor = libinput_device_get_id_vendor(libinput_dev);
+                product = libinput_device_get_id_product(libinput_dev);
+        }
+#endif
        char *name = strdup(device->name ? device->name : "");
        strip_whitespace(name);
@@ -76,20 +87,13 @@ char *input_device_get_identifier(struct wlr_input_device *device) {
                }
        }
-        const char *fmt = "%d:%d:%s";
+        char *identifier = format_str("%d:%d:%s", vendor, product, name);
-        int len = snprintf(NULL, 0, fmt, vendor, product, name) + 1;
-        char *identifier = malloc(len);
-        if (!identifier) {
-                sway_log(SWAY_ERROR, "Unable to allocate unique input device name");
-                return NULL;
-        }
-        snprintf(identifier, len, fmt, vendor, product, name);
        free(name);
        return identifier;
 }
 static bool device_is_touchpad(struct sway_input_device *device) {
+#if WLR_HAS_LIBINPUT_BACKEND
        if (device->wlr_device->type != WLR_INPUT_DEVICE_POINTER ||
                        !wlr_input_device_is_libinput(device->wlr_device)) {
                return false;
@@ -99,6 +103,9 @@ static bool device_is_touchpad(struct sway_input_device *device) {
                wlr_libinput_get_device_handle(device->wlr_device);
        return libinput_device_config_tap_get_finger_count(libinput_device) > 0;
+#else
+        return false;
+#endif
 }
 const char *input_device_get_type(struct sway_input_device *device) {
@@ -113,7 +120,7 @@ const char *input_device_get_type(struct sway_input_device *device) {
                return "keyboard";
        case WLR_INPUT_DEVICE_TOUCH:
                return "touch";
-        case WLR_INPUT_DEVICE_TABLET_TOOL:
+        case WLR_INPUT_DEVICE_TABLET:
                return "tablet_tool";
        case WLR_INPUT_DEVICE_TABLET_PAD:
                return "tablet_pad";
@@ -236,7 +243,11 @@ static void handle_new_input(struct wl_listener *listener, void *data) {
        apply_input_type_config(input_device);
-        sway_input_configure_libinput_device(input_device);
+#if WLR_HAS_LIBINPUT_BACKEND
+        bool config_changed = sway_input_configure_libinput_device(input_device);
+#else
+        bool config_changed = false;
+#endif
        wl_signal_add(&device->events.destroy, &input_device->device_destroy);
        input_device->device_destroy.notify = handle_device_destroy;
@@ -274,29 +285,9 @@ static void handle_new_input(struct wl_listener *listener, void *data) {
        }
        ipc_event_input("added", input_device);
-}
-static void handle_inhibit_activate(struct wl_listener *listener, void *data) {
+        if (config_changed) {
-        struct sway_input_manager *input_manager = wl_container_of(
+                ipc_event_input("libinput_config", input_device);
-                        listener, input_manager, inhibit_activate);
-        struct sway_seat *seat;
-        wl_list_for_each(seat, &input_manager->seats, link) {
-                seat_set_exclusive_client(seat, input_manager->inhibit->active_client);
-        }
-}
-static void handle_inhibit_deactivate(struct wl_listener *listener, void *data) {
-        struct sway_input_manager *input_manager = wl_container_of(
-                        listener, input_manager, inhibit_deactivate);
-        struct sway_seat *seat;
-        wl_list_for_each(seat, &input_manager->seats, link) {
-                seat_set_exclusive_client(seat, NULL);
-                struct sway_node *previous = seat_get_focus(seat);
-                if (previous) {
-                        // Hack to get seat to re-focus the return value of get_focus
-                        seat_set_focus(seat, NULL);
-                        seat_set_focus(seat, previous);
-                }
        }
 }
@@ -377,7 +368,7 @@ void handle_virtual_keyboard(struct wl_listener *listener, void *data) {
        struct sway_input_manager *input_manager =
                wl_container_of(listener, input_manager, virtual_keyboard_new);
        struct wlr_virtual_keyboard_v1 *keyboard = data;
-        struct wlr_input_device *device = &keyboard->input_device;
+        struct wlr_input_device *device = &keyboard->keyboard.base;
        // TODO: Amend protocol to allow NULL seat
        struct sway_seat *seat = keyboard->seat ?
@@ -410,7 +401,7 @@ void handle_virtual_pointer(struct wl_listener *listener, void *data) {
                wl_container_of(listener, input_manager, virtual_pointer_new);
        struct wlr_virtual_pointer_v1_new_pointer_event *event = data;
        struct wlr_virtual_pointer_v1 *pointer = event->new_pointer;
-        struct wlr_input_device *device = &pointer->input_device;
+        struct wlr_input_device *device = &pointer->pointer.base;
        struct sway_seat *seat = event->suggested_seat ?
                input_manager_sway_seat_from_wlr_seat(event->suggested_seat) :
@@ -442,6 +433,20 @@ void handle_virtual_pointer(struct wl_listener *listener, void *data) {
        }
 }
+static void handle_transient_seat_manager_create_seat(
+                struct wl_listener *listener, void *data) {
+        struct wlr_transient_seat_v1 *transient_seat = data;
+        static uint64_t i;
+        char name[256];
+        snprintf(name, sizeof(name), "transient-%"PRIx64, i++);
+        struct sway_seat *seat = seat_create(name);
+        if (seat && seat->wlr_seat) {
+                wlr_transient_seat_v1_ready(transient_seat, seat->wlr_seat);
+        } else {
+                wlr_transient_seat_v1_deny(transient_seat);
+        }
+}
 struct sway_input_manager *input_manager_create(struct sway_server *server) {
        struct sway_input_manager *input =
                calloc(1, sizeof(struct sway_input_manager));
@@ -468,14 +473,6 @@ struct sway_input_manager *input_manager_create(struct sway_server *server) {
                &input->virtual_pointer_new);
        input->virtual_pointer_new.notify = handle_virtual_pointer;
-        input->inhibit = wlr_input_inhibit_manager_create(server->wl_display);
-        input->inhibit_activate.notify = handle_inhibit_activate;
-        wl_signal_add(&input->inhibit->events.activate,
-                        &input->inhibit_activate);
-        input->inhibit_deactivate.notify = handle_inhibit_deactivate;
-        wl_signal_add(&input->inhibit->events.deactivate,
-                        &input->inhibit_deactivate);
        input->keyboard_shortcuts_inhibit =
                wlr_keyboard_shortcuts_inhibit_v1_create(server->wl_display);
        input->keyboard_shortcuts_inhibit_new_inhibitor.notify =
@@ -483,6 +480,17 @@ struct sway_input_manager *input_manager_create(struct sway_server *server) {
        wl_signal_add(&input->keyboard_shortcuts_inhibit->events.new_inhibitor,
                        &input->keyboard_shortcuts_inhibit_new_inhibitor);
+        input->pointer_gestures = wlr_pointer_gestures_v1_create(server->wl_display);
+        input->transient_seat_manager =
+                wlr_transient_seat_manager_v1_create(server->wl_display);
+        assert(input->transient_seat_manager);
+        input->transient_seat_create.notify =
+                handle_transient_seat_manager_create_seat;
+        wl_signal_add(&input->transient_seat_manager->events.create_seat,
+                        &input->transient_seat_create);
        return input;
 }
@@ -520,21 +528,50 @@ static void retranslate_keysyms(struct input_config *input_config) {
                        return;
                }
        }
+        for (int i = 0; i < config->input_type_configs->length; ++i) {
+                struct input_config *ic = config->input_type_configs->items[i];
+                if (ic->xkb_layout || ic->xkb_file) {
+                        // this is the first config with xkb_layout or xkb_file
+                        if (ic->identifier == input_config->identifier) {
+                                translate_keysyms(ic);
+                        }
+                        return;
+                }
+        }
 }
 static void input_manager_configure_input(
                struct sway_input_device *input_device) {
-        sway_input_configure_libinput_device(input_device);
+#if WLR_HAS_LIBINPUT_BACKEND
+        bool config_changed = sway_input_configure_libinput_device(input_device);
+#else
+        bool config_changed = false;
+#endif
        struct sway_seat *seat = NULL;
        wl_list_for_each(seat, &server.input->seats, link) {
                seat_configure_device(seat, input_device);
        }
+        if (config_changed) {
+                ipc_event_input("libinput_config", input_device);
+        }
 }
-void input_manager_configure_all_inputs(void) {
+void input_manager_configure_all_input_mappings(void) {
-        struct sway_input_device *input_device = NULL;
+        struct sway_input_device *input_device;
        wl_list_for_each(input_device, &server.input->devices, link) {
-                input_manager_configure_input(input_device);
+                struct sway_seat *seat;
+                wl_list_for_each(seat, &server.input->seats, link) {
+                        seat_configure_device_mapping(seat, input_device);
+                }
+#if WLR_HAS_LIBINPUT_BACKEND
+                // Input devices mapped to unavailable outputs get their libinput
+                // send_events setting switched to false. We need to re-enable this
+                // when the output appears.
+                sway_input_configure_libinput_device_send_events(input_device);
+#endif
        }
 }
@@ -556,7 +593,9 @@ void input_manager_apply_input_config(struct input_config *input_config) {
 }
 void input_manager_reset_input(struct sway_input_device *input_device) {
+#if WLR_HAS_LIBINPUT_BACKEND
        sway_input_reset_libinput_device(input_device);
+#endif
        struct sway_seat *seat = NULL;
        wl_list_for_each(seat, &server.input->seats, link) {
                seat_reset_device(seat, input_device);
@@ -564,6 +603,13 @@ void input_manager_reset_input(struct sway_input_device *input_device) {
 }
 void input_manager_reset_all_inputs(void) {
+        // Set the active keyboard to NULL to avoid spamming configuration updates
+        // for all keyboard devices.
+        struct sway_seat *seat;
+        wl_list_for_each(seat, &server.input->seats, link) {
+                wlr_seat_set_keyboard(seat->wlr_seat, NULL);
+        }
        struct sway_input_device *input_device = NULL;
        wl_list_for_each(input_device, &server.input->devices, link) {
                input_manager_reset_input(input_device);
@@ -572,7 +618,6 @@ void input_manager_reset_all_inputs(void) {
        // If there is at least one keyboard using the default keymap, repeat delay,
        // and repeat rate, then it is possible that there is a keyboard group that
        // need their keyboard disarmed.
-        struct sway_seat *seat;
        wl_list_for_each(seat, &server.input->seats, link) {
                struct sway_keyboard_group *group;
                wl_list_for_each(group, &seat->keyboard_groups, link) {
diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c
index f258ac7d..f74d0658 100644
--- a/sway/input/keyboard.c
+++ b/sway/input/keyboard.c
@@ -1,10 +1,9 @@
 #include <assert.h>
 #include <limits.h>
 #include <strings.h>
+#include <wlr/config.h>
 #include <wlr/backend/multi.h>
-#include <wlr/backend/session.h>
 #include <wlr/interfaces/wlr_keyboard.h>
-#include <wlr/types/wlr_idle.h>
 #include <wlr/types/wlr_keyboard.h>
 #include <wlr/types/wlr_keyboard_group.h>
 #include <xkbcommon/xkbcommon-names.h>
@@ -16,6 +15,10 @@
 #include "sway/ipc-server.h"
 #include "log.h"
+#if WLR_HAS_SESSION
+#include <wlr/backend/session.h>
+#endif
 static struct modifier_key {
        char *name;
        uint32_t mod;
@@ -29,6 +32,7 @@ static struct modifier_key {
        { XKB_MOD_NAME_NUM, WLR_MODIFIER_MOD2 },
        { "Mod3", WLR_MODIFIER_MOD3 },
        { XKB_MOD_NAME_LOGO, WLR_MODIFIER_LOGO },
+        { "Super", WLR_MODIFIER_LOGO },
        { "Mod5", WLR_MODIFIER_MOD5 },
 };
@@ -264,14 +268,12 @@ static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard,
                xkb_keysym_t keysym = pressed_keysyms[i];
                if (keysym >= XKB_KEY_XF86Switch_VT_1 &&
                                keysym <= XKB_KEY_XF86Switch_VT_12) {
-                        if (wlr_backend_is_multi(server.backend)) {
+#if WLR_HAS_SESSION
-                                struct wlr_session *session =
+                        if (server.session) {
-                                        wlr_backend_get_session(server.backend);
+                                unsigned vt = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
-                                if (session) {
+                                wlr_session_change_vt(server.session, vt);
-                                        unsigned vt = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
-                                        wlr_session_change_vt(session, vt);
-                                }
                        }
+#endif
                        return true;
                }
        }
@@ -291,14 +293,12 @@ static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard,
 static size_t keyboard_keysyms_translated(struct sway_keyboard *keyboard,
                xkb_keycode_t keycode, const xkb_keysym_t **keysyms,
                uint32_t *modifiers) {
-        struct wlr_input_device *device =
+        *modifiers = wlr_keyboard_get_modifiers(keyboard->wlr);
-                keyboard->seat_device->input_device->wlr_device;
-        *modifiers = wlr_keyboard_get_modifiers(device->keyboard);
        xkb_mod_mask_t consumed = xkb_state_key_get_consumed_mods2(
-                device->keyboard->xkb_state, keycode, XKB_CONSUMED_MODE_XKB);
+                keyboard->wlr->xkb_state, keycode, XKB_CONSUMED_MODE_XKB);
        *modifiers = *modifiers & ~consumed;
-        return xkb_state_key_get_syms(device->keyboard->xkb_state,
+        return xkb_state_key_get_syms(keyboard->wlr->xkb_state,
                keycode, keysyms);
 }
@@ -314,13 +314,11 @@ static size_t keyboard_keysyms_translated(struct sway_keyboard *keyboard,
 static size_t keyboard_keysyms_raw(struct sway_keyboard *keyboard,
                xkb_keycode_t keycode, const xkb_keysym_t **keysyms,
                uint32_t *modifiers) {
-        struct wlr_input_device *device =
+        *modifiers = wlr_keyboard_get_modifiers(keyboard->wlr);
-                keyboard->seat_device->input_device->wlr_device;
-        *modifiers = wlr_keyboard_get_modifiers(device->keyboard);
        xkb_layout_index_t layout_index = xkb_state_key_get_layout(
-                device->keyboard->xkb_state, keycode);
+                keyboard->wlr->xkb_state, keycode);
-        return xkb_keymap_key_get_syms_by_level(device->keyboard->keymap,
+        return xkb_keymap_key_get_syms_by_level(keyboard->wlr->keymap,
                keycode, layout_index, 0, keysyms);
 }
@@ -360,8 +358,7 @@ static void update_keyboard_state(struct sway_keyboard *keyboard,
                        keyinfo->keycode, &keyinfo->translated_keysyms,
                        &keyinfo->translated_modifiers);
-        keyinfo->code_modifiers = wlr_keyboard_get_modifiers(
+        keyinfo->code_modifiers = wlr_keyboard_get_modifiers(keyboard->wlr);
-                        keyboard->seat_device->input_device->wlr_device->keyboard);
        // Update shortcut model keyinfo
        update_shortcut_state(&keyboard->state_keycodes, raw_keycode, keystate,
@@ -401,15 +398,15 @@ static struct wlr_input_method_keyboard_grab_v2 *keyboard_get_im_grab(
 }
 static void handle_key_event(struct sway_keyboard *keyboard,
-                struct wlr_event_keyboard_key *event) {
+                struct wlr_keyboard_key_event *event) {
        struct sway_seat *seat = keyboard->seat_device->sway_seat;
        struct wlr_seat *wlr_seat = seat->wlr_seat;
        struct wlr_input_device *wlr_device =
                keyboard->seat_device->input_device->wlr_device;
        char *device_identifier = input_device_get_identifier(wlr_device);
-        bool exact_identifier = wlr_device->keyboard->group != NULL;
+        bool exact_identifier = keyboard->wlr->group != NULL;
        seat_idle_notify_activity(seat, IDLE_SOURCE_KEYBOARD);
-        bool input_inhibited = seat->exclusive_client != NULL;
+        bool locked = server.session_lock.lock;
        struct sway_keyboard_shortcuts_inhibitor *sway_inhibitor =
                keyboard_shortcuts_inhibitor_get_for_focused_surface(seat);
        bool shortcuts_inhibited = sway_inhibitor && sway_inhibitor->inhibitor->active;
@@ -427,17 +424,17 @@ static void handle_key_event(struct sway_keyboard *keyboard,
        struct sway_binding *binding_released = NULL;
        get_active_binding(&keyboard->state_keycodes,
                        config->current_mode->keycode_bindings, &binding_released,
-                        keyinfo.code_modifiers, true, input_inhibited,
+                        keyinfo.code_modifiers, true, locked,
                        shortcuts_inhibited, device_identifier,
                        exact_identifier, keyboard->effective_layout);
        get_active_binding(&keyboard->state_keysyms_raw,
                        config->current_mode->keysym_bindings, &binding_released,
-                        keyinfo.raw_modifiers, true, input_inhibited,
+                        keyinfo.raw_modifiers, true, locked,
                        shortcuts_inhibited, device_identifier,
                        exact_identifier, keyboard->effective_layout);
        get_active_binding(&keyboard->state_keysyms_translated,
                        config->current_mode->keysym_bindings, &binding_released,
-                        keyinfo.translated_modifiers, true, input_inhibited,
+                        keyinfo.translated_modifiers, true, locked,
                        shortcuts_inhibited, device_identifier,
                        exact_identifier, keyboard->effective_layout);
@@ -459,17 +456,17 @@ static void handle_key_event(struct sway_keyboard *keyboard,
        if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
                get_active_binding(&keyboard->state_keycodes,
                                config->current_mode->keycode_bindings, &binding,
-                                keyinfo.code_modifiers, false, input_inhibited,
+                                keyinfo.code_modifiers, false, locked,
                                shortcuts_inhibited, device_identifier,
                                exact_identifier, keyboard->effective_layout);
                get_active_binding(&keyboard->state_keysyms_raw,
                                config->current_mode->keysym_bindings, &binding,
-                                keyinfo.raw_modifiers, false, input_inhibited,
+                                keyinfo.raw_modifiers, false, locked,
                                shortcuts_inhibited, device_identifier,
                                exact_identifier, keyboard->effective_layout);
                get_active_binding(&keyboard->state_keysyms_translated,
                                config->current_mode->keysym_bindings, &binding,
-                                keyinfo.translated_modifiers, false, input_inhibited,
+                                keyinfo.translated_modifiers, false, locked,
                                shortcuts_inhibited, device_identifier,
                                exact_identifier, keyboard->effective_layout);
        }
@@ -477,10 +474,10 @@ static void handle_key_event(struct sway_keyboard *keyboard,
        // Set up (or clear) keyboard repeat for a pressed binding. Since the
        // binding may remove the keyboard, the timer needs to be updated first
        if (binding && !(binding->flags & BINDING_NOREPEAT) &&
-                        wlr_device->keyboard->repeat_info.delay > 0) {
+                        keyboard->wlr->repeat_info.delay > 0) {
                keyboard->repeat_binding = binding;
                if (wl_event_source_timer_update(keyboard->key_repeat_source,
-                                wlr_device->keyboard->repeat_info.delay) < 0) {
+                                keyboard->wlr->repeat_info.delay) < 0) {
                        sway_log(SWAY_DEBUG, "failed to set key repeat timer");
                }
        } else if (keyboard->repeat_binding) {
@@ -492,7 +489,7 @@ static void handle_key_event(struct sway_keyboard *keyboard,
                handled = true;
        }
-        if (!handled && wlr_device->keyboard->group) {
+        if (!handled && keyboard->wlr->group) {
                // Only handle device specific bindings for keyboards in a group
                free(device_identifier);
                return;
@@ -517,7 +514,7 @@ static void handle_key_event(struct sway_keyboard *keyboard,
                        &keyboard->state_pressed_sent, event->keycode,
                        event->state, keyinfo.keycode, 0);
                if (pressed_sent) {
-                        wlr_seat_set_keyboard(wlr_seat, wlr_device);
+                        wlr_seat_set_keyboard(wlr_seat, keyboard->wlr);
                        wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec,
                                event->keycode, event->state);
                        handled = true;
@@ -528,8 +525,7 @@ static void handle_key_event(struct sway_keyboard *keyboard,
                struct wlr_input_method_keyboard_grab_v2 *kb_grab = keyboard_get_im_grab(keyboard);
                if (kb_grab) {
-                        wlr_input_method_keyboard_grab_v2_set_keyboard(kb_grab,
+                        wlr_input_method_keyboard_grab_v2_set_keyboard(kb_grab, keyboard->wlr);
-                                wlr_device->keyboard);
                        wlr_input_method_keyboard_grab_v2_send_key(kb_grab,
                                event->time_msec, event->keycode, event->state);
                        handled = true;
@@ -542,7 +538,7 @@ static void handle_key_event(struct sway_keyboard *keyboard,
                update_shortcut_state(
                        &keyboard->state_pressed_sent, event->keycode, event->state,
                        keyinfo.keycode, 0);
-                wlr_seat_set_keyboard(wlr_seat, wlr_device);
+                wlr_seat_set_keyboard(wlr_seat, keyboard->wlr);
                wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec,
                                event->keycode, event->state);
        }
@@ -618,14 +614,12 @@ static void handle_keyboard_group_leave(struct wl_listener *listener,
 }
 static int handle_keyboard_repeat(void *data) {
-        struct sway_keyboard *keyboard = (struct sway_keyboard *)data;
+        struct sway_keyboard *keyboard = data;
-        struct wlr_keyboard *wlr_device =
-                        keyboard->seat_device->input_device->wlr_device->keyboard;
        if (keyboard->repeat_binding) {
-                if (wlr_device->repeat_info.rate > 0) {
+                if (keyboard->wlr->repeat_info.rate > 0) {
                        // We queue the next event first, as the command might cancel it
                        if (wl_event_source_timer_update(keyboard->key_repeat_source,
-                                        1000 / wlr_device->repeat_info.rate) < 0) {
+                                        1000 / keyboard->wlr->repeat_info.rate) < 0) {
                                sway_log(SWAY_DEBUG, "failed to update key repeat timer");
                        }
                }
@@ -658,31 +652,28 @@ static void determine_bar_visibility(uint32_t modifiers) {
 }
 static void handle_modifier_event(struct sway_keyboard *keyboard) {
-        struct wlr_input_device *wlr_device =
+        if (!keyboard->wlr->group) {
-                keyboard->seat_device->input_device->wlr_device;
-        if (!wlr_device->keyboard->group) {
                struct wlr_input_method_keyboard_grab_v2 *kb_grab = keyboard_get_im_grab(keyboard);
                if (kb_grab) {
-                        wlr_input_method_keyboard_grab_v2_set_keyboard(kb_grab,
+                        wlr_input_method_keyboard_grab_v2_set_keyboard(kb_grab, keyboard->wlr);
-                                        wlr_device->keyboard);
                        wlr_input_method_keyboard_grab_v2_send_modifiers(kb_grab,
-                                        &wlr_device->keyboard->modifiers);
+                                        &keyboard->wlr->modifiers);
                } else {
                        struct wlr_seat *wlr_seat = keyboard->seat_device->sway_seat->wlr_seat;
-                        wlr_seat_set_keyboard(wlr_seat, wlr_device);
+                        wlr_seat_set_keyboard(wlr_seat, keyboard->wlr);
                        wlr_seat_keyboard_notify_modifiers(wlr_seat,
-                                        &wlr_device->keyboard->modifiers);
+                                        &keyboard->wlr->modifiers);
                }
-                uint32_t modifiers = wlr_keyboard_get_modifiers(wlr_device->keyboard);
+                uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard->wlr);
                determine_bar_visibility(modifiers);
        }
-        if (wlr_device->keyboard->modifiers.group != keyboard->effective_layout) {
+        if (keyboard->wlr->modifiers.group != keyboard->effective_layout) {
-                keyboard->effective_layout = wlr_device->keyboard->modifiers.group;
+                keyboard->effective_layout = keyboard->wlr->modifiers.group;
-                if (!wlr_keyboard_group_from_wlr_keyboard(wlr_device->keyboard)) {
+                if (!wlr_keyboard_group_from_wlr_keyboard(keyboard->wlr)) {
                        ipc_event_input("xkb_layout", keyboard->seat_device->input_device);
                }
        }
@@ -711,6 +702,7 @@ struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat,
        }
        keyboard->seat_device = device;
+        keyboard->wlr = wlr_keyboard_from_input_device(device->input_device->wlr_device);
        device->keyboard = keyboard;
        wl_list_init(&keyboard->keyboard_key.link);
@@ -724,23 +716,11 @@ struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat,
 static void handle_xkb_context_log(struct xkb_context *context,
                enum xkb_log_level level, const char *format, va_list args) {
-        va_list args_copy;
+        char *error = vformat_str(format, args);
-        va_copy(args_copy, args);
-        size_t length = vsnprintf(NULL, 0, format, args_copy) + 1;
-        va_end(args_copy);
-        char *error = malloc(length);
-        if (!error) {
-                sway_log(SWAY_ERROR, "Failed to allocate libxkbcommon log message");
-                return;
-        }
-        va_copy(args_copy, args);
-        vsnprintf(error, length, format, args_copy);
-        va_end(args_copy);
-        if (error[length - 2] == '\n') {
+        size_t len = strlen(error);
-                error[length - 2] = '\0';
+        if (error[len - 1] == '\n') {
+                error[len - 1] = '\0';
        }
        sway_log_importance_t importance = SWAY_DEBUG;
@@ -761,7 +741,7 @@ static void handle_xkb_context_log(struct xkb_context *context,
 struct xkb_keymap *sway_keyboard_compile_keymap(struct input_config *ic,
                char **error) {
-        struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+        struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_SECURE_GETENV);
        if (!sway_assert(context, "cannot create XKB context")) {
                return NULL;
        }
@@ -775,13 +755,8 @@ struct xkb_keymap *sway_keyboard_compile_keymap(struct input_config *ic,
                if (!keymap_file) {
                        sway_log_errno(SWAY_ERROR, "cannot read xkb file %s", ic->xkb_file);
                        if (error) {
-                                size_t len = snprintf(NULL, 0, "cannot read xkb file %s: %s",
+                                *error = format_str("cannot read xkb file %s: %s",
-                                                ic->xkb_file, strerror(errno)) + 1;
+                                        ic->xkb_file, strerror(errno));
-                                *error = malloc(len);
-                                if (*error) {
-                                        snprintf(*error, len, "cannot read xkb_file %s: %s",
-                                                        ic->xkb_file, strerror(errno));
-                                }
                        }
                        goto cleanup;
                }
@@ -819,13 +794,12 @@ static void destroy_empty_wlr_keyboard_group(void *data) {
 static void sway_keyboard_group_remove(struct sway_keyboard *keyboard) {
        struct sway_input_device *device = keyboard->seat_device->input_device;
-        struct wlr_keyboard *wlr_keyboard = device->wlr_device->keyboard;
+        struct wlr_keyboard_group *wlr_group = keyboard->wlr->group;
-        struct wlr_keyboard_group *wlr_group = wlr_keyboard->group;
        sway_log(SWAY_DEBUG, "Removing keyboard %s from group %p",
                        device->identifier, wlr_group);
-        wlr_keyboard_group_remove_keyboard(wlr_keyboard->group, wlr_keyboard);
+        wlr_keyboard_group_remove_keyboard(keyboard->wlr->group, keyboard->wlr);
        if (wl_list_empty(&wlr_group->devices)) {
                sway_log(SWAY_DEBUG, "Destroying empty keyboard group %p",
@@ -850,9 +824,7 @@ static void sway_keyboard_group_remove(struct sway_keyboard *keyboard) {
 }
 static void sway_keyboard_group_remove_invalid(struct sway_keyboard *keyboard) {
-        struct sway_input_device *device = keyboard->seat_device->input_device;
+        if (!keyboard->wlr->group) {
-        struct wlr_keyboard *wlr_keyboard = device->wlr_device->keyboard;
-        if (!wlr_keyboard->group) {
                return;
        }
@@ -868,7 +840,7 @@ static void sway_keyboard_group_remove_invalid(struct sway_keyboard *keyboard) {
                break;
        case KEYBOARD_GROUP_DEFAULT: /* fallthrough */
        case KEYBOARD_GROUP_SMART:;
-                struct wlr_keyboard_group *group = wlr_keyboard->group;
+                struct wlr_keyboard_group *group = keyboard->wlr->group;
                if (!wlr_keyboard_keymaps_match(keyboard->keymap, group->keyboard.keymap) ||
                                !repeat_info_match(keyboard, &group->keyboard)) {
                        sway_keyboard_group_remove(keyboard);
@@ -879,7 +851,6 @@ static void sway_keyboard_group_remove_invalid(struct sway_keyboard *keyboard) {
 static void sway_keyboard_group_add(struct sway_keyboard *keyboard) {
        struct sway_input_device *device = keyboard->seat_device->input_device;
-        struct wlr_keyboard *wlr_keyboard = device->wlr_device->keyboard;
        struct sway_seat *seat = keyboard->seat_device->sway_seat;
        struct seat_config *sc = seat_get_config(seat);
@@ -911,7 +882,7 @@ static void sway_keyboard_group_add(struct sway_keyboard *keyboard) {
                                        repeat_info_match(keyboard, &wlr_group->keyboard)) {
                                sway_log(SWAY_DEBUG, "Adding keyboard %s to group %p",
                                                device->identifier, wlr_group);
-                                wlr_keyboard_group_add_keyboard(wlr_group, wlr_keyboard);
+                                wlr_keyboard_group_add_keyboard(wlr_group, keyboard->wlr);
                                return;
                        }
                        break;
@@ -950,7 +921,7 @@ static void sway_keyboard_group_add(struct sway_keyboard *keyboard) {
                goto cleanup;
        }
        sway_group->seat_device->input_device->wlr_device =
-                sway_group->wlr_group->input_device;
+                &sway_group->wlr_group->keyboard.base;
        if (!sway_keyboard_create(seat, sway_group->seat_device)) {
                sway_log(SWAY_ERROR, "Failed to allocate sway_keyboard for group");
@@ -959,7 +930,7 @@ static void sway_keyboard_group_add(struct sway_keyboard *keyboard) {
        sway_log(SWAY_DEBUG, "Adding keyboard %s to group %p",
                        device->identifier, sway_group->wlr_group);
-        wlr_keyboard_group_add_keyboard(sway_group->wlr_group, wlr_keyboard);
+        wlr_keyboard_group_add_keyboard(sway_group->wlr_group, keyboard->wlr);
        wl_list_insert(&seat->keyboard_groups, &sway_group->link);
@@ -991,10 +962,8 @@ cleanup:
 void sway_keyboard_configure(struct sway_keyboard *keyboard) {
        struct input_config *input_config =
                input_device_get_config(keyboard->seat_device->input_device);
-        struct wlr_input_device *wlr_device =
-                keyboard->seat_device->input_device->wlr_device;
-        if (!sway_assert(!wlr_keyboard_group_from_wlr_keyboard(wlr_device->keyboard),
+        if (!sway_assert(!wlr_keyboard_group_from_wlr_keyboard(keyboard->wlr),
                                "sway_keyboard_configure should not be called with a "
                                "keyboard group's keyboard")) {
                return;
@@ -1036,11 +1005,11 @@ void sway_keyboard_configure(struct sway_keyboard *keyboard) {
                sway_keyboard_group_remove_invalid(keyboard);
-                wlr_keyboard_set_keymap(wlr_device->keyboard, keyboard->keymap);
+                wlr_keyboard_set_keymap(keyboard->wlr, keyboard->keymap);
-                wlr_keyboard_set_repeat_info(wlr_device->keyboard,
+                wlr_keyboard_set_repeat_info(keyboard->wlr,
                                keyboard->repeat_rate, keyboard->repeat_delay);
-                if (!wlr_device->keyboard->group) {
+                if (!keyboard->wlr->group) {
                        sway_keyboard_group_add(keyboard);
                }
@@ -1060,40 +1029,42 @@ void sway_keyboard_configure(struct sway_keyboard *keyboard) {
                        }
                }
                if (locked_mods) {
-                        wlr_keyboard_notify_modifiers(wlr_device->keyboard, 0, 0,
+                        wlr_keyboard_notify_modifiers(keyboard->wlr, 0, 0,
                                        locked_mods, 0);
                        uint32_t leds = 0;
                        for (uint32_t i = 0; i < WLR_LED_COUNT; ++i) {
-                                if (xkb_state_led_index_is_active(
+                                if (xkb_state_led_index_is_active(keyboard->wlr->xkb_state,
-                                                wlr_device->keyboard->xkb_state,
+                                                keyboard->wlr->led_indexes[i])) {
-                                                wlr_device->keyboard->led_indexes[i])) {
                                        leds |= (1 << i);
                                }
                        }
-                        if (wlr_device->keyboard->group) {
+                        if (keyboard->wlr->group) {
-                                wlr_keyboard_led_update(
+                                wlr_keyboard_led_update(&keyboard->wlr->group->keyboard, leds);
-                                                &wlr_device->keyboard->group->keyboard, leds);
                        } else {
-                                wlr_keyboard_led_update(wlr_device->keyboard, leds);
+                                wlr_keyboard_led_update(keyboard->wlr, leds);
                        }
                }
        } else {
                xkb_keymap_unref(keymap);
                sway_keyboard_group_remove_invalid(keyboard);
-                if (!wlr_device->keyboard->group) {
+                if (!keyboard->wlr->group) {
                        sway_keyboard_group_add(keyboard);
                }
        }
+        // If the seat has no active keyboard, set this one
        struct wlr_seat *seat = keyboard->seat_device->sway_seat->wlr_seat;
-        wlr_seat_set_keyboard(seat, wlr_device);
+        struct wlr_keyboard *current_keyboard = seat->keyboard_state.keyboard;
+        if (current_keyboard == NULL) {
+                wlr_seat_set_keyboard(seat, keyboard->wlr);
+        }
        wl_list_remove(&keyboard->keyboard_key.link);
-        wl_signal_add(&wlr_device->keyboard->events.key, &keyboard->keyboard_key);
+        wl_signal_add(&keyboard->wlr->events.key, &keyboard->keyboard_key);
        keyboard->keyboard_key.notify = handle_keyboard_key;
        wl_list_remove(&keyboard->keyboard_modifiers.link);
-        wl_signal_add(&wlr_device->keyboard->events.modifiers,
+        wl_signal_add(&keyboard->wlr->events.modifiers,
                &keyboard->keyboard_modifiers);
        keyboard->keyboard_modifiers.notify = handle_keyboard_modifiers;
@@ -1110,12 +1081,11 @@ void sway_keyboard_destroy(struct sway_keyboard *keyboard) {
        if (!keyboard) {
                return;
        }
-        if (keyboard->seat_device->input_device->wlr_device->keyboard->group) {
+        if (keyboard->wlr->group) {
                sway_keyboard_group_remove(keyboard);
        }
        struct wlr_seat *wlr_seat = keyboard->seat_device->sway_seat->wlr_seat;
-        struct sway_input_device *device = keyboard->seat_device->input_device;
+        if (wlr_seat_get_keyboard(wlr_seat) == keyboard->wlr) {
-        if (wlr_seat_get_keyboard(wlr_seat) == device->wlr_device->keyboard) {
                wlr_seat_set_keyboard(wlr_seat, NULL);
        }
        if (keyboard->keymap) {
diff --git a/sway/input/libinput.c b/sway/input/libinput.c
index 060a584a..0266c7a9 100644
--- a/sway/input/libinput.c
+++ b/sway/input/libinput.c
@@ -79,6 +79,16 @@ static bool set_accel_speed(struct libinput_device *device, double speed) {
        return true;
 }
+static bool set_rotation_angle(struct libinput_device *device, double angle) {
+        if (!libinput_device_config_rotation_is_available(device) ||
+                        libinput_device_config_rotation_get_angle(device) == angle) {
+                return false;
+        }
+        sway_log(SWAY_DEBUG, "rotation_set_angle(%f)", angle);
+        log_status(libinput_device_config_rotation_set_angle(device, angle));
+        return true;
+}
 static bool set_accel_profile(struct libinput_device *device,
                enum libinput_config_accel_profile profile) {
        if (!libinput_device_config_accel_is_available(device) ||
@@ -156,6 +166,18 @@ static bool set_scroll_button(struct libinput_device *dev, uint32_t button) {
        return true;
 }
+static bool set_scroll_button_lock(struct libinput_device *dev,
+                enum libinput_config_scroll_button_lock_state lock) {
+        uint32_t scroll = libinput_device_config_scroll_get_methods(dev);
+        if ((scroll & ~LIBINPUT_CONFIG_SCROLL_NO_SCROLL) == 0 ||
+                        libinput_device_config_scroll_get_button_lock(dev) == lock) {
+                return false;
+        }
+        sway_log(SWAY_DEBUG, "scroll_set_button_lock(%" PRIu32 ")", lock);
+        log_status(libinput_device_config_scroll_set_button_lock(dev, lock));
+        return true;
+}
 static bool set_dwt(struct libinput_device *device, bool dwt) {
        if (!libinput_device_config_dwt_is_available(device) ||
                        libinput_device_config_dwt_get_enabled(device) == dwt) {
@@ -166,6 +188,16 @@ static bool set_dwt(struct libinput_device *device, bool dwt) {
        return true;
 }
+static bool set_dwtp(struct libinput_device *device, bool dwtp) {
+        if (!libinput_device_config_dwtp_is_available(device) ||
+                        libinput_device_config_dwtp_get_enabled(device) == dwtp) {
+                return false;
+        }
+        sway_log(SWAY_DEBUG, "dwtp_set_enabled(%d)", dwtp);
+        log_status(libinput_device_config_dwtp_set_enabled(device, dwtp));
+        return true;
+}
 static bool set_calibration_matrix(struct libinput_device *dev, float mat[6]) {
        if (!libinput_device_config_calibration_has_matrix(dev)) {
                return false;
@@ -187,35 +219,38 @@ static bool set_calibration_matrix(struct libinput_device *dev, float mat[6]) {
        return changed;
 }
-void sway_input_configure_libinput_device(struct sway_input_device *input_device) {
+static bool configure_send_events(struct libinput_device *device,
-        struct input_config *ic = input_device_get_config(input_device);
+                struct input_config *ic) {
-        if (!ic || !wlr_input_device_is_libinput(input_device->wlr_device)) {
-                return;
-        }
-        struct libinput_device *device =
-                wlr_libinput_get_device_handle(input_device->wlr_device);
-        sway_log(SWAY_DEBUG, "sway_input_configure_libinput_device('%s' on '%s')",
-                        ic->identifier, input_device->identifier);
-        bool changed = false;
        if (ic->mapped_to_output &&
+                        strcmp("*", ic->mapped_to_output) != 0 &&
                        !output_by_name_or_id(ic->mapped_to_output)) {
                sway_log(SWAY_DEBUG,
                                "%s '%s' is mapped to offline output '%s'; disabling input",
                                ic->input_type, ic->identifier, ic->mapped_to_output);
-                changed |= set_send_events(device,
+                return set_send_events(device, LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
-                        LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
        } else if (ic->send_events != INT_MIN) {
-                changed |= set_send_events(device, ic->send_events);
+                return set_send_events(device, ic->send_events);
        } else {
                // Have to reset to the default mode here, otherwise if ic->send_events
                // is unset and a mapped output just came online after being disabled,
                // we'd remain stuck sending no events.
-                changed |= set_send_events(device,
+                return set_send_events(device,
                        libinput_device_config_send_events_get_default_mode(device));
        }
+}
+bool sway_input_configure_libinput_device(struct sway_input_device *input_device) {
+        struct input_config *ic = input_device_get_config(input_device);
+        if (!ic || !wlr_input_device_is_libinput(input_device->wlr_device)) {
+                return false;
+        }
+        struct libinput_device *device =
+                wlr_libinput_get_device_handle(input_device->wlr_device);
+        sway_log(SWAY_DEBUG, "sway_input_configure_libinput_device('%s' on '%s')",
+                        ic->identifier, input_device->identifier);
+        bool changed = configure_send_events(device, ic);
        if (ic->tap != INT_MIN) {
                changed |= set_tap(device, ic->tap);
        }
@@ -231,6 +266,9 @@ void sway_input_configure_libinput_device(struct sway_input_device *input_device
        if (ic->pointer_accel != FLT_MIN) {
                changed |= set_accel_speed(device, ic->pointer_accel);
        }
+        if (ic->rotation_angle != FLT_MIN) {
+                changed |= set_rotation_angle(device, ic->rotation_angle);
+        }
        if (ic->accel_profile != INT_MIN) {
                changed |= set_accel_profile(device, ic->accel_profile);
        }
@@ -252,13 +290,33 @@ void sway_input_configure_libinput_device(struct sway_input_device *input_device
        if (ic->scroll_button != INT_MIN) {
                changed |= set_scroll_button(device, ic->scroll_button);
        }
+        if (ic->scroll_button_lock != INT_MIN) {
+                changed |= set_scroll_button_lock(device, ic->scroll_button_lock);
+        }
        if (ic->dwt != INT_MIN) {
                changed |= set_dwt(device, ic->dwt);
        }
+        if (ic->dwtp != INT_MIN) {
+                changed |= set_dwtp(device, ic->dwtp);
+        }
        if (ic->calibration_matrix.configured) {
                changed |= set_calibration_matrix(device, ic->calibration_matrix.matrix);
        }
+        return changed;
+}
+void sway_input_configure_libinput_device_send_events(
+                struct sway_input_device *input_device) {
+        struct input_config *ic = input_device_get_config(input_device);
+        if (!ic || !wlr_input_device_is_libinput(input_device->wlr_device)) {
+                return;
+        }
+        struct libinput_device *device =
+                wlr_libinput_get_device_handle(input_device->wlr_device);
+        bool changed = configure_send_events(device, ic);
        if (changed) {
                ipc_event_input("libinput_config", input_device);
        }
@@ -287,6 +345,8 @@ void sway_input_reset_libinput_device(struct sway_input_device *input_device) {
                libinput_device_config_tap_get_default_drag_lock_enabled(device));
        changed |= set_accel_speed(device,
                libinput_device_config_accel_get_default_speed(device));
+        changed |= set_rotation_angle(device,
+                libinput_device_config_rotation_get_default_angle(device));
        changed |= set_accel_profile(device,
                libinput_device_config_accel_get_default_profile(device));
        changed |= set_natural_scroll(device,
@@ -304,6 +364,8 @@ void sway_input_reset_libinput_device(struct sway_input_device *input_device) {
                libinput_device_config_scroll_get_default_button(device));
        changed |= set_dwt(device,
                libinput_device_config_dwt_get_default_enabled(device));
+        changed |= set_dwtp(device,
+                libinput_device_config_dwtp_get_default_enabled(device));
        float matrix[6];
        libinput_device_config_calibration_get_default_matrix(device, matrix);
@@ -332,6 +394,13 @@ bool sway_libinput_device_is_builtin(struct sway_input_device *sway_device) {
                return false;
        }
-        const char prefix[] = "platform-";
+        const char prefix_platform[] = "platform-";
-        return strncmp(id_path, prefix, strlen(prefix)) == 0;
+        if (strncmp(id_path, prefix_platform, strlen(prefix_platform)) != 0) {
+                return false;
+        }
+        const char prefix_pci[] = "pci-";
+        const char infix_platform[] = "-platform-";
+        return (strncmp(id_path, prefix_pci, strlen(prefix_pci)) == 0) &&
+                strstr(id_path, infix_platform);
 }
diff --git a/sway/input/seat.c b/sway/input/seat.c
index 2d714acd..da4bb12a 100644
--- a/sway/input/seat.c
+++ b/sway/input/seat.c
@@ -1,22 +1,23 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <linux/input-event-codes.h>
 #include <string.h>
 #include <strings.h>
 #include <time.h>
+#include <wlr/config.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_data_device.h>
-#include <wlr/types/wlr_idle.h>
+#include <wlr/types/wlr_idle_notify_v1.h>
 #include <wlr/types/wlr_keyboard_group.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_primary_selection.h>
 #include <wlr/types/wlr_tablet_v2.h>
+#include <wlr/types/wlr_touch.h>
 #include <wlr/types/wlr_xcursor_manager.h>
 #include "config.h"
 #include "list.h"
 #include "log.h"
 #include "sway/config.h"
-#include "sway/desktop.h"
+#include "sway/scene_descriptor.h"
 #include "sway/input/cursor.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/keyboard.h"
@@ -42,6 +43,7 @@ static void seat_device_destroy(struct sway_seat_device *seat_device) {
        sway_keyboard_destroy(seat_device->keyboard);
        sway_tablet_destroy(seat_device->tablet);
        sway_tablet_pad_destroy(seat_device->tablet_pad);
+        sway_switch_destroy(seat_device->switch_device);
        wlr_cursor_detach_input_device(seat_device->sway_seat->cursor->cursor,
                seat_device->input_device->wlr_device);
        wl_list_remove(&seat_device->link);
@@ -51,10 +53,26 @@ static void seat_device_destroy(struct sway_seat_device *seat_device) {
 static void seat_node_destroy(struct sway_seat_node *seat_node) {
        wl_list_remove(&seat_node->destroy.link);
        wl_list_remove(&seat_node->link);
+        /*
+         * This is the only time we remove items from the focus stack without
+         * immediately re-adding them. If we just removed the last thing,
+         * mark that nothing has focus anymore.
+         */
+        if (wl_list_empty(&seat_node->seat->focus_stack)) {
+                seat_node->seat->has_focus = false;
+        }
        free(seat_node);
 }
 void seat_destroy(struct sway_seat *seat) {
+        wlr_seat_destroy(seat->wlr_seat);
+}
+static void handle_seat_destroy(struct wl_listener *listener, void *data) {
+        struct sway_seat *seat = wl_container_of(listener, seat, destroy);
        if (seat == config->handler_context.seat) {
                config->handler_context.seat = input_manager_get_default_seat();
        }
@@ -75,10 +93,11 @@ void seat_destroy(struct sway_seat *seat) {
        wl_list_remove(&seat->request_set_selection.link);
        wl_list_remove(&seat->request_set_primary_selection.link);
        wl_list_remove(&seat->link);
-        wlr_seat_destroy(seat->wlr_seat);
+        wl_list_remove(&seat->destroy.link);
        for (int i = 0; i < seat->deferred_bindings->length; i++) {
                free_sway_binding(seat->deferred_bindings->items[i]);
        }
+        wlr_scene_node_destroy(&seat->scene_tree->node);
        list_free(seat->deferred_bindings);
        free(seat->prev_workspace_name);
        free(seat);
@@ -86,21 +105,10 @@ void seat_destroy(struct sway_seat *seat) {
 void seat_idle_notify_activity(struct sway_seat *seat,
                enum sway_input_idle_source source) {
-        uint32_t mask = seat->idle_inhibit_sources;
+        if ((source & seat->idle_inhibit_sources) == 0) {
-        struct wlr_idle_timeout *timeout;
+                return;
-        int ntimers = 0, nidle = 0;
-        wl_list_for_each(timeout, &server.idle->idle_timers, link) {
-                ++ntimers;
-                if (timeout->idle_state) {
-                        ++nidle;
-                }
-        }
-        if (nidle == ntimers) {
-                mask = seat->idle_wake_sources;
-        }
-        if ((source & mask) > 0) {
-                wlr_idle_notify_activity(server.idle, seat->wlr_seat);
        }
+        wlr_idle_notifier_v1_notify_activity(server.idle_notifier_v1, seat->wlr_seat);
 }
 /**
@@ -130,7 +138,7 @@ static struct sway_keyboard *sway_keyboard_for_wlr_keyboard(
                if (input_device->wlr_device->type != WLR_INPUT_DEVICE_KEYBOARD) {
                        continue;
                }
-                if (input_device->wlr_device->keyboard == wlr_keyboard) {
+                if (input_device->wlr_device == &wlr_keyboard->base) {
                        return seat_device->keyboard;
                }
        }
@@ -138,7 +146,7 @@ static struct sway_keyboard *sway_keyboard_for_wlr_keyboard(
        wl_list_for_each(group, &seat->keyboard_groups, link) {
                struct sway_input_device *input_device =
                        group->seat_device->input_device;
-                if (input_device->wlr_device->keyboard == wlr_keyboard) {
+                if (input_device->wlr_device == &wlr_keyboard->base) {
                        return group->seat_device->keyboard;
                }
        }
@@ -162,11 +170,11 @@ static void seat_keyboard_notify_enter(struct sway_seat *seat,
                        state->pressed_keycodes, state->npressed, &keyboard->modifiers);
 }
-static void seat_tablet_pads_notify_enter(struct sway_seat *seat,
+static void seat_tablet_pads_set_focus(struct sway_seat *seat,
                struct wlr_surface *surface) {
        struct sway_seat_device *seat_device;
        wl_list_for_each(seat_device, &seat->devices, link) {
-                sway_tablet_pad_notify_enter(seat_device->tablet_pad, surface);
+                sway_tablet_pad_set_focus(seat_device->tablet_pad, surface);
        }
 }
@@ -182,7 +190,7 @@ static void seat_send_focus(struct sway_node *node, struct sway_seat *seat) {
                node->sway_container->view : NULL;
        if (view && seat_is_input_allowed(seat, view->surface)) {
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
                if (view->type == SWAY_VIEW_XWAYLAND) {
                        struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
                        wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
@@ -190,7 +198,7 @@ static void seat_send_focus(struct sway_node *node, struct sway_seat *seat) {
 #endif
                seat_keyboard_notify_enter(seat, view->surface);
-                seat_tablet_pads_notify_enter(seat, view->surface);
+                seat_tablet_pads_set_focus(seat, view->surface);
                sway_input_method_relay_set_focus(&seat->im_relay, view->surface);
                struct wlr_pointer_constraint_v1 *constraint =
@@ -210,14 +218,13 @@ void seat_for_each_node(struct sway_seat *seat,
 struct sway_container *seat_get_focus_inactive_view(struct sway_seat *seat,
                struct sway_node *ancestor) {
-        if (ancestor->type == N_CONTAINER && ancestor->sway_container->view) {
+        if (node_is_view(ancestor)) {
                return ancestor->sway_container;
        }
        struct sway_seat_node *current;
        wl_list_for_each(current, &seat->focus_stack, link) {
                struct sway_node *node = current->node;
-                if (node->type == N_CONTAINER && node->sway_container->view &&
+                if (node_is_view(node) && node_has_ancestor(node, ancestor)) {
-                                node_has_ancestor(node, ancestor)) {
                        return node->sway_container;
                }
        }
@@ -236,7 +243,7 @@ static void handle_seat_node_destroy(struct wl_listener *listener, void *data) {
                seat_node_destroy(seat_node);
                // If an unmanaged or layer surface is focused when an output gets
                // disabled and an empty workspace on the output was focused by the
-                // seat, the seat needs to refocus it's focus inactive to update the
+                // seat, the seat needs to refocus its focus inactive to update the
                // value of seat->workspace.
                if (seat->workspace == node->sway_workspace) {
                        struct sway_node *node = seat_get_focus_inactive(seat, &root->node);
@@ -352,25 +359,15 @@ static void handle_new_node(struct wl_listener *listener, void *data) {
        seat_node_from_node(seat, node);
 }
-static void drag_icon_damage_whole(struct sway_drag_icon *icon) {
+static void drag_icon_update_position(struct sway_seat *seat, struct wlr_scene_node *node) {
-        if (!icon->wlr_drag_icon->mapped) {
+        struct wlr_drag_icon *wlr_icon = scene_descriptor_try_get(node, SWAY_SCENE_DESC_DRAG_ICON);
-                return;
-        }
-        desktop_damage_surface(icon->wlr_drag_icon->surface, icon->x, icon->y, true);
-}
-void drag_icon_update_position(struct sway_drag_icon *icon) {
-        drag_icon_damage_whole(icon);
-        struct wlr_drag_icon *wlr_icon = icon->wlr_drag_icon;
-        struct sway_seat *seat = icon->seat;
        struct wlr_cursor *cursor = seat->cursor->cursor;
        switch (wlr_icon->drag->grab_type) {
        case WLR_DRAG_GRAB_KEYBOARD:
                return;
        case WLR_DRAG_GRAB_KEYBOARD_POINTER:
-                icon->x = cursor->x;
+                wlr_scene_node_set_position(node, cursor->x, cursor->y);
-                icon->y = cursor->y;
                break;
        case WLR_DRAG_GRAB_KEYBOARD_TOUCH:;
                struct wlr_touch_point *point =
@@ -378,39 +375,15 @@ void drag_icon_update_position(struct sway_drag_icon *icon) {
                if (point == NULL) {
                        return;
                }
-                icon->x = seat->touch_x;
+                wlr_scene_node_set_position(node, seat->touch_x, seat->touch_y);
-                icon->y = seat->touch_y;
        }
-        drag_icon_damage_whole(icon);
 }
-static void drag_icon_handle_surface_commit(struct wl_listener *listener,
+void drag_icons_update_position(struct sway_seat *seat) {
-                void *data) {
+        struct wlr_scene_node *node;
-        struct sway_drag_icon *icon =
+        wl_list_for_each(node, &seat->drag_icons->children, link) {
-                wl_container_of(listener, icon, surface_commit);
+                drag_icon_update_position(seat, node);
-        drag_icon_update_position(icon);
+        }
-}
-static void drag_icon_handle_map(struct wl_listener *listener, void *data) {
-        struct sway_drag_icon *icon = wl_container_of(listener, icon, map);
-        drag_icon_damage_whole(icon);
-}
-static void drag_icon_handle_unmap(struct wl_listener *listener, void *data) {
-        struct sway_drag_icon *icon = wl_container_of(listener, icon, unmap);
-        drag_icon_damage_whole(icon);
-}
-static void drag_icon_handle_destroy(struct wl_listener *listener, void *data) {
-        struct sway_drag_icon *icon = wl_container_of(listener, icon, destroy);
-        icon->wlr_drag_icon->data = NULL;
-        wl_list_remove(&icon->link);
-        wl_list_remove(&icon->surface_commit.link);
-        wl_list_remove(&icon->unmap.link);
-        wl_list_remove(&icon->map.link);
-        wl_list_remove(&icon->destroy.link);
-        free(icon);
 }
 static void drag_handle_destroy(struct wl_listener *listener, void *data) {
@@ -482,27 +455,20 @@ static void handle_start_drag(struct wl_listener *listener, void *data) {
        struct wlr_drag_icon *wlr_drag_icon = wlr_drag->icon;
        if (wlr_drag_icon != NULL) {
-                struct sway_drag_icon *icon = calloc(1, sizeof(struct sway_drag_icon));
+                struct wlr_scene_tree *tree = wlr_scene_drag_icon_create(seat->drag_icons, wlr_drag_icon);
-                if (icon == NULL) {
+                if (!tree) {
-                        sway_log(SWAY_ERROR, "Allocation failed");
+                        sway_log(SWAY_ERROR, "Failed to allocate a drag icon scene tree");
                        return;
                }
-                icon->seat = seat;
-                icon->wlr_drag_icon = wlr_drag_icon;
-                wlr_drag_icon->data = icon;
-                icon->surface_commit.notify = drag_icon_handle_surface_commit;
+                if (!scene_descriptor_assign(&tree->node, SWAY_SCENE_DESC_DRAG_ICON,
-                wl_signal_add(&wlr_drag_icon->surface->events.commit, &icon->surface_commit);
+                                wlr_drag_icon)) {
-                icon->unmap.notify = drag_icon_handle_unmap;
+                        sway_log(SWAY_ERROR, "Failed to allocate a drag icon scene descriptor");
-                wl_signal_add(&wlr_drag_icon->events.unmap, &icon->unmap);
+                        wlr_scene_node_destroy(&tree->node);
-                icon->map.notify = drag_icon_handle_map;
+                        return;
-                wl_signal_add(&wlr_drag_icon->events.map, &icon->map);
+                }
-                icon->destroy.notify = drag_icon_handle_destroy;
-                wl_signal_add(&wlr_drag_icon->events.destroy, &icon->destroy);
-                wl_list_insert(&root->drag_icons, &icon->link);
-                drag_icon_update_position(icon);
+                drag_icon_update_position(seat, &tree->node);
        }
        seatop_begin_default(seat);
 }
@@ -549,8 +515,18 @@ struct sway_seat *seat_create(const char *seat_name) {
                return NULL;
        }
+        bool failed = false;
+        seat->scene_tree = alloc_scene_tree(root->layers.seat, &failed);
+        seat->drag_icons = alloc_scene_tree(seat->scene_tree, &failed);
+        if (failed) {
+                wlr_scene_node_destroy(&seat->scene_tree->node);
+                free(seat);
+                return NULL;
+        }
        seat->wlr_seat = wlr_seat_create(server.wl_display, seat_name);
        if (!sway_assert(seat->wlr_seat, "could not allocate seat")) {
+                wlr_scene_node_destroy(&seat->scene_tree->node);
                free(seat);
                return NULL;
        }
@@ -558,11 +534,15 @@ struct sway_seat *seat_create(const char *seat_name) {
        seat->cursor = sway_cursor_create(seat);
        if (!seat->cursor) {
+                wlr_scene_node_destroy(&seat->scene_tree->node);
                wlr_seat_destroy(seat->wlr_seat);
                free(seat);
                return NULL;
        }
+        seat->destroy.notify = handle_seat_destroy;
+        wl_signal_add(&seat->wlr_seat->events.destroy, &seat->destroy);
        seat->idle_inhibit_sources = seat->idle_wake_sources =
                IDLE_SOURCE_KEYBOARD |
                IDLE_SOURCE_POINTER |
@@ -636,7 +616,7 @@ static void seat_update_capabilities(struct sway_seat *seat) {
                case WLR_INPUT_DEVICE_TOUCH:
                        caps |= WL_SEAT_CAPABILITY_TOUCH;
                        break;
-                case WLR_INPUT_DEVICE_TABLET_TOOL:
+                case WLR_INPUT_DEVICE_TABLET:
                        caps |= WL_SEAT_CAPABILITY_POINTER;
                        break;
                case WLR_INPUT_DEVICE_SWITCH:
@@ -654,7 +634,7 @@ static void seat_update_capabilities(struct sway_seat *seat) {
        } else {
                wlr_seat_set_capabilities(seat->wlr_seat, caps);
                if ((previous_caps & WL_SEAT_CAPABILITY_POINTER) == 0) {
-                        cursor_set_image(seat->cursor, "left_ptr", NULL);
+                        cursor_set_image(seat->cursor, "default", NULL);
                }
        }
 }
@@ -694,19 +674,28 @@ static const char *get_builtin_output_name(void) {
 static bool is_touch_or_tablet_tool(struct sway_seat_device *seat_device) {
        switch (seat_device->input_device->wlr_device->type) {
        case WLR_INPUT_DEVICE_TOUCH:
-        case WLR_INPUT_DEVICE_TABLET_TOOL:
+        case WLR_INPUT_DEVICE_TABLET:
                return true;
        default:
                return false;
        }
 }
-static void seat_apply_input_config(struct sway_seat *seat,
+static void seat_apply_input_mapping(struct sway_seat *seat,
                struct sway_seat_device *sway_device) {
        struct input_config *ic =
                input_device_get_config(sway_device->input_device);
-        sway_log(SWAY_DEBUG, "Applying input config to %s",
+        switch (sway_device->input_device->wlr_device->type) {
+        case WLR_INPUT_DEVICE_POINTER:
+        case WLR_INPUT_DEVICE_TOUCH:
+        case WLR_INPUT_DEVICE_TABLET:
+                break;
+        default:
+                return; // these devices don't support mappings
+        }
+        sway_log(SWAY_DEBUG, "Applying input mapping to %s",
                sway_device->input_device->identifier);
        const char *mapped_to_output = ic == NULL ? NULL : ic->mapped_to_output;
@@ -715,14 +704,26 @@ static void seat_apply_input_config(struct sway_seat *seat,
                ic == NULL ? MAPPED_TO_DEFAULT : ic->mapped_to;
        switch (mapped_to) {
-        case MAPPED_TO_DEFAULT:
+        case MAPPED_TO_DEFAULT:;
                /*
                 * If the wlroots backend provides an output name, use that.
                 *
-                 * Otherwise, try to map built-in touch and tablet tool devices to the
+                 * Otherwise, try to map built-in touch and pointer devices to the
                 * built-in output.
                 */
-                mapped_to_output = sway_device->input_device->wlr_device->output_name;
+                struct wlr_input_device *dev = sway_device->input_device->wlr_device;
+                switch (dev->type) {
+                case WLR_INPUT_DEVICE_POINTER:
+                        mapped_to_output = wlr_pointer_from_input_device(dev)->output_name;
+                        break;
+                case WLR_INPUT_DEVICE_TOUCH:
+                        mapped_to_output = wlr_touch_from_input_device(dev)->output_name;
+                        break;
+                default:
+                        mapped_to_output = NULL;
+                        break;
+                }
+#if WLR_HAS_LIBINPUT_BACKEND
                if (mapped_to_output == NULL && is_touch_or_tablet_tool(sway_device) &&
                                sway_libinput_device_is_builtin(sway_device->input_device)) {
                        mapped_to_output = get_builtin_output_name();
@@ -731,6 +732,10 @@ static void seat_apply_input_config(struct sway_seat *seat,
                                        mapped_to_output, sway_device->input_device->identifier);
                        }
                }
+#else
+                (void)is_touch_or_tablet_tool;
+                (void)get_builtin_output_name;
+#endif
                if (mapped_to_output == NULL) {
                        return;
                }
@@ -774,12 +779,9 @@ static void seat_apply_input_config(struct sway_seat *seat,
 static void seat_configure_pointer(struct sway_seat *seat,
                struct sway_seat_device *sway_device) {
-        if ((seat->wlr_seat->capabilities & WL_SEAT_CAPABILITY_POINTER) == 0) {
+        seat_configure_xcursor(seat);
-                seat_configure_xcursor(seat);
-        }
        wlr_cursor_attach_input_device(seat->cursor->cursor,
                sway_device->input_device->wlr_device);
-        seat_apply_input_config(seat, sway_device);
        wl_event_source_timer_update(
                        seat->cursor->hide_source, cursor_get_timeout(seat->cursor));
 }
@@ -790,13 +792,22 @@ static void seat_configure_keyboard(struct sway_seat *seat,
                sway_keyboard_create(seat, seat_device);
        }
        sway_keyboard_configure(seat_device->keyboard);
-        wlr_seat_set_keyboard(seat->wlr_seat,
-                        seat_device->input_device->wlr_device);
+        // We only need to update the current keyboard, as the rest will be updated
-        struct sway_node *focus = seat_get_focus(seat);
+        // as they are activated.
-        if (focus && node_is_view(focus)) {
+        struct wlr_keyboard *wlr_keyboard =
-                // force notify reenter to pick up the new configuration
+                wlr_keyboard_from_input_device(seat_device->input_device->wlr_device);
+        struct wlr_keyboard *current_keyboard = seat->wlr_seat->keyboard_state.keyboard;
+        if (wlr_keyboard != current_keyboard) {
+                return;
+        }
+        // force notify reenter to pick up the new configuration.  This reuses
+        // the current focused surface to avoid breaking input grabs.
+        struct wlr_surface *surface = seat->wlr_seat->keyboard_state.focused_surface;
+        if (surface) {
                wlr_seat_keyboard_notify_clear_focus(seat->wlr_seat);
-                seat_keyboard_notify_enter(seat, focus->sway_container->view->surface);
+                seat_keyboard_notify_enter(seat, surface);
        }
 }
@@ -805,7 +816,6 @@ static void seat_configure_switch(struct sway_seat *seat,
        if (!seat_device->switch_device) {
                sway_switch_create(seat, seat_device);
        }
-        seat_apply_input_config(seat, seat_device);
        sway_switch_configure(seat_device->switch_device);
 }
@@ -813,7 +823,6 @@ static void seat_configure_touch(struct sway_seat *seat,
                struct sway_seat_device *sway_device) {
        wlr_cursor_attach_input_device(seat->cursor->cursor,
                sway_device->input_device->wlr_device);
-        seat_apply_input_config(seat, sway_device);
 }
 static void seat_configure_tablet_tool(struct sway_seat *seat,
@@ -824,7 +833,6 @@ static void seat_configure_tablet_tool(struct sway_seat *seat,
        sway_configure_tablet(sway_device->tablet);
        wlr_cursor_attach_input_device(seat->cursor->cursor,
                sway_device->input_device->wlr_device);
-        seat_apply_input_config(seat, sway_device);
 }
 static void seat_configure_tablet_pad(struct sway_seat *seat,
@@ -874,13 +882,25 @@ void seat_configure_device(struct sway_seat *seat,
                case WLR_INPUT_DEVICE_TOUCH:
                        seat_configure_touch(seat, seat_device);
                        break;
-                case WLR_INPUT_DEVICE_TABLET_TOOL:
+                case WLR_INPUT_DEVICE_TABLET:
                        seat_configure_tablet_tool(seat, seat_device);
                        break;
                case WLR_INPUT_DEVICE_TABLET_PAD:
                        seat_configure_tablet_pad(seat, seat_device);
                        break;
        }
+        seat_apply_input_mapping(seat, seat_device);
+}
+void seat_configure_device_mapping(struct sway_seat *seat,
+                struct sway_input_device *input_device) {
+        struct sway_seat_device *seat_device = seat_get_device(seat, input_device);
+        if (!seat_device) {
+                return;
+        }
+        seat_apply_input_mapping(seat, seat_device);
 }
 void seat_reset_device(struct sway_seat *seat,
@@ -901,7 +921,7 @@ void seat_reset_device(struct sway_seat *seat,
                case WLR_INPUT_DEVICE_TOUCH:
                        seat_reset_input_config(seat, seat_device);
                        break;
-                case WLR_INPUT_DEVICE_TABLET_TOOL:
+                case WLR_INPUT_DEVICE_TABLET:
                        seat_reset_input_config(seat, seat_device);
                        break;
                case WLR_INPUT_DEVICE_TABLET_PAD:
@@ -982,7 +1002,7 @@ void seat_configure_xcursor(struct sway_seat *seat) {
                        setenv("XCURSOR_THEME", cursor_theme, 1);
                }
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
                if (server.xwayland.wlr_xwayland && (!server.xwayland.xcursor_manager ||
                                !xcursor_manager_is_named(server.xwayland.xcursor_manager,
                                        cursor_theme) ||
@@ -997,7 +1017,7 @@ void seat_configure_xcursor(struct sway_seat *seat) {
                        wlr_xcursor_manager_load(server.xwayland.xcursor_manager, 1);
                        struct wlr_xcursor *xcursor = wlr_xcursor_manager_get_xcursor(
-                                server.xwayland.xcursor_manager, "left_ptr", 1);
+                                server.xwayland.xcursor_manager, "default", 1);
                        if (xcursor != NULL) {
                                struct wlr_xcursor_image *image = xcursor->images[0];
                                wlr_xwayland_set_cursor(
@@ -1023,32 +1043,35 @@ void seat_configure_xcursor(struct sway_seat *seat) {
                        sway_log(SWAY_ERROR,
                                "Cannot create XCursor manager for theme '%s'", cursor_theme);
                }
-        }
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *sway_output = root->outputs->items[i];
+                for (int i = 0; i < root->outputs->length; ++i) {
-                struct wlr_output *output = sway_output->wlr_output;
+                        struct sway_output *sway_output = root->outputs->items[i];
-                bool result =
+                        struct wlr_output *output = sway_output->wlr_output;
-                        wlr_xcursor_manager_load(seat->cursor->xcursor_manager,
+                        bool result =
-                                output->scale);
+                                wlr_xcursor_manager_load(seat->cursor->xcursor_manager,
-                if (!result) {
+                                        output->scale);
-                        sway_log(SWAY_ERROR,
+                        if (!result) {
-                                "Cannot load xcursor theme for output '%s' with scale %f",
+                                sway_log(SWAY_ERROR,
-                                output->name, output->scale);
+                                        "Cannot load xcursor theme for output '%s' with scale %f",
+                                        output->name, output->scale);
+                        }
                }
-        }
-        // Reset the cursor so that we apply it to outputs that just appeared
+                // Reset the cursor so that we apply it to outputs that just appeared
-        cursor_set_image(seat->cursor, NULL, NULL);
+                cursor_set_image(seat->cursor, NULL, NULL);
-        cursor_set_image(seat->cursor, "left_ptr", NULL);
+                cursor_set_image(seat->cursor, "default", NULL);
-        wlr_cursor_warp(seat->cursor->cursor, NULL, seat->cursor->cursor->x,
+                wlr_cursor_warp(seat->cursor->cursor, NULL, seat->cursor->cursor->x,
-                seat->cursor->cursor->y);
+                        seat->cursor->cursor->y);
+        }
 }
 bool seat_is_input_allowed(struct sway_seat *seat,
                struct wlr_surface *surface) {
-        struct wl_client *client = wl_resource_get_client(surface->resource);
+        if (server.session_lock.lock) {
-        return !seat->exclusive_client || seat->exclusive_client == client;
+                return sway_session_lock_has_surface(server.session_lock.lock, surface);
+        }
+        return true;
 }
 static void send_unfocus(struct sway_container *con, void *data) {
@@ -1107,15 +1130,7 @@ void seat_set_raw_focus(struct sway_seat *seat, struct sway_node *node) {
        }
 }
-void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
+static void seat_set_workspace_focus(struct sway_seat *seat, struct sway_node *node) {
-        if (seat->focused_layer) {
-                struct wlr_layer_surface_v1 *layer = seat->focused_layer;
-                seat_set_focus_layer(seat, NULL);
-                seat_set_focus(seat, node);
-                seat_set_focus_layer(seat, layer);
-                return;
-        }
        struct sway_node *last_focus = seat_get_focus(seat);
        if (last_focus == node) {
                return;
@@ -1248,6 +1263,24 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
        }
 }
+void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
+        // Prevents the layer from losing focus if it has keyboard exclusivity
+        if (seat->has_exclusive_layer) {
+                struct wlr_layer_surface_v1 *layer = seat->focused_layer;
+                seat_set_focus_layer(seat, NULL);
+                seat_set_workspace_focus(seat, node);
+                seat_set_focus_layer(seat, layer);
+        } else if (seat->focused_layer) {
+                seat_set_focus_layer(seat, NULL);
+                seat_set_workspace_focus(seat, node);
+        } else {
+                seat_set_workspace_focus(seat, node);
+        }
+        if (server.session_lock.lock) {
+                seat_set_focus_surface(seat, server.session_lock.lock->focused, false);
+        }
+}
 void seat_set_focus_container(struct sway_seat *seat,
                struct sway_container *con) {
        seat_set_focus(seat, con ? &con->node : NULL);
@@ -1273,7 +1306,7 @@ void seat_set_focus_surface(struct sway_seat *seat,
        }
        sway_input_method_relay_set_focus(&seat->im_relay, surface);
-        seat_tablet_pads_notify_enter(seat, surface);
+        seat_tablet_pads_set_focus(seat, surface);
 }
 void seat_set_focus_layer(struct sway_seat *seat,
@@ -1287,28 +1320,23 @@ void seat_set_focus_layer(struct sway_seat *seat,
                        seat_set_focus(seat, previous);
                }
                return;
-        } else if (!layer || seat->focused_layer == layer) {
+        } else if (!layer) {
                return;
        }
-        assert(layer->mapped);
+        assert(layer->surface->mapped);
-        seat_set_focus_surface(seat, layer->surface, true);
+        if (layer->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP &&
-        if (layer->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP) {
+                        layer->current.keyboard_interactive
-                seat->focused_layer = layer;
+                        == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE) {
+                seat->has_exclusive_layer = true;
        }
-}
+        if (seat->focused_layer == layer) {
-void seat_set_exclusive_client(struct sway_seat *seat,
-                struct wl_client *client) {
-        if (!client) {
-                seat->exclusive_client = client;
-                // Triggers a refocus of the topmost surface layer if necessary
-                // TODO: Make layer surface focus per-output based on cursor position
-                for (int i = 0; i < root->outputs->length; ++i) {
-                        struct sway_output *output = root->outputs->items[i];
-                        arrange_layers(output);
-                }
                return;
        }
+        seat_set_focus_surface(seat, layer->surface, true);
+        seat->focused_layer = layer;
+}
+void seat_unfocus_unless_client(struct sway_seat *seat, struct wl_client *client) {
        if (seat->focused_layer) {
                if (wl_resource_get_client(seat->focused_layer->resource) != client) {
                        seat_set_focus_layer(seat, NULL);
@@ -1335,7 +1363,6 @@ void seat_set_exclusive_client(struct sway_seat *seat,
                                        now.tv_nsec / 1000, point->touch_id);
                }
        }
-        seat->exclusive_client = client;
 }
 struct sway_node *seat_get_focus_inactive(struct sway_seat *seat,
@@ -1416,9 +1443,8 @@ struct sway_node *seat_get_focus(struct sway_seat *seat) {
        if (!seat->has_focus) {
                return NULL;
        }
-        if (wl_list_empty(&seat->focus_stack)) {
+        sway_assert(!wl_list_empty(&seat->focus_stack),
-                return NULL;
+                        "focus_stack is empty, but has_focus is true");
-        }
        struct sway_seat_node *current =
                wl_container_of(seat->focus_stack.next, current, link);
        return current->node;
@@ -1503,7 +1529,7 @@ struct seat_config *seat_get_config_by_name(const char *name) {
 }
 void seat_pointer_notify_button(struct sway_seat *seat, uint32_t time_msec,
-                uint32_t button, enum wlr_button_state state) {
+                uint32_t button, enum wl_pointer_button_state state) {
        seat->last_button_serial = wlr_seat_pointer_notify_button(seat->wlr_seat,
                        time_msec, button, state);
 }
@@ -1540,7 +1566,7 @@ void seatop_unref(struct sway_seat *seat, struct sway_container *con) {
 void seatop_button(struct sway_seat *seat, uint32_t time_msec,
                struct wlr_input_device *device, uint32_t button,
-                enum wlr_button_state state) {
+                enum wl_pointer_button_state state) {
        if (seat->seatop_impl->button) {
                seat->seatop_impl->button(seat, time_msec, device, button, state);
        }
@@ -1553,12 +1579,38 @@ void seatop_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
 }
 void seatop_pointer_axis(struct sway_seat *seat,
-                struct wlr_event_pointer_axis *event) {
+                struct wlr_pointer_axis_event *event) {
        if (seat->seatop_impl->pointer_axis) {
                seat->seatop_impl->pointer_axis(seat, event);
        }
 }
+void seatop_touch_motion(struct sway_seat *seat, struct wlr_touch_motion_event *event,
+                double lx, double ly) {
+        if (seat->seatop_impl->touch_motion) {
+                seat->seatop_impl->touch_motion(seat, event, lx, ly);
+        }
+}
+void seatop_touch_up(struct sway_seat *seat, struct wlr_touch_up_event *event) {
+        if (seat->seatop_impl->touch_up) {
+                seat->seatop_impl->touch_up(seat, event);
+        }
+}
+void seatop_touch_down(struct sway_seat *seat, struct wlr_touch_down_event *event,
+                double lx, double ly) {
+        if (seat->seatop_impl->touch_down) {
+                seat->seatop_impl->touch_down(seat, event, lx, ly);
+        }
+}
+void seatop_touch_cancel(struct sway_seat *seat, struct wlr_touch_cancel_event *event) {
+        if (seat->seatop_impl->touch_cancel) {
+                seat->seatop_impl->touch_cancel(seat, event);
+        }
+}
 void seatop_tablet_tool_tip(struct sway_seat *seat,
                struct sway_tablet_tool *tool, uint32_t time_msec,
                enum wlr_tablet_tool_tip_state state) {
@@ -1576,6 +1628,62 @@ void seatop_tablet_tool_motion(struct sway_seat *seat,
        }
 }
+void seatop_hold_begin(struct sway_seat *seat,
+                struct wlr_pointer_hold_begin_event *event) {
+        if (seat->seatop_impl->hold_begin) {
+                seat->seatop_impl->hold_begin(seat, event);
+        }
+}
+void seatop_hold_end(struct sway_seat *seat,
+                struct wlr_pointer_hold_end_event *event) {
+        if (seat->seatop_impl->hold_end) {
+                seat->seatop_impl->hold_end(seat, event);
+        }
+}
+void seatop_pinch_begin(struct sway_seat *seat,
+                struct wlr_pointer_pinch_begin_event *event) {
+        if (seat->seatop_impl->pinch_begin) {
+                seat->seatop_impl->pinch_begin(seat, event);
+        }
+}
+void seatop_pinch_update(struct sway_seat *seat,
+                struct wlr_pointer_pinch_update_event *event) {
+        if (seat->seatop_impl->pinch_update) {
+                seat->seatop_impl->pinch_update(seat, event);
+        }
+}
+void seatop_pinch_end(struct sway_seat *seat,
+                struct wlr_pointer_pinch_end_event *event) {
+        if (seat->seatop_impl->pinch_end) {
+                seat->seatop_impl->pinch_end(seat, event);
+        }
+}
+void seatop_swipe_begin(struct sway_seat *seat,
+                struct wlr_pointer_swipe_begin_event *event) {
+        if (seat->seatop_impl->swipe_begin) {
+                seat->seatop_impl->swipe_begin(seat, event);
+        }
+}
+void seatop_swipe_update(struct sway_seat *seat,
+                struct wlr_pointer_swipe_update_event *event) {
+        if (seat->seatop_impl->swipe_update) {
+                seat->seatop_impl->swipe_update(seat, event);
+        }
+}
+void seatop_swipe_end(struct sway_seat *seat,
+                struct wlr_pointer_swipe_end_event *event) {
+        if (seat->seatop_impl->swipe_end) {
+                seat->seatop_impl->swipe_end(seat, event);
+        }
+}
 void seatop_rebase(struct sway_seat *seat, uint32_t time_msec) {
        if (seat->seatop_impl->rebase) {
                seat->seatop_impl->rebase(seat, time_msec);
@@ -1591,13 +1699,6 @@ void seatop_end(struct sway_seat *seat) {
        seat->seatop_impl = NULL;
 }
-void seatop_render(struct sway_seat *seat, struct sway_output *output,
-                pixman_region32_t *damage) {
-        if (seat->seatop_impl->render) {
-                seat->seatop_impl->render(seat, output, damage);
-        }
-}
 bool seatop_allows_set_cursor(struct sway_seat *seat) {
        return seat->seatop_impl->allow_set_cursor;
 }
diff --git a/sway/input/seatop_default.c b/sway/input/seatop_default.c
index f9eb8c8a..e01fa933 100644
--- a/sway/input/seatop_default.c
+++ b/sway/input/seatop_default.c
@@ -1,18 +1,21 @@
-#define _POSIX_C_SOURCE 200809L
 #include <float.h>
 #include <libevdev/libevdev.h>
 #include <wlr/types/wlr_cursor.h>
+#include <wlr/types/wlr_subcompositor.h>
 #include <wlr/types/wlr_tablet_v2.h>
 #include <wlr/types/wlr_xcursor_manager.h>
+#include "gesture.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
 #include "sway/input/tablet.h"
+#include "sway/layers.h"
 #include "sway/output.h"
+#include "sway/scene_descriptor.h"
 #include "sway/tree/view.h"
 #include "sway/tree/workspace.h"
 #include "log.h"
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
 #include "sway/xwayland.h"
 #endif
@@ -20,6 +23,7 @@ struct seatop_default_event {
        struct sway_node *previous_node;
        uint32_t pressed_buttons[SWAY_CURSOR_PRESSED_BUTTONS_CAP];
        size_t pressed_button_count;
+        struct gesture_tracker gestures;
 };
 /*-----------------------------------------\
@@ -51,6 +55,9 @@ static bool edge_is_external(struct sway_container *cont, enum wlr_edges edge) {
        while (cont) {
                if (container_parent_layout(cont) == layout) {
                        list_t *siblings = container_get_siblings(cont);
+                        if (!siblings) {
+                                return false;
+                        }
                        int index = list_find(siblings, cont);
                        if (index > 0 && (edge == WLR_EDGE_LEFT || edge == WLR_EDGE_TOP)) {
                                return false;
@@ -226,14 +233,15 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
        struct sway_container *cont = node && node->type == N_CONTAINER ?
                node->sway_container : NULL;
-        if (wlr_surface_is_layer_surface(surface)) {
+        struct wlr_layer_surface_v1 *layer;
+#if WLR_HAS_XWAYLAND
+        struct wlr_xwayland_surface *xsurface;
+#endif
+        if ((layer = wlr_layer_surface_v1_try_from_wlr_surface(surface)) &&
+                        layer->current.keyboard_interactive) {
                // Handle tapping a layer surface
-                struct wlr_layer_surface_v1 *layer =
+                seat_set_focus_layer(seat, layer);
-                                wlr_layer_surface_v1_from_wlr_surface(surface);
+                transaction_commit_dirty();
-                if (layer->current.keyboard_interactive) {
-                        seat_set_focus_layer(seat, layer);
-                        transaction_commit_dirty();
-                }
        } else if (cont) {
                bool is_floating_or_child = container_is_floating_or_child(cont);
                bool is_fullscreen_or_child = container_is_fullscreen_or_child(cont);
@@ -258,20 +266,17 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
                // Handle tapping on a container surface
                seat_set_focus_container(seat, cont);
-                seatop_begin_down(seat, node->sway_container, time_msec, sx, sy);
+                seatop_begin_down(seat, node->sway_container, sx, sy);
        }
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        // Handle tapping on an xwayland unmanaged view
-        else if (wlr_surface_is_xwayland_surface(surface)) {
+        else if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(surface)) &&
-                struct wlr_xwayland_surface *xsurface =
+                        xsurface->override_redirect &&
-                                wlr_xwayland_surface_from_wlr_surface(surface);
+                        wlr_xwayland_or_surface_wants_focus(xsurface)) {
-                if (xsurface->override_redirect &&
+                struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
-                                wlr_xwayland_or_surface_wants_focus(xsurface)) {
+                wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
-                        struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
+                seat_set_focus_surface(seat, xsurface->surface, false);
-                        wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
+                transaction_commit_dirty();
-                        seat_set_focus_surface(seat, xsurface->surface, false);
-                        transaction_commit_dirty();
-                }
        }
 #endif
@@ -285,7 +290,7 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
 static bool trigger_pointer_button_binding(struct sway_seat *seat,
                struct wlr_input_device *device, uint32_t button,
-                enum wlr_button_state state, uint32_t modifiers,
+                enum wl_pointer_button_state state, uint32_t modifiers,
                bool on_titlebar, bool on_border, bool on_contents, bool on_workspace) {
        // We can reach this for non-pointer devices if we're currently emulating
        // pointer input for one. Emulated input should not trigger bindings. The
@@ -299,7 +304,7 @@ static bool trigger_pointer_button_binding(struct sway_seat *seat,
        char *device_identifier = device ? input_device_get_identifier(device)
                : strdup("*");
        struct sway_binding *binding = NULL;
-        if (state == WLR_BUTTON_PRESSED) {
+        if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
                state_add_button(e, button);
                binding = get_active_mouse_binding(e,
                        config->current_mode->mouse_bindings, modifiers, false,
@@ -324,7 +329,7 @@ static bool trigger_pointer_button_binding(struct sway_seat *seat,
 static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                struct wlr_input_device *device, uint32_t button,
-                enum wlr_button_state state) {
+                enum wl_pointer_button_state state) {
        struct sway_cursor *cursor = seat->cursor;
        // Determine what's under the cursor
@@ -357,7 +362,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
        // Handle clicking an empty workspace
        if (node && node->type == N_WORKSPACE) {
-                if (state == WLR_BUTTON_PRESSED) {
+                if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
                        seat_set_focus(seat, node);
                        transaction_commit_dirty();
                }
@@ -365,21 +370,23 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                return;
        }
-        // Handle clicking a layer surface
+        // Handle clicking a layer surface and its popups/subsurfaces
-        if (surface && wlr_surface_is_layer_surface(surface)) {
+        struct wlr_layer_surface_v1 *layer = NULL;
-                struct wlr_layer_surface_v1 *layer =
+        if ((layer = toplevel_layer_surface_from_surface(surface))) {
-                        wlr_layer_surface_v1_from_wlr_surface(surface);
                if (layer->current.keyboard_interactive) {
                        seat_set_focus_layer(seat, layer);
                        transaction_commit_dirty();
                }
+                if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
+                        seatop_begin_down_on_surface(seat, surface, sx, sy);
+                }
                seat_pointer_notify_button(seat, time_msec, button, state);
                return;
        }
        // Handle tiling resize via border
        if (cont && resize_edge && button == BTN_LEFT &&
-                        state == WLR_BUTTON_PRESSED && !is_floating) {
+                        state == WL_POINTER_BUTTON_STATE_PRESSED && !is_floating) {
                // If a resize is triggered on a tabbed or stacked container, change
                // focus to the tab which already had inactive focus -- otherwise, we'd
                // change the active tab when the user probably just wanted to resize.
@@ -397,7 +404,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
        // Handle tiling resize via mod
        bool mod_pressed = modifiers & config->floating_mod;
        if (cont && !is_floating_or_child && mod_pressed &&
-                        state == WLR_BUTTON_PRESSED) {
+                        state == WL_POINTER_BUTTON_STATE_PRESSED) {
                uint32_t btn_resize = config->floating_mod_inverse ?
                        BTN_LEFT : BTN_RIGHT;
                if (button == btn_resize) {
@@ -424,13 +431,31 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                }
        }
+        // Handle changing focus when clicking on a container
+        if (cont && state == WL_POINTER_BUTTON_STATE_PRESSED) {
+                // Default case: focus the container that was just clicked.
+                node = &cont->node;
+                // If the container is a tab/stacked container and the click happened
+                // on a tab, switch to the tab. If the tab contents were already
+                // focused, focus the tab container itself. If the tab container was
+                // already focused, cycle back to focusing the tab contents.
+                if (on_titlebar) {
+                        struct sway_container *focus = seat_get_focused_container(seat);
+                        if (focus == cont || !container_has_ancestor(focus, cont)) {
+                                node = seat_get_focus_inactive(seat, &cont->node);
+                        }
+                }
+                seat_set_focus(seat, node);
+                transaction_commit_dirty();
+        }
        // Handle beginning floating move
        if (cont && is_floating_or_child && !is_fullscreen_or_child &&
-                        state == WLR_BUTTON_PRESSED) {
+                        state == WL_POINTER_BUTTON_STATE_PRESSED) {
                uint32_t btn_move = config->floating_mod_inverse ? BTN_RIGHT : BTN_LEFT;
                if (button == btn_move && (mod_pressed || on_titlebar)) {
-                        seat_set_focus_container(seat,
-                                        seat_get_focus_inactive_view(seat, &cont->node));
                        seatop_begin_move_floating(seat, container_toplevel_ancestor(cont));
                        return;
                }
@@ -438,9 +463,10 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
        // Handle beginning floating resize
        if (cont && is_floating_or_child && !is_fullscreen_or_child &&
-                        state == WLR_BUTTON_PRESSED) {
+                        state == WL_POINTER_BUTTON_STATE_PRESSED) {
                // Via border
                if (button == BTN_LEFT && resize_edge != WLR_EDGE_NONE) {
+                        seat_set_focus_container(seat, cont);
                        seatop_begin_resize_floating(seat, cont, resize_edge);
                        return;
                }
@@ -455,6 +481,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                                WLR_EDGE_RIGHT : WLR_EDGE_LEFT;
                        edge |= cursor->cursor->y > floater->pending.y + floater->pending.height / 2 ?
                                WLR_EDGE_BOTTOM : WLR_EDGE_TOP;
+                        seat_set_focus_container(seat, floater);
                        seatop_begin_resize_floating(seat, floater, edge);
                        return;
                }
@@ -462,55 +489,43 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
        // Handle moving a tiling container
        if (config->tiling_drag && (mod_pressed || on_titlebar) &&
-                        state == WLR_BUTTON_PRESSED && !is_floating_or_child &&
+                        state == WL_POINTER_BUTTON_STATE_PRESSED && !is_floating_or_child &&
                        cont && cont->pending.fullscreen_mode == FULLSCREEN_NONE) {
-                struct sway_container *focus = seat_get_focused_container(seat);
+                // If moving a container by its title bar, use a threshold for the drag
-                bool focused = focus == cont || container_has_ancestor(focus, cont);
-                if (on_titlebar && !focused) {
-                        node = seat_get_focus_inactive(seat, &cont->node);
-                        seat_set_focus(seat, node);
-                }
-                // If moving a container by it's title bar, use a threshold for the drag
                if (!mod_pressed && config->tiling_drag_threshold > 0) {
                        seatop_begin_move_tiling_threshold(seat, cont);
                } else {
                        seatop_begin_move_tiling(seat, cont);
                }
                return;
        }
        // Handle mousedown on a container surface
-        if (surface && cont && state == WLR_BUTTON_PRESSED) {
+        if (surface && cont && state == WL_POINTER_BUTTON_STATE_PRESSED) {
-                seat_set_focus_container(seat, cont);
+                seatop_begin_down(seat, cont, sx, sy);
-                seatop_begin_down(seat, cont, time_msec, sx, sy);
+                seat_pointer_notify_button(seat, time_msec, button, WL_POINTER_BUTTON_STATE_PRESSED);
-                seat_pointer_notify_button(seat, time_msec, button, WLR_BUTTON_PRESSED);
                return;
        }
        // Handle clicking a container surface or decorations
-        if (cont && state == WLR_BUTTON_PRESSED) {
+        if (cont && state == WL_POINTER_BUTTON_STATE_PRESSED) {
-                node = seat_get_focus_inactive(seat, &cont->node);
-                seat_set_focus(seat, node);
-                transaction_commit_dirty();
                seat_pointer_notify_button(seat, time_msec, button, state);
                return;
        }
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        // Handle clicking on xwayland unmanaged view
-        if (surface && wlr_surface_is_xwayland_surface(surface)) {
+        struct wlr_xwayland_surface *xsurface;
-                struct wlr_xwayland_surface *xsurface =
+        if (surface &&
-                        wlr_xwayland_surface_from_wlr_surface(surface);
+                        (xsurface = wlr_xwayland_surface_try_from_wlr_surface(surface)) &&
-                if (xsurface->override_redirect &&
+                        xsurface->override_redirect &&
-                                wlr_xwayland_or_surface_wants_focus(xsurface)) {
+                        wlr_xwayland_or_surface_wants_focus(xsurface)) {
-                        struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
+                struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
-                        wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
+                wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
-                        seat_set_focus_surface(seat, xsurface->surface, false);
+                seat_set_focus_surface(seat, xsurface->surface, false);
-                        transaction_commit_dirty();
+                transaction_commit_dirty();
-                        seat_pointer_notify_button(seat, time_msec, button, state);
+                seat_pointer_notify_button(seat, time_msec, button, state);
-                        return;
-                }
        }
 #endif
@@ -533,6 +548,21 @@ static void check_focus_follows_mouse(struct sway_seat *seat,
                if (wlr_output == NULL) {
                        return;
                }
+                struct wlr_surface *surface = NULL;
+                double sx, sy;
+                node_at_coords(seat, seat->cursor->cursor->x, seat->cursor->cursor->y,
+                                &surface, &sx, &sy);
+                // Focus topmost layer surface
+                struct wlr_layer_surface_v1 *layer = NULL;
+                if ((layer = toplevel_layer_surface_from_surface(surface)) &&
+                                layer->current.keyboard_interactive) {
+                        seat_set_focus_layer(seat, layer);
+                        transaction_commit_dirty();
+                        return;
+                }
                struct sway_output *hovered_output = wlr_output->data;
                if (focus && hovered_output != node_get_output(focus)) {
                        struct sway_workspace *ws = output_get_active_workspace(hovered_output);
@@ -593,12 +623,7 @@ static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
                wlr_seat_pointer_notify_clear_focus(seat->wlr_seat);
        }
-        struct sway_drag_icon *drag_icon;
+        drag_icons_update_position(seat);
-        wl_list_for_each(drag_icon, &root->drag_icons, link) {
-                if (drag_icon->seat == seat) {
-                        drag_icon_update_position(drag_icon);
-                }
-        }
        e->previous_node = node;
 }
@@ -628,25 +653,50 @@ static void handle_tablet_tool_motion(struct sway_seat *seat,
                wlr_tablet_v2_tablet_tool_notify_proximity_out(tool->tablet_v2_tool);
        }
-        struct sway_drag_icon *drag_icon;
+        drag_icons_update_position(seat);
-        wl_list_for_each(drag_icon, &root->drag_icons, link) {
-                if (drag_icon->seat == seat) {
-                        drag_icon_update_position(drag_icon);
-                }
-        }
        e->previous_node = node;
 }
+static void handle_touch_down(struct sway_seat *seat,
+                struct wlr_touch_down_event *event, double lx, double ly) {
+        struct wlr_surface *surface = NULL;
+        struct wlr_seat *wlr_seat = seat->wlr_seat;
+        struct sway_cursor *cursor = seat->cursor;
+        double sx, sy;
+        node_at_coords(seat, seat->touch_x, seat->touch_y, &surface, &sx, &sy);
+        if (surface && wlr_surface_accepts_touch(wlr_seat, surface)) {
+                if (seat_is_input_allowed(seat, surface)) {
+                        cursor->simulating_pointer_from_touch = false;
+                        seatop_begin_touch_down(seat, surface, event, sx, sy, lx, ly);
+                }
+        } else if (!cursor->simulating_pointer_from_touch &&
+                        (!surface || seat_is_input_allowed(seat, surface))) {
+                // Fallback to cursor simulation.
+                // The pointer_touch_id state is needed, so drags are not aborted when over
+                // a surface supporting touch and multi touch events don't interfere.
+                cursor->simulating_pointer_from_touch = true;
+                cursor->pointer_touch_id = seat->touch_id;
+                double dx, dy;
+                dx = seat->touch_x - cursor->cursor->x;
+                dy = seat->touch_y - cursor->cursor->y;
+                pointer_motion(cursor, event->time_msec, &event->touch->base, dx, dy,
+                                dx, dy);
+                dispatch_cursor_button(cursor, &event->touch->base, event->time_msec,
+                                BTN_LEFT, WL_POINTER_BUTTON_STATE_PRESSED);
+        }
+}
 /*----------------------------------------\
 * Functions used by handle_pointer_axis  /
 *--------------------------------------*/
-static uint32_t wl_axis_to_button(struct wlr_event_pointer_axis *event) {
+static uint32_t wl_axis_to_button(struct wlr_pointer_axis_event *event) {
        switch (event->orientation) {
-        case WLR_AXIS_ORIENTATION_VERTICAL:
+        case WL_POINTER_AXIS_VERTICAL_SCROLL:
                return event->delta < 0 ? SWAY_SCROLL_UP : SWAY_SCROLL_DOWN;
-        case WLR_AXIS_ORIENTATION_HORIZONTAL:
+        case WL_POINTER_AXIS_HORIZONTAL_SCROLL:
                return event->delta < 0 ? SWAY_SCROLL_LEFT : SWAY_SCROLL_RIGHT;
        default:
                sway_log(SWAY_DEBUG, "Unknown axis orientation");
@@ -655,9 +705,9 @@ static uint32_t wl_axis_to_button(struct wlr_event_pointer_axis *event) {
 }
 static void handle_pointer_axis(struct sway_seat *seat,
-                struct wlr_event_pointer_axis *event) {
+                struct wlr_pointer_axis_event *event) {
        struct sway_input_device *input_device =
-                event->device ? event->device->data : NULL;
+                event->pointer ? event->pointer->base.data : NULL;
        struct input_config *ic =
                input_device ? input_device_get_config(input_device) : NULL;
        struct sway_cursor *cursor = seat->cursor;
@@ -703,6 +753,7 @@ static void handle_pointer_axis(struct sway_seat *seat,
        // Scrolling on a tabbed or stacked title bar (handled as press event)
        if (!handled && (on_titlebar || on_titlebar_border)) {
+                struct sway_node *new_focus;
                enum sway_container_layout layout = container_parent_layout(cont);
                if (layout == L_TABBED || layout == L_STACKED) {
                        struct sway_node *tabcontainer = node_get_parent(node);
@@ -710,7 +761,7 @@ static void handle_pointer_axis(struct sway_seat *seat,
                                seat_get_active_tiling_child(seat, tabcontainer);
                        list_t *siblings = container_get_siblings(cont);
                        int desired = list_find(siblings, active->sway_container) +
-                                round(scroll_factor * event->delta_discrete);
+                                roundf(scroll_factor * event->delta_discrete / WLR_POINTER_AXIS_DISCRETE_STEP);
                        if (desired < 0) {
                                desired = 0;
                        } else if (desired >= siblings->length) {
@@ -719,14 +770,16 @@ static void handle_pointer_axis(struct sway_seat *seat,
                        struct sway_container *new_sibling_con = siblings->items[desired];
                        struct sway_node *new_sibling = &new_sibling_con->node;
-                        struct sway_node *new_focus =
-                                seat_get_focus_inactive(seat, new_sibling);
                        // Use the focused child of the tabbed/stacked container, not the
                        // container the user scrolled on.
-                        seat_set_focus(seat, new_focus);
+                        new_focus = seat_get_focus_inactive(seat, new_sibling);
-                        transaction_commit_dirty();
+                } else {
-                        handled = true;
+                        new_focus = seat_get_focus_inactive(seat, &cont->node);
                }
+                seat_set_focus(seat, new_focus);
+                transaction_commit_dirty();
+                handled = true;
        }
        // Handle mouse bindings - x11 mouse buttons 4-7 - release event
@@ -742,8 +795,307 @@ static void handle_pointer_axis(struct sway_seat *seat,
        if (!handled) {
                wlr_seat_pointer_notify_axis(cursor->seat->wlr_seat, event->time_msec,
-                        event->orientation, scroll_factor * event->delta,
+                        event->orientation, scroll_factor * event->delta, 
-                        round(scroll_factor * event->delta_discrete), event->source);
+                        roundf(scroll_factor * event->delta_discrete), event->source,
+                        event->relative_direction);
+        }
+}
+/*------------------------------------\
+ * Functions used by gesture support  /
+ *----------------------------------*/
+/**
+ * Check gesture binding for a specific gesture type and finger count.
+ * Returns true if binding is present, false otherwise
+ */
+static bool gesture_binding_check(list_t *bindings, enum gesture_type type,
+                uint8_t fingers, struct sway_input_device *device) {
+        char *input =
+                device ? input_device_get_identifier(device->wlr_device) : strdup("*");
+        for (int i = 0; i < bindings->length; ++i) {
+                struct sway_gesture_binding *binding = bindings->items[i];
+                // Check type and finger count
+                if (!gesture_check(&binding->gesture, type, fingers)) {
+                        continue;
+                }
+                // Check that input matches
+                if (strcmp(binding->input, "*") != 0 &&
+                        strcmp(binding->input, input) != 0) {
+                        continue;
+                }
+                free(input);
+                return true;
+        }
+        free(input);
+        return false;
+}
+/**
+ * Return the gesture binding which matches gesture type, finger count
+ * and direction, otherwise return null.
+ */
+static struct sway_gesture_binding* gesture_binding_match(
+                list_t *bindings, struct gesture *gesture, const char *input) {
+        struct sway_gesture_binding *current = NULL;
+        // Find best matching binding
+        for (int i = 0; i < bindings->length; ++i) {
+                struct sway_gesture_binding *binding = bindings->items[i];
+                bool exact = binding->flags & BINDING_EXACT;
+                // Check gesture matching
+                if (!gesture_match(&binding->gesture, gesture, exact)) {
+                        continue;
+                }
+                // Check input matching
+                if (strcmp(binding->input, "*") != 0 &&
+                                strcmp(binding->input, input) != 0) {
+                        continue;
+                }
+                // If we already have a match ...
+                if (current) {
+                        // ... check if input matching is equivalent
+                        if (strcmp(current->input, binding->input) == 0) {
+                                // ... - do not override an exact binding
+                                if (!exact && current->flags & BINDING_EXACT) {
+                                        continue;
+                                }
+                                // ... - and ensure direction matching is better or equal
+                                if (gesture_compare(&current->gesture, &binding->gesture) > 0) {
+                                        continue;
+                                }
+                        } else if (strcmp(binding->input, "*") == 0) {
+                                // ... do not accept worse input match
+                                continue;
+                        }
+                }
+                // Accept newer or better match
+                current = binding;
+                // If exact binding and input is found, quit search
+                if (strcmp(current->input, input) == 0 &&
+                                gesture_compare(&current->gesture, gesture) == 0) {
+                        break;
+                }
+        } // for all gesture bindings
+        return current;
+}
+// Wrapper around gesture_tracker_end to use tracker with sway bindings
+static struct sway_gesture_binding* gesture_tracker_end_and_match(
+                struct gesture_tracker *tracker, struct sway_input_device* device) {
+        // Determine name of input that received gesture
+        char *input = device
+                ? input_device_get_identifier(device->wlr_device)
+                : strdup("*");
+        // Match tracking result to binding
+        struct gesture *gesture = gesture_tracker_end(tracker);
+        struct sway_gesture_binding *binding = gesture_binding_match(
+                        config->current_mode->gesture_bindings, gesture, input);
+        free(gesture);
+        free(input);
+        return binding;
+}
+// Small wrapper around seat_execute_command to work on gesture bindings
+static void gesture_binding_execute(struct sway_seat *seat,
+                struct sway_gesture_binding *binding) {
+        struct sway_binding *dummy_binding =
+                calloc(1, sizeof(struct sway_binding));
+        dummy_binding->type = BINDING_GESTURE;
+        dummy_binding->command = binding->command;
+        char *description = gesture_to_string(&binding->gesture);
+        sway_log(SWAY_DEBUG, "executing gesture binding: %s", description);
+        free(description);
+        seat_execute_command(seat, dummy_binding);
+        free(dummy_binding);
+}
+static void handle_hold_begin(struct sway_seat *seat,
+                struct wlr_pointer_hold_begin_event *event) {
+        // Start tracking gesture if there is a matching binding ...
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        list_t *bindings = config->current_mode->gesture_bindings;
+        if (gesture_binding_check(bindings, GESTURE_TYPE_HOLD, event->fingers, device)) {
+                struct seatop_default_event *seatop = seat->seatop_data;
+                gesture_tracker_begin(&seatop->gestures, GESTURE_TYPE_HOLD, event->fingers);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_hold_begin(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->fingers);
+        }
+}
+static void handle_hold_end(struct sway_seat *seat,
+                struct wlr_pointer_hold_end_event *event) {
+        // Ensure that gesture is being tracked and was not cancelled
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (!gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_HOLD)) {
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_hold_end(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->cancelled);
+                return;
+        }
+        if (event->cancelled) {
+                gesture_tracker_cancel(&seatop->gestures);
+                return;
+        }
+        // End gesture tracking and execute matched binding
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        struct sway_gesture_binding *binding = gesture_tracker_end_and_match(
+                &seatop->gestures, device);
+        if (binding) {
+                gesture_binding_execute(seat, binding);
+        }
+}
+static void handle_pinch_begin(struct sway_seat *seat,
+                struct wlr_pointer_pinch_begin_event *event) {
+        // Start tracking gesture if there is a matching binding ...
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        list_t *bindings = config->current_mode->gesture_bindings;
+        if (gesture_binding_check(bindings, GESTURE_TYPE_PINCH, event->fingers, device)) {
+                struct seatop_default_event *seatop = seat->seatop_data;
+                gesture_tracker_begin(&seatop->gestures, GESTURE_TYPE_PINCH, event->fingers);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_pinch_begin(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->fingers);
+        }
+}
+static void handle_pinch_update(struct sway_seat *seat,
+                struct wlr_pointer_pinch_update_event *event) {
+        // Update any ongoing tracking ...
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_PINCH)) {
+                gesture_tracker_update(&seatop->gestures, event->dx, event->dy,
+                        event->scale, event->rotation);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_pinch_update(
+                        server.input->pointer_gestures,
+                        cursor->seat->wlr_seat,
+                        event->time_msec, event->dx, event->dy,
+                        event->scale, event->rotation);
+        }
+}
+static void handle_pinch_end(struct sway_seat *seat,
+                struct wlr_pointer_pinch_end_event *event) {
+        // Ensure that gesture is being tracked and was not cancelled
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (!gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_PINCH)) {
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_pinch_end(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->cancelled);
+                return;
+        }
+        if (event->cancelled) {
+                gesture_tracker_cancel(&seatop->gestures);
+                return;
+        }
+        // End gesture tracking and execute matched binding
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        struct sway_gesture_binding *binding = gesture_tracker_end_and_match(
+                &seatop->gestures, device);
+        if (binding) {
+                gesture_binding_execute(seat, binding);
+        }
+}
+static void handle_swipe_begin(struct sway_seat *seat,
+                struct wlr_pointer_swipe_begin_event *event) {
+        // Start tracking gesture if there is a matching binding ...
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        list_t *bindings = config->current_mode->gesture_bindings;
+        if (gesture_binding_check(bindings, GESTURE_TYPE_SWIPE, event->fingers, device)) {
+                struct seatop_default_event *seatop = seat->seatop_data;
+                gesture_tracker_begin(&seatop->gestures, GESTURE_TYPE_SWIPE, event->fingers);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_swipe_begin(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->fingers);
+        }
+}
+static void handle_swipe_update(struct sway_seat *seat,
+                struct wlr_pointer_swipe_update_event *event) {
+        // Update any ongoing tracking ...
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_SWIPE)) {
+                gesture_tracker_update(&seatop->gestures,
+                        event->dx, event->dy, NAN, NAN);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_swipe_update(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->dx, event->dy);
+        }
+}
+static void handle_swipe_end(struct sway_seat *seat,
+                struct wlr_pointer_swipe_end_event *event) {
+        // Ensure gesture is being tracked and was not cancelled
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (!gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_SWIPE)) {
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_swipe_end(server.input->pointer_gestures,
+                        cursor->seat->wlr_seat, event->time_msec, event->cancelled);
+                return;
+        }
+        if (event->cancelled) {
+                gesture_tracker_cancel(&seatop->gestures);
+                return;
+        }
+        // End gesture tracking and execute matched binding
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        struct sway_gesture_binding *binding = gesture_tracker_end_and_match(
+                &seatop->gestures, device);
+        if (binding) {
+                gesture_binding_execute(seat, binding);
        }
 }
@@ -776,6 +1128,15 @@ static const struct sway_seatop_impl seatop_impl = {
        .pointer_axis = handle_pointer_axis,
        .tablet_tool_tip = handle_tablet_tool_tip,
        .tablet_tool_motion = handle_tablet_tool_motion,
+        .hold_begin = handle_hold_begin,
+        .hold_end = handle_hold_end,
+        .pinch_begin = handle_pinch_begin,
+        .pinch_update = handle_pinch_update,
+        .pinch_end = handle_pinch_end,
+        .swipe_begin = handle_swipe_begin,
+        .swipe_update = handle_swipe_update,
+        .swipe_end = handle_swipe_end,
+        .touch_down = handle_touch_down,
        .rebase = handle_rebase,
        .allow_set_cursor = true,
 };
@@ -786,8 +1147,8 @@ void seatop_begin_default(struct sway_seat *seat) {
        struct seatop_default_event *e =
                calloc(1, sizeof(struct seatop_default_event));
        sway_assert(e, "Unable to allocate seatop_default_event");
        seat->seatop_impl = &seatop_impl;
        seat->seatop_data = e;
        seatop_rebase(seat, 0);
 }
diff --git a/sway/input/seatop_down.c b/sway/input/seatop_down.c
index 844cf5ab..340e334b 100644
--- a/sway/input/seatop_down.c
+++ b/sway/input/seatop_down.c
@@ -1,23 +1,138 @@
-#define _POSIX_C_SOURCE 200809L
 #include <float.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_tablet_v2.h>
+#include <wlr/types/wlr_touch.h>
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
 #include "sway/tree/view.h"
 #include "sway/desktop/transaction.h"
 #include "log.h"
+struct seatop_touch_point_event {
+        double ref_lx, ref_ly;         // touch's x/y at start of op
+        double ref_con_lx, ref_con_ly; // container's x/y at start of op
+        int32_t touch_id;
+        struct wl_list link;
+};
 struct seatop_down_event {
        struct sway_container *con;
+        struct sway_seat *seat;
+        struct wl_listener surface_destroy;
+        struct wlr_surface *surface;
        double ref_lx, ref_ly;         // cursor's x/y at start of op
        double ref_con_lx, ref_con_ly; // container's x/y at start of op
+        struct wl_list point_events;   // seatop_touch_point_event::link
 };
+static void handle_touch_motion(struct sway_seat *seat,
+                struct wlr_touch_motion_event *event, double lx, double ly) {
+        struct seatop_down_event *e = seat->seatop_data;
+        struct seatop_touch_point_event *point_event;
+        bool found = false;
+        wl_list_for_each(point_event, &e->point_events, link) {
+                if (point_event->touch_id == event->touch_id) {
+                        found = true;
+                        break;
+                }
+        }
+        if (!found) {
+                return; // Probably not a point_event from this seatop_down
+        }
+        double moved_x = lx - point_event->ref_lx;
+        double moved_y = ly - point_event->ref_ly;
+        double sx = point_event->ref_con_lx + moved_x;
+        double sy = point_event->ref_con_ly + moved_y;
+        wlr_seat_touch_notify_motion(seat->wlr_seat, event->time_msec,
+                event->touch_id, sx, sy);
+}
+static void handle_touch_up(struct sway_seat *seat,
+                struct wlr_touch_up_event *event) {
+        struct seatop_down_event *e = seat->seatop_data;
+        struct seatop_touch_point_event *point_event, *tmp;
+        wl_list_for_each_safe(point_event, tmp, &e->point_events, link) {
+                if (point_event->touch_id == event->touch_id) {
+                        wl_list_remove(&point_event->link);
+                        free(point_event);
+                        break;
+                }
+        }
+        wlr_seat_touch_notify_up(seat->wlr_seat, event->time_msec, event->touch_id);
+        if (wl_list_empty(&e->point_events)) {
+                seatop_begin_default(seat);
+        }
+}
+static void handle_touch_down(struct sway_seat *seat,
+                struct wlr_touch_down_event *event, double lx, double ly) {
+        struct seatop_down_event *e = seat->seatop_data;
+        double sx, sy;
+        struct wlr_surface *surface = NULL;
+        struct sway_node *focused_node = node_at_coords(seat, seat->touch_x,
+                seat->touch_y, &surface, &sx, &sy);
+        if (!surface || surface != e->surface) { // Must start from the initial surface
+                return;
+        }
+        struct seatop_touch_point_event *point_event =
+                calloc(1, sizeof(struct seatop_touch_point_event));
+        if (!sway_assert(point_event, "Unable to allocate point_event")) {
+                return;
+        }
+        point_event->touch_id = event->touch_id;
+        point_event->ref_lx = lx;
+        point_event->ref_ly = ly;
+        point_event->ref_con_lx = sx;
+        point_event->ref_con_ly = sy;
+        wl_list_insert(&e->point_events, &point_event->link);
+        wlr_seat_touch_notify_down(seat->wlr_seat, surface, event->time_msec,
+                        event->touch_id, sx, sy);
+        if (focused_node) {
+            seat_set_focus(seat, focused_node);
+        }
+}
+static void handle_touch_cancel(struct sway_seat *seat,
+                struct wlr_touch_cancel_event *event) {
+        struct seatop_down_event *e = seat->seatop_data;
+        struct seatop_touch_point_event *point_event, *tmp;
+        wl_list_for_each_safe(point_event, tmp, &e->point_events, link) {
+                if (point_event->touch_id == event->touch_id) {
+                        wl_list_remove(&point_event->link);
+                        free(point_event);
+                        break;
+                }
+        }
+        if (e->surface) {
+                struct wl_client *client = wl_resource_get_client(e->surface->resource);
+                struct wlr_seat_client *seat_client = wlr_seat_client_for_wl_client(seat->wlr_seat, client);
+                if (seat_client != NULL) {
+                        wlr_seat_touch_notify_cancel(seat->wlr_seat, seat_client);
+                }
+        }
+        if (wl_list_empty(&e->point_events)) {
+                seatop_begin_default(seat);
+        }
+}
 static void handle_pointer_axis(struct sway_seat *seat,
-                struct wlr_event_pointer_axis *event) {
+                struct wlr_pointer_axis_event *event) {
        struct sway_input_device *input_device =
-                event->device ? event->device->data : NULL;
+                event->pointer ? event->pointer->base.data : NULL;
        struct input_config *ic =
                input_device ? input_device_get_config(input_device) : NULL;
        float scroll_factor =
@@ -25,12 +140,13 @@ static void handle_pointer_axis(struct sway_seat *seat,
        wlr_seat_pointer_notify_axis(seat->wlr_seat, event->time_msec,
                event->orientation, scroll_factor * event->delta,
-                round(scroll_factor * event->delta_discrete), event->source);
+                roundf(scroll_factor * event->delta_discrete), event->source,
+                event->relative_direction);
 }
 static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                struct wlr_input_device *device, uint32_t button,
-                enum wlr_button_state state) {
+                enum wl_pointer_button_state state) {
        seat_pointer_notify_button(seat, time_msec, button, state);
        if (seat->cursor->pressed_button_count == 0) {
@@ -40,8 +156,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
 static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
        struct seatop_down_event *e = seat->seatop_data;
-        struct sway_container *con = e->con;
+        if (seat_is_input_allowed(seat, e->surface)) {
-        if (seat_is_input_allowed(seat, con->view->surface)) {
                double moved_x = seat->cursor->cursor->x - e->ref_lx;
                double moved_y = seat->cursor->cursor->y - e->ref_ly;
                double sx = e->ref_con_lx + moved_x;
@@ -62,8 +177,7 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
 static void handle_tablet_tool_motion(struct sway_seat *seat,
                struct sway_tablet_tool *tool, uint32_t time_msec) {
        struct seatop_down_event *e = seat->seatop_data;
-        struct sway_container *con = e->con;
+        if (seat_is_input_allowed(seat, e->surface)) {
-        if (seat_is_input_allowed(seat, con->view->surface)) {
                double moved_x = seat->cursor->cursor->x - e->ref_lx;
                double moved_y = seat->cursor->cursor->y - e->ref_ly;
                double sx = e->ref_con_lx + moved_x;
@@ -72,6 +186,14 @@ static void handle_tablet_tool_motion(struct sway_seat *seat,
        }
 }
+static void handle_destroy(struct wl_listener *listener, void *data) {
+        struct seatop_down_event *e =
+                wl_container_of(listener, e, surface_destroy);
+        if (e) {
+                seatop_begin_default(e->seat);
+        }
+}
 static void handle_unref(struct sway_seat *seat, struct sway_container *con) {
        struct seatop_down_event *e = seat->seatop_data;
        if (e->con == con) {
@@ -79,34 +201,63 @@ static void handle_unref(struct sway_seat *seat, struct sway_container *con) {
        }
 }
+static void handle_end(struct sway_seat *seat) {
+        struct seatop_down_event *e = seat->seatop_data;
+        wl_list_remove(&e->surface_destroy.link);
+}
 static const struct sway_seatop_impl seatop_impl = {
        .button = handle_button,
        .pointer_motion = handle_pointer_motion,
        .pointer_axis = handle_pointer_axis,
        .tablet_tool_tip = handle_tablet_tool_tip,
        .tablet_tool_motion = handle_tablet_tool_motion,
+        .touch_motion = handle_touch_motion,
+        .touch_up = handle_touch_up,
+        .touch_down = handle_touch_down,
+        .touch_cancel = handle_touch_cancel,
        .unref = handle_unref,
+        .end = handle_end,
        .allow_set_cursor = true,
 };
 void seatop_begin_down(struct sway_seat *seat, struct sway_container *con,
-                uint32_t time_msec, int sx, int sy) {
+                double sx, double sy) {
+        seatop_begin_down_on_surface(seat, con->view->surface, sx, sy);
+        struct seatop_down_event *e = seat->seatop_data;
+        e->con = con;
+        container_raise_floating(con);
+        transaction_commit_dirty();
+}
+void seatop_begin_touch_down(struct sway_seat *seat,
+                struct wlr_surface *surface, struct wlr_touch_down_event *event,
+                double sx, double sy, double lx, double ly) {
+        seatop_begin_down_on_surface(seat, surface, sx, sy);
+        handle_touch_down(seat, event, lx, ly);
+}
+void seatop_begin_down_on_surface(struct sway_seat *seat,
+                struct wlr_surface *surface, double sx, double sy) {
        seatop_end(seat);
        struct seatop_down_event *e =
                calloc(1, sizeof(struct seatop_down_event));
-        if (!e) {
+        if (!sway_assert(e, "Unable to allocate e")) {
                return;
        }
-        e->con = con;
+        e->con = NULL;
+        e->seat = seat;
+        e->surface = surface;
+        wl_signal_add(&e->surface->events.destroy, &e->surface_destroy);
+        e->surface_destroy.notify = handle_destroy;
        e->ref_lx = seat->cursor->cursor->x;
        e->ref_ly = seat->cursor->cursor->y;
        e->ref_con_lx = sx;
        e->ref_con_ly = sy;
+        wl_list_init(&e->point_events);
        seat->seatop_impl = &seatop_impl;
        seat->seatop_data = e;
-        container_raise_floating(con);
-        transaction_commit_dirty();
 }
diff --git a/sway/input/seatop_move_floating.c b/sway/input/seatop_move_floating.c
index ddcd4c53..83668d88 100644
--- a/sway/input/seatop_move_floating.c
+++ b/sway/input/seatop_move_floating.c
@@ -1,6 +1,4 @@
-#define _POSIX_C_SOURCE 200809L
 #include <wlr/types/wlr_cursor.h>
-#include "sway/desktop.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
@@ -23,7 +21,7 @@ static void finalize_move(struct sway_seat *seat) {
 static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                struct wlr_input_device *device, uint32_t button,
-                enum wlr_button_state state) {
+                enum wl_pointer_button_state state) {
        if (seat->cursor->pressed_button_count == 0) {
                finalize_move(seat);
        }
@@ -39,9 +37,7 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
 static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
        struct seatop_move_floating_event *e = seat->seatop_data;
        struct wlr_cursor *cursor = seat->cursor->cursor;
-        desktop_damage_whole_container(e->con);
        container_floating_move_to(e->con, cursor->x - e->dx, cursor->y - e->dy);
-        desktop_damage_whole_container(e->con);
        transaction_commit_dirty();
 }
diff --git a/sway/input/seatop_move_tiling.c b/sway/input/seatop_move_tiling.c
index 223c6c08..c525b77a 100644
--- a/sway/input/seatop_move_tiling.c
+++ b/sway/input/seatop_move_tiling.c
@@ -1,8 +1,6 @@
-#define _POSIX_C_SOURCE 200809L
 #include <limits.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/util/edges.h>
-#include "sway/desktop.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
@@ -24,29 +22,17 @@ struct seatop_move_tiling_event {
        struct sway_container *con;
        struct sway_node *target_node;
        enum wlr_edges target_edge;
-        struct wlr_box drop_box;
        double ref_lx, ref_ly; // cursor's x/y at start of op
        bool threshold_reached;
        bool split_target;
        bool insert_after_target;
+        struct wlr_scene_rect *indicator_rect;
 };
-static void handle_render(struct sway_seat *seat,
+static void handle_end(struct sway_seat *seat) {
-                struct sway_output *output, pixman_region32_t *damage) {
        struct seatop_move_tiling_event *e = seat->seatop_data;
-        if (!e->threshold_reached) {
+        wlr_scene_node_destroy(&e->indicator_rect->node);
-                return;
+        e->indicator_rect = NULL;
-        }
-        if (e->target_node && node_get_output(e->target_node) == output) {
-                float color[4];
-                memcpy(&color, config->border_colors.focused.indicator,
-                                sizeof(float) * 4);
-                premultiply_alpha(color, 0.5);
-                struct wlr_box box;
-                memcpy(&box, &e->drop_box, sizeof(struct wlr_box));
-                scale_box(&box, output->wlr_output->scale);
-                render_rect(output, damage, &box, color);
-        }
 }
 static void handle_motion_prethreshold(struct sway_seat *seat) {
@@ -67,6 +53,7 @@ static void handle_motion_prethreshold(struct sway_seat *seat) {
        // If the threshold has been exceeded, start the actual drag
        if ((cx - sx) * (cx - sx) + (cy - sy) * (cy - sy) > threshold) {
+                wlr_scene_node_set_enabled(&e->indicator_rect->node, true);
                e->threshold_reached = true;
                cursor_set_image(seat->cursor, "grab", NULL);
        }
@@ -165,6 +152,11 @@ static bool split_titlebar(struct sway_node *node, struct sway_container *avoid,
        return false;
 }
+static void update_indicator(struct seatop_move_tiling_event *e, struct wlr_box *box) {
+        wlr_scene_node_set_position(&e->indicator_rect->node, box->x, box->y);
+        wlr_scene_rect_set_size(e->indicator_rect, box->width, box->height);
+}
 static void handle_motion_postthreshold(struct sway_seat *seat) {
        struct seatop_move_tiling_event *e = seat->seatop_data;
        e->split_target = false;
@@ -173,8 +165,6 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
        struct sway_cursor *cursor = seat->cursor;
        struct sway_node *node = node_at_coords(seat,
                        cursor->cursor->x, cursor->cursor->y, &surface, &sx, &sy);
-        // Damage the old location
-        desktop_damage_box(&e->drop_box);
        if (!node) {
                // Eg. hovered over a layer surface such as swaybar
@@ -187,8 +177,10 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
                // Empty workspace
                e->target_node = node;
                e->target_edge = WLR_EDGE_NONE;
-                workspace_get_box(node->sway_workspace, &e->drop_box);
-                desktop_damage_box(&e->drop_box);
+                struct wlr_box drop_box;
+                workspace_get_box(node->sway_workspace, &drop_box);
+                update_indicator(e, &drop_box);
                return;
        }
@@ -201,11 +193,18 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
                return;
        }
+        struct wlr_box drop_box = {
+                .x = con->pending.content_x,
+                .y = con->pending.content_y,
+                .width = con->pending.content_width,
+                .height = con->pending.content_height,
+        };
        // Check if the cursor is over a tilebar only if the destination
        // container is not a descendant of the source container.
        if (!surface && !container_has_ancestor(con, e->con) &&
                        split_titlebar(node, e->con, cursor->cursor,
-                                &e->drop_box, &e->insert_after_target)) {
+                                &drop_box, &e->insert_after_target)) {
                // Don't allow dropping over the source container's titlebar
                // to give users a chance to cancel a drag operation.
                if (con == e->con) {
@@ -215,6 +214,7 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
                        e->split_target = true;
                }
                e->target_edge = WLR_EDGE_NONE;
+                update_indicator(e, &drop_box);
                return;
        }
@@ -256,8 +256,7 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
                                e->target_node = node_get_parent(e->target_node);
                        }
                        e->target_edge = edge;
-                        e->drop_box = box;
+                        update_indicator(e, &box);
-                        desktop_damage_box(&e->drop_box);
                        return;
                }
                con = con->pending.parent;
@@ -299,12 +298,8 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
        }
        e->target_node = node;
-        e->drop_box.x = con->pending.content_x;
+        resize_box(&drop_box, e->target_edge, thickness);
-        e->drop_box.y = con->pending.content_y;
+        update_indicator(e, &drop_box);
-        e->drop_box.width = con->pending.content_width;
-        e->drop_box.height = con->pending.content_height;
-        resize_box(&e->drop_box, e->target_edge, thickness);
-        desktop_damage_box(&e->drop_box);
 }
 static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
@@ -410,7 +405,7 @@ static void finalize_move(struct sway_seat *seat) {
 static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                struct wlr_input_device *device, uint32_t button,
-                enum wlr_button_state state) {
+                enum wl_pointer_button_state state) {
        if (seat->cursor->pressed_button_count == 0) {
                finalize_move(seat);
        }
@@ -439,7 +434,7 @@ static const struct sway_seatop_impl seatop_impl = {
        .pointer_motion = handle_pointer_motion,
        .tablet_tool_tip = handle_tablet_tool_tip,
        .unref = handle_unref,
-        .render = handle_render,
+        .end = handle_end,
 };
 void seatop_begin_move_tiling_threshold(struct sway_seat *seat,
@@ -451,6 +446,20 @@ void seatop_begin_move_tiling_threshold(struct sway_seat *seat,
        if (!e) {
                return;
        }
+        const float *indicator = config->border_colors.focused.indicator;
+        float color[4] = {
+                indicator[0] * .5,
+                indicator[1] * .5,
+                indicator[2] * .5,
+                indicator[3] * .5,
+        };
+        e->indicator_rect = wlr_scene_rect_create(seat->scene_tree, 0, 0, color);
+        if (!e->indicator_rect) {
+                free(e);
+                return;
+        }
        e->con = con;
        e->ref_lx = seat->cursor->cursor->x;
        e->ref_ly = seat->cursor->cursor->y;
diff --git a/sway/input/seatop_resize_floating.c b/sway/input/seatop_resize_floating.c
index 8400a4b3..bec86e33 100644
--- a/sway/input/seatop_resize_floating.c
+++ b/sway/input/seatop_resize_floating.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <limits.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_xcursor_manager.h>
@@ -21,7 +20,7 @@ struct seatop_resize_floating_event {
 static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                struct wlr_input_device *device, uint32_t button,
-                enum wlr_button_state state) {
+                enum wl_pointer_button_state state) {
        struct seatop_resize_floating_event *e = seat->seatop_data;
        struct sway_container *con = e->con;
@@ -80,17 +79,25 @@ static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
        double height = e->ref_height + grow_height;
        int min_width, max_width, min_height, max_height;
        floating_calculate_constraints(&min_width, &max_width,
-                        &min_height, &max_height);
+                &min_height, &max_height);
-        width = fmax(min_width + border_width, fmin(width, max_width));
+        width = fmin(width, max_width - border_width);
-        height = fmax(min_height + border_height, fmin(height, max_height));
+        width = fmax(width, min_width + border_width);
+        width = fmax(width, 1);
+        height = fmin(height, max_height - border_height);
+        height = fmax(height, min_height + border_height);
+        height = fmax(height, 1);
        // Apply the view's min/max size
        if (con->view) {
                double view_min_width, view_max_width, view_min_height, view_max_height;
                view_get_constraints(con->view, &view_min_width, &view_max_width,
                                &view_min_height, &view_max_height);
-                width = fmax(view_min_width + border_width, fmin(width, view_max_width));
+                width = fmin(width, view_max_width - border_width);
-                height = fmax(view_min_height + border_height, fmin(height, view_max_height));
+                width = fmax(width, view_min_width + border_width);
+                width = fmax(width, 1);
+                height = fmin(height, view_max_height - border_height);
+                height = fmax(height, view_min_height + border_height);
+                height = fmax(height, 1);
        }
diff --git a/sway/input/seatop_resize_tiling.c b/sway/input/seatop_resize_tiling.c
index 869d11b5..15fd333b 100644
--- a/sway/input/seatop_resize_tiling.c
+++ b/sway/input/seatop_resize_tiling.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/util/edges.h>
 #include "sway/commands.h"
@@ -46,7 +45,7 @@ static struct sway_container *container_get_resize_sibling(
 static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                struct wlr_input_device *device, uint32_t button,
-                enum wlr_button_state state) {
+                enum wl_pointer_button_state state) {
        struct seatop_resize_tiling_event *e = seat->seatop_data;
        if (seat->cursor->pressed_button_count == 0) {
diff --git a/sway/input/switch.c b/sway/input/switch.c
index 9ea87a1a..831f4dbf 100644
--- a/sway/input/switch.c
+++ b/sway/input/switch.c
@@ -1,6 +1,5 @@
 #include "sway/config.h"
 #include "sway/input/switch.h"
-#include <wlr/types/wlr_idle.h>
 #include "log.h"
 struct sway_switch *sway_switch_create(struct sway_seat *seat,
@@ -11,6 +10,7 @@ struct sway_switch *sway_switch_create(struct sway_seat *seat,
                return NULL;
        }
        device->switch_device = switch_device;
+        switch_device->wlr = wlr_switch_from_input_device(device->input_device->wlr_device);
        switch_device->seat_device = device;
        switch_device->state = WLR_SWITCH_STATE_OFF;
        wl_list_init(&switch_device->switch_toggle.link);
@@ -19,9 +19,22 @@ struct sway_switch *sway_switch_create(struct sway_seat *seat,
        return switch_device;
 }
+static bool sway_switch_trigger_test(enum sway_switch_trigger trigger,
+                enum wlr_switch_state state) {
+        switch (trigger) {
+        case SWAY_SWITCH_TRIGGER_ON:
+                return state == WLR_SWITCH_STATE_ON;
+        case SWAY_SWITCH_TRIGGER_OFF:
+                return state == WLR_SWITCH_STATE_OFF;
+        case SWAY_SWITCH_TRIGGER_TOGGLE:
+                return true;
+        }
+        abort(); // unreachable
+}
 static void execute_binding(struct sway_switch *sway_switch) {
-        struct sway_seat* seat = sway_switch->seat_device->sway_seat;
+        struct sway_seat *seat = sway_switch->seat_device->sway_seat;
-        bool input_inhibited = seat->exclusive_client != NULL;
+        bool locked = server.session_lock.lock;
        list_t *bindings = config->current_mode->switch_bindings;
        struct sway_switch_binding *matched_binding = NULL;
@@ -30,22 +43,21 @@ static void execute_binding(struct sway_switch *sway_switch) {
                if (binding->type != sway_switch->type) {
                        continue;
                }
-                if (binding->state != WLR_SWITCH_STATE_TOGGLE &&
+                if (!sway_switch_trigger_test(binding->trigger, sway_switch->state)) {
-                                binding->state != sway_switch->state) {
                        continue;
                }
-                if (config->reloading && (binding->state == WLR_SWITCH_STATE_TOGGLE
+                if (config->reloading && (binding->trigger == SWAY_SWITCH_TRIGGER_TOGGLE
                                || (binding->flags & BINDING_RELOAD) == 0)) {
                        continue;
                }
                bool binding_locked = binding->flags & BINDING_LOCKED;
-                if (!binding_locked && input_inhibited) {
+                if (!binding_locked && locked) {
                        continue;
                }
                matched_binding = binding;
-                if (binding_locked == input_inhibited) {
+                if (binding_locked == locked) {
                        break;
                }
        }
@@ -65,7 +77,7 @@ static void execute_binding(struct sway_switch *sway_switch) {
 static void handle_switch_toggle(struct wl_listener *listener, void *data) {
        struct sway_switch *sway_switch =
                        wl_container_of(listener, sway_switch, switch_toggle);
-        struct wlr_event_switch_toggle *event = data;
+        struct wlr_switch_toggle_event *event = data;
        struct sway_seat *seat = sway_switch->seat_device->sway_seat;
        seat_idle_notify_activity(seat, IDLE_SOURCE_SWITCH);
@@ -82,10 +94,8 @@ static void handle_switch_toggle(struct wl_listener *listener, void *data) {
 }
 void sway_switch_configure(struct sway_switch *sway_switch) {
-        struct wlr_input_device *wlr_device =
-                sway_switch->seat_device->input_device->wlr_device;
        wl_list_remove(&sway_switch->switch_toggle.link);
-        wl_signal_add(&wlr_device->switch_device->events.toggle,
+        wl_signal_add(&sway_switch->wlr->events.toggle,
                        &sway_switch->switch_toggle);
        sway_switch->switch_toggle.notify = handle_switch_toggle;
        sway_log(SWAY_DEBUG, "Configured switch for device");
diff --git a/sway/input/tablet.c b/sway/input/tablet.c
index 26e86e36..2863642a 100644
--- a/sway/input/tablet.c
+++ b/sway/input/tablet.c
@@ -1,6 +1,5 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdlib.h>
-#include <wlr/backend/libinput.h>
+#include <wlr/config.h>
 #include <wlr/types/wlr_tablet_v2.h>
 #include <wlr/types/wlr_tablet_tool.h>
 #include <wlr/types/wlr_tablet_pad.h>
@@ -9,6 +8,10 @@
 #include "sway/input/seat.h"
 #include "sway/input/tablet.h"
+#if WLR_HAS_LIBINPUT_BACKEND
+#include <wlr/backend/libinput.h>
+#endif
 static void handle_pad_tablet_destroy(struct wl_listener *listener, void *data) {
        struct sway_tablet_pad *pad =
                wl_container_of(listener, pad, tablet_destroy);
@@ -54,15 +57,14 @@ void sway_configure_tablet(struct sway_tablet *tablet) {
                tablet->seat_device->input_device->wlr_device;
        struct sway_seat *seat = tablet->seat_device->sway_seat;
-        if ((seat->wlr_seat->capabilities & WL_SEAT_CAPABILITY_POINTER) == 0) {
+        seat_configure_xcursor(seat);
-                seat_configure_xcursor(seat);
-        }
        if (!tablet->tablet_v2) {
                tablet->tablet_v2 =
                        wlr_tablet_create(server.tablet_v2, seat->wlr_seat, device);
        }
+#if WLR_HAS_LIBINPUT_BACKEND
        /* Search for a sibling tablet pad */
        if (!wlr_input_device_is_libinput(device)) {
                /* We can only do this on libinput devices */
@@ -87,6 +89,7 @@ void sway_configure_tablet(struct sway_tablet *tablet) {
                        break;
                }
        }
+#endif
 }
 void sway_tablet_destroy(struct sway_tablet *tablet) {
@@ -196,7 +199,7 @@ static void handle_tablet_pad_attach(struct wl_listener *listener,
 static void handle_tablet_pad_ring(struct wl_listener *listener, void *data) {
        struct sway_tablet_pad *pad = wl_container_of(listener, pad, ring);
-        struct wlr_event_tablet_pad_ring *event = data;
+        struct wlr_tablet_pad_ring_event *event = data;
        if (!pad->current_surface) {
                return;
@@ -210,7 +213,7 @@ static void handle_tablet_pad_ring(struct wl_listener *listener, void *data) {
 static void handle_tablet_pad_strip(struct wl_listener *listener, void *data) {
        struct sway_tablet_pad *pad = wl_container_of(listener, pad, strip);
-        struct wlr_event_tablet_pad_strip *event = data;
+        struct wlr_tablet_pad_strip_event *event = data;
        if (!pad->current_surface) {
                return;
@@ -224,7 +227,7 @@ static void handle_tablet_pad_strip(struct wl_listener *listener, void *data) {
 static void handle_tablet_pad_button(struct wl_listener *listener, void *data) {
        struct sway_tablet_pad *pad = wl_container_of(listener, pad, button);
-        struct wlr_event_tablet_pad_button *event = data;
+        struct wlr_tablet_pad_button_event *event = data;
        if (!pad->current_surface) {
                return;
@@ -246,6 +249,7 @@ struct sway_tablet_pad *sway_tablet_pad_create(struct sway_seat *seat,
                return NULL;
        }
+        tablet_pad->wlr = wlr_tablet_pad_from_input_device(device->input_device->wlr_device);
        tablet_pad->seat_device = device;
        wl_list_init(&tablet_pad->attach.link);
        wl_list_init(&tablet_pad->button.link);
@@ -260,40 +264,41 @@ struct sway_tablet_pad *sway_tablet_pad_create(struct sway_seat *seat,
 }
 void sway_configure_tablet_pad(struct sway_tablet_pad *tablet_pad) {
-        struct wlr_input_device *device =
+        struct wlr_input_device *wlr_device =
                tablet_pad->seat_device->input_device->wlr_device;
        struct sway_seat *seat = tablet_pad->seat_device->sway_seat;
        if (!tablet_pad->tablet_v2_pad) {
                tablet_pad->tablet_v2_pad =
-                        wlr_tablet_pad_create(server.tablet_v2, seat->wlr_seat, device);
+                        wlr_tablet_pad_create(server.tablet_v2, seat->wlr_seat, wlr_device);
        }
        wl_list_remove(&tablet_pad->attach.link);
        tablet_pad->attach.notify = handle_tablet_pad_attach;
-        wl_signal_add(&device->tablet_pad->events.attach_tablet,
+        wl_signal_add(&tablet_pad->wlr->events.attach_tablet,
                &tablet_pad->attach);
        wl_list_remove(&tablet_pad->button.link);
        tablet_pad->button.notify = handle_tablet_pad_button;
-        wl_signal_add(&device->tablet_pad->events.button, &tablet_pad->button);
+        wl_signal_add(&tablet_pad->wlr->events.button, &tablet_pad->button);
        wl_list_remove(&tablet_pad->strip.link);
        tablet_pad->strip.notify = handle_tablet_pad_strip;
-        wl_signal_add(&device->tablet_pad->events.strip, &tablet_pad->strip);
+        wl_signal_add(&tablet_pad->wlr->events.strip, &tablet_pad->strip);
        wl_list_remove(&tablet_pad->ring.link);
        tablet_pad->ring.notify = handle_tablet_pad_ring;
-        wl_signal_add(&device->tablet_pad->events.ring, &tablet_pad->ring);
+        wl_signal_add(&tablet_pad->wlr->events.ring, &tablet_pad->ring);
+#if WLR_HAS_LIBINPUT_BACKEND
        /* Search for a sibling tablet */
-        if (!wlr_input_device_is_libinput(device)) {
+        if (!wlr_input_device_is_libinput(wlr_device)) {
                /* We can only do this on libinput devices */
                return;
        }
        struct libinput_device_group *group =
-                libinput_device_get_device_group(wlr_libinput_get_device_handle(device));
+                libinput_device_get_device_group(wlr_libinput_get_device_handle(wlr_device));
        struct sway_tablet *tool;
        wl_list_for_each(tool, &seat->cursor->tablets, link) {
                struct wlr_input_device *tablet =
@@ -310,6 +315,7 @@ void sway_configure_tablet_pad(struct sway_tablet_pad *tablet_pad) {
                        break;
                }
        }
+#endif
 }
 void sway_tablet_pad_destroy(struct sway_tablet_pad *tablet_pad) {
@@ -333,14 +339,10 @@ static void handle_pad_tablet_surface_destroy(struct wl_listener *listener,
        struct sway_tablet_pad *tablet_pad =
                wl_container_of(listener, tablet_pad, surface_destroy);
-        wlr_tablet_v2_tablet_pad_notify_leave(tablet_pad->tablet_v2_pad,
+        sway_tablet_pad_set_focus(tablet_pad, NULL);
-                tablet_pad->current_surface);
-        wl_list_remove(&tablet_pad->surface_destroy.link);
-        wl_list_init(&tablet_pad->surface_destroy.link);
-        tablet_pad->current_surface = NULL;
 }
-void sway_tablet_pad_notify_enter(struct sway_tablet_pad *tablet_pad,
+void sway_tablet_pad_set_focus(struct sway_tablet_pad *tablet_pad,
                struct wlr_surface *surface) {
        if (!tablet_pad || !tablet_pad->tablet) {
                return;
@@ -359,7 +361,8 @@ void sway_tablet_pad_notify_enter(struct sway_tablet_pad *tablet_pad,
                tablet_pad->current_surface = NULL;
        }
-        if (!wlr_surface_accepts_tablet_v2(tablet_pad->tablet->tablet_v2, surface)) {
+        if (surface == NULL ||
+                        !wlr_surface_accepts_tablet_v2(tablet_pad->tablet->tablet_v2, surface)) {
                return;
        }
@@ -367,7 +370,6 @@ void sway_tablet_pad_notify_enter(struct sway_tablet_pad *tablet_pad,
                tablet_pad->tablet->tablet_v2, surface);
        tablet_pad->current_surface = surface;
-        wl_list_remove(&tablet_pad->surface_destroy.link);
        tablet_pad->surface_destroy.notify = handle_pad_tablet_surface_destroy;
        wl_signal_add(&surface->events.destroy, &tablet_pad->surface_destroy);
 }
diff --git a/sway/input/text_input.c b/sway/input/text_input.c
index b8c19c17..c38a3bb2 100644
--- a/sway/input/text_input.c
+++ b/sway/input/text_input.c
@@ -2,7 +2,14 @@
 #include <stdlib.h>
 #include "log.h"
 #include "sway/input/seat.h"
+#include "sway/scene_descriptor.h"
+#include "sway/tree/root.h"
+#include "sway/tree/view.h"
+#include "sway/output.h"
 #include "sway/input/text_input.h"
+#include "sway/input/text_input_popup.h"
+#include "sway/layers.h"
+static void input_popup_update(struct sway_input_popup *popup);
 static struct sway_text_input *relay_get_focusable_text_input(
                struct sway_input_method_relay *relay) {
@@ -77,8 +84,6 @@ static void handle_im_grab_keyboard(struct wl_listener *listener, void *data) {
        struct wlr_keyboard *active_keyboard = wlr_seat_get_keyboard(relay->seat->wlr_seat);
        wlr_input_method_keyboard_grab_v2_set_keyboard(keyboard_grab,
                active_keyboard);
-        wlr_input_method_keyboard_grab_v2_send_modifiers(keyboard_grab,
-                &active_keyboard->modifiers);
        wl_signal_add(&keyboard_grab->events.destroy,
                &relay->input_method_keyboard_grab_destroy);
@@ -104,6 +109,10 @@ static void handle_im_destroy(struct wl_listener *listener, void *data) {
                input_method_destroy);
        struct wlr_input_method_v2 *context = data;
        assert(context == relay->input_method);
+        wl_list_remove(&relay->input_method_commit.link);
+        wl_list_remove(&relay->input_method_grab_keyboard.link);
+        wl_list_remove(&relay->input_method_destroy.link);
+        wl_list_remove(&relay->input_method_new_popup_surface.link);
        relay->input_method = NULL;
        struct sway_text_input *text_input = relay_get_focused_text_input(relay);
        if (text_input) {
@@ -135,6 +144,11 @@ static void relay_send_im_state(struct sway_input_method_relay *relay,
                        input->current.content_type.hint,
                        input->current.content_type.purpose);
        }
+        struct sway_input_popup *popup;
+        wl_list_for_each(popup, &relay->input_popups, link) {
+                // send_text_input_rectangle is called in this function
+                input_popup_update(popup);
+        }
        wlr_input_method_v2_send_done(input_method);
        // TODO: pass intent, display popup size
 }
@@ -257,6 +271,211 @@ static void relay_handle_text_input(struct wl_listener *listener,
        sway_text_input_create(relay, wlr_text_input);
 }
+static void input_popup_update(struct sway_input_popup *popup) {
+        struct sway_text_input *text_input =
+                relay_get_focused_text_input(popup->relay);
+        if (text_input == NULL || text_input->input->focused_surface == NULL) {
+                return;
+        }
+        if (popup->scene_tree != NULL) {
+                wlr_scene_node_destroy(&popup->scene_tree->node);
+                popup->scene_tree = NULL;
+        }
+        if (popup->desc.relative != NULL) {
+                wlr_scene_node_destroy(popup->desc.relative);
+                popup->desc.relative = NULL;
+        }
+        popup->desc.view = NULL;
+        if (!popup->popup_surface->surface->mapped) {
+                return;
+        }
+        bool cursor_rect = text_input->input->current.features
+                & WLR_TEXT_INPUT_V3_FEATURE_CURSOR_RECTANGLE;
+        struct wlr_surface *focused_surface = text_input->input->focused_surface;
+        struct wlr_box cursor_area = text_input->input->current.cursor_rectangle;
+        struct wlr_box output_box;
+        struct wlr_box parent = {0};
+        struct wlr_layer_surface_v1 *layer_surface =
+                wlr_layer_surface_v1_try_from_wlr_surface(focused_surface);
+        struct wlr_scene_tree *relative_parent;
+        struct wlr_box geo = {0};
+        popup->scene_tree = wlr_scene_subsurface_tree_create(root->layers.popup, popup->popup_surface->surface);
+        if (layer_surface != NULL) {
+                struct sway_layer_surface *layer =
+                        layer_surface->data;
+                if (layer == NULL) {
+                        return;
+                }
+                relative_parent = layer->scene->tree;
+                struct wlr_output *output = layer->layer_surface->output;
+                wlr_output_layout_get_box(root->output_layout, output, &output_box);
+                int lx, ly;
+                wlr_scene_node_coords(&layer->tree->node, &lx, &ly);
+                parent.x = lx;
+                parent.y = ly;
+                popup->desc.view = NULL;
+        } else {
+                struct sway_view *view = view_from_wlr_surface(focused_surface);
+                relative_parent = view->scene_tree;
+                geo = view->geometry;
+                int lx, ly;
+                wlr_scene_node_coords(&view->scene_tree->node, &lx, &ly);
+                struct wlr_output *output = wlr_output_layout_output_at(root->output_layout,
+                        view->container->pending.content_x + view->geometry.x,
+                        view->container->pending.content_y + view->geometry.y);
+                wlr_output_layout_get_box(root->output_layout, output, &output_box);
+                parent.x = lx;
+                parent.y = ly;
+                parent.width = view->geometry.width;
+                parent.height = view->geometry.height;
+                popup->desc.view = view;
+        }
+        struct wlr_scene_tree *relative = wlr_scene_tree_create(relative_parent);
+        popup->desc.relative = &relative->node;
+        if (!scene_descriptor_assign(&popup->scene_tree->node,
+                        SWAY_SCENE_DESC_POPUP, &popup->desc)) {
+                wlr_scene_node_destroy(&popup->scene_tree->node);
+                popup->scene_tree = NULL;
+                return;
+        }
+        if (!cursor_rect) {
+                cursor_area.x = 0;
+                cursor_area.y = 0;
+                cursor_area.width = parent.width;
+                cursor_area.height = parent.height;
+        }
+        int popup_width = popup->popup_surface->surface->current.width;
+        int popup_height = popup->popup_surface->surface->current.height;
+        int x1 = parent.x + cursor_area.x;
+        int x2 = parent.x + cursor_area.x + cursor_area.width;
+        int y1 = parent.y + cursor_area.y;
+        int y2 = parent.y + cursor_area.y + cursor_area.height;
+        int x = x1;
+        int y = y2;
+        int available_right = output_box.x + output_box.width - x1;
+        int available_left = x2 - output_box.x;
+        if (available_right < popup_width && available_left > available_right) {
+                x = x2 - popup_width;
+        }
+        int available_down = output_box.y + output_box.height - y2;
+        int available_up = y1 - output_box.y;
+        if (available_down < popup_height && available_up > available_down) {
+                y = y1 - popup_height;
+        }
+        wlr_scene_node_set_position(&relative->node, x - parent.x - geo.x, y - parent.y - geo.y);
+        if (cursor_rect) {
+                struct wlr_box box = {
+                        .x = x1 - x,
+                        .y = y1 - y,
+                        .width = cursor_area.width,
+                        .height = cursor_area.height,
+                };
+                wlr_input_popup_surface_v2_send_text_input_rectangle(
+                        popup->popup_surface, &box);
+        }
+        wlr_scene_node_set_position(&popup->scene_tree->node, x - geo.x, y - geo.y);
+}
+static void input_popup_set_focus(struct sway_input_popup *popup,
+                struct wlr_surface *surface) {
+        wl_list_remove(&popup->focused_surface_unmap.link);
+        if (surface == NULL) {
+                wl_list_init(&popup->focused_surface_unmap.link);
+                input_popup_update(popup);
+                return;
+        }
+        struct wlr_layer_surface_v1 *layer_surface =
+                wlr_layer_surface_v1_try_from_wlr_surface(surface);
+        if (layer_surface != NULL) {
+                wl_signal_add(
+                        &layer_surface->surface->events.unmap, &popup->focused_surface_unmap);
+                input_popup_update(popup);
+                return;
+        }
+        struct sway_view *view = view_from_wlr_surface(surface);
+        wl_signal_add(&view->events.unmap, &popup->focused_surface_unmap);
+}
+static void handle_im_popup_destroy(struct wl_listener *listener, void *data) {
+        struct sway_input_popup *popup =
+                wl_container_of(listener, popup, popup_destroy);
+        wl_list_remove(&popup->focused_surface_unmap.link);
+        wl_list_remove(&popup->popup_surface_commit.link);
+        wl_list_remove(&popup->popup_destroy.link);
+        wl_list_remove(&popup->link);
+        free(popup);
+}
+static void handle_im_popup_surface_commit(struct wl_listener *listener,
+                void *data) {
+        struct sway_input_popup *popup =
+                wl_container_of(listener, popup, popup_surface_commit);
+        input_popup_update(popup);
+}
+static void handle_im_focused_surface_unmap(
+                struct wl_listener *listener, void *data) {
+        struct sway_input_popup *popup =
+                wl_container_of(listener, popup, focused_surface_unmap);
+        input_popup_update(popup);
+}
+static void handle_im_new_popup_surface(struct wl_listener *listener,
+                void *data) {
+        struct sway_input_method_relay *relay = wl_container_of(listener, relay,
+                input_method_new_popup_surface);
+        struct sway_input_popup *popup = calloc(1, sizeof(*popup));
+        popup->relay = relay;
+        popup->popup_surface = data;
+        popup->popup_surface->data = popup;
+        wl_signal_add(
+                &popup->popup_surface->events.destroy, &popup->popup_destroy);
+        popup->popup_destroy.notify = handle_im_popup_destroy;
+        wl_signal_add(&popup->popup_surface->surface->events.commit,
+                &popup->popup_surface_commit);
+        popup->popup_surface_commit.notify = handle_im_popup_surface_commit;
+        wl_list_init(&popup->focused_surface_unmap.link);
+        popup->focused_surface_unmap.notify = handle_im_focused_surface_unmap;
+        struct sway_text_input *text_input = relay_get_focused_text_input(relay);
+        if (text_input != NULL) {
+                input_popup_set_focus(popup, text_input->input->focused_surface);
+        } else {
+                input_popup_set_focus(popup, NULL);
+        }
+        wl_list_insert(&relay->input_popups, &popup->link);
+}
+static void text_input_send_enter(struct sway_text_input *text_input,
+                struct wlr_surface *surface) {
+        wlr_text_input_v3_send_enter(text_input->input, surface);
+        struct sway_input_popup *popup;
+        wl_list_for_each(popup, &text_input->relay->input_popups, link) {
+                input_popup_set_focus(popup, surface);
+        }
+}
 static void relay_handle_input_method(struct wl_listener *listener,
                void *data) {
        struct sway_input_method_relay *relay = wl_container_of(listener, relay,
@@ -282,10 +501,13 @@ static void relay_handle_input_method(struct wl_listener *listener,
        wl_signal_add(&relay->input_method->events.destroy,
                &relay->input_method_destroy);
        relay->input_method_destroy.notify = handle_im_destroy;
+        wl_signal_add(&relay->input_method->events.new_popup_surface,
+                &relay->input_method_new_popup_surface);
+        relay->input_method_new_popup_surface.notify = handle_im_new_popup_surface;
        struct sway_text_input *text_input = relay_get_focusable_text_input(relay);
        if (text_input) {
-                wlr_text_input_v3_send_enter(text_input->input,
+                text_input_send_enter(text_input,
                        text_input->pending_focused_surface);
                text_input_set_pending_focused_surface(text_input, NULL);
        }
@@ -295,6 +517,7 @@ void sway_input_method_relay_init(struct sway_seat *seat,
                struct sway_input_method_relay *relay) {
        relay->seat = seat;
        wl_list_init(&relay->text_inputs);
+        wl_list_init(&relay->input_popups);
        relay->text_input_new.notify = relay_handle_text_input;
        wl_signal_add(&server.text_input->events.text_input,
diff --git a/sway/ipc-json.c b/sway/ipc-json.c
index 1b64f86e..b7370aa6 100644
--- a/sway/ipc-json.c
+++ b/sway/ipc-json.c
@@ -3,7 +3,8 @@
 #include <json.h>
 #include <libevdev/libevdev.h>
 #include <stdio.h>
-#include <wlr/backend/libinput.h>
+#include <wlr/config.h>
+#include <wlr/types/wlr_content_type_v1.h>
 #include <wlr/types/wlr_output.h>
 #include <xkbcommon/xkbcommon.h>
 #include "config.h"
@@ -20,6 +21,10 @@
 #include "wlr-layer-shell-unstable-v1-protocol.h"
 #include "sway/desktop/idle_inhibit_v1.h"
+#if WLR_HAS_LIBINPUT_BACKEND
+#include <wlr/backend/libinput.h>
+#endif
 static const int i3_output_id = INT32_MAX;
 static const int i3_scratch_id = INT32_MAX - 1;
@@ -112,13 +117,44 @@ static const char *ipc_json_output_adaptive_sync_status_description(
                return "disabled";
        case WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED:
                return "enabled";
-        case WLR_OUTPUT_ADAPTIVE_SYNC_UNKNOWN:
-                return "unknown";
        }
        return NULL;
 }
-#if HAVE_XWAYLAND
+static const char *ipc_json_output_mode_aspect_ratio_description(
+                enum wlr_output_mode_aspect_ratio aspect_ratio) {
+        switch (aspect_ratio) {
+        case WLR_OUTPUT_MODE_ASPECT_RATIO_NONE:
+                return "none";
+        case WLR_OUTPUT_MODE_ASPECT_RATIO_4_3:
+                return "4:3";
+        case WLR_OUTPUT_MODE_ASPECT_RATIO_16_9:
+                return "16:9";
+        case WLR_OUTPUT_MODE_ASPECT_RATIO_64_27:
+                return "64:27";
+        case WLR_OUTPUT_MODE_ASPECT_RATIO_256_135:
+                return "256:135";
+        }
+        return NULL;
+}
+static json_object *ipc_json_output_mode_description(
+                const struct wlr_output_mode *mode) {
+        const char *pic_ar =
+                ipc_json_output_mode_aspect_ratio_description(mode->picture_aspect_ratio);
+        json_object *mode_object = json_object_new_object();
+        json_object_object_add(mode_object, "width",
+                json_object_new_int(mode->width));
+        json_object_object_add(mode_object, "height",
+                json_object_new_int(mode->height));
+        json_object_object_add(mode_object, "refresh",
+                json_object_new_int(mode->refresh));
+        json_object_object_add(mode_object, "picture_aspect_ratio",
+                json_object_new_string(pic_ar));
+        return mode_object;
+}
+#if WLR_HAS_XWAYLAND
 static const char *ipc_json_xwindow_type_description(struct sway_view *view) {
        struct wlr_xwayland_surface *surface = view->wlr_xwayland_surface;
        struct sway_xwayland *xwayland = &server.xwayland;
@@ -170,6 +206,20 @@ static const char *ipc_json_user_idle_inhibitor_description(enum sway_idle_inhib
        return NULL;
 }
+static const char *ipc_json_content_type_description(enum wp_content_type_v1_type type) {
+        switch (type) {
+        case WP_CONTENT_TYPE_V1_TYPE_NONE:
+                return "none";
+        case WP_CONTENT_TYPE_V1_TYPE_PHOTO:
+                return "photo";
+        case WP_CONTENT_TYPE_V1_TYPE_VIDEO:
+                return "video";
+        case WP_CONTENT_TYPE_V1_TYPE_GAME:
+                return "game";
+        }
+        return NULL;
+}
 json_object *ipc_json_get_version(void) {
        int major = 0, minor = 0, patch = 0;
        json_object *version = json_object_new_object();
@@ -238,27 +288,56 @@ static json_object *ipc_json_create_node(int id, const char* type, char *name,
        json_object_object_add(object, "focus", focus);
        json_object_object_add(object, "fullscreen_mode", json_object_new_int(0));
        json_object_object_add(object, "sticky", json_object_new_boolean(false));
+        json_object_object_add(object, "floating", NULL);
+        json_object_object_add(object, "scratchpad_state", NULL);
        return object;
 }
+static void ipc_json_describe_wlr_output(struct wlr_output *wlr_output, json_object *object) {
+        json_object_object_add(object, "primary", json_object_new_boolean(false));
+        json_object_object_add(object, "make",
+                        json_object_new_string(wlr_output->make ? wlr_output->make : "Unknown"));
+        json_object_object_add(object, "model",
+                        json_object_new_string(wlr_output->model ? wlr_output->model : "Unknown"));
+        json_object_object_add(object, "serial",
+                        json_object_new_string(wlr_output->serial ? wlr_output->serial : "Unknown"));
+        json_object *modes_array = json_object_new_array();
+        struct wlr_output_mode *mode;
+        wl_list_for_each(mode, &wlr_output->modes, link) {
+                json_object *mode_object = json_object_new_object();
+                json_object_object_add(mode_object, "width",
+                        json_object_new_int(mode->width));
+                json_object_object_add(mode_object, "height",
+                        json_object_new_int(mode->height));
+                json_object_object_add(mode_object, "refresh",
+                        json_object_new_int(mode->refresh));
+                json_object_array_add(modes_array, mode_object);
+        }
+        json_object_object_add(object, "modes", modes_array);
+}
 static void ipc_json_describe_output(struct sway_output *output,
                json_object *object) {
+        ipc_json_describe_wlr_output(output->wlr_output, object);
+}
+static void ipc_json_describe_enabled_output(struct sway_output *output,
+                json_object *object) {
+        ipc_json_describe_output(output, object);
        struct wlr_output *wlr_output = output->wlr_output;
+        json_object_object_add(object, "non_desktop", json_object_new_boolean(false));
        json_object_object_add(object, "active", json_object_new_boolean(true));
        json_object_object_add(object, "dpms",
                        json_object_new_boolean(wlr_output->enabled));
-        json_object_object_add(object, "primary", json_object_new_boolean(false));
+        json_object_object_add(object, "power",
+                        json_object_new_boolean(wlr_output->enabled));
        json_object_object_add(object, "layout", json_object_new_string("output"));
        json_object_object_add(object, "orientation",
                        json_object_new_string(
                                ipc_json_orientation_description(L_NONE)));
-        json_object_object_add(object, "make",
-                        json_object_new_string(wlr_output->make));
-        json_object_object_add(object, "model",
-                        json_object_new_string(wlr_output->model));
-        json_object_object_add(object, "serial",
-                        json_object_new_string(wlr_output->serial));
        json_object_object_add(object, "scale",
                        json_object_new_double(wlr_output->scale));
        json_object_object_add(object, "scale_filter",
@@ -283,25 +362,26 @@ static void ipc_json_describe_output(struct sway_output *output,
        json_object *modes_array = json_object_new_array();
        struct wlr_output_mode *mode;
        wl_list_for_each(mode, &wlr_output->modes, link) {
-                json_object *mode_object = json_object_new_object();
+                json_object *mode_object =
-                json_object_object_add(mode_object, "width",
+                        ipc_json_output_mode_description(mode);
-                        json_object_new_int(mode->width));
-                json_object_object_add(mode_object, "height",
-                        json_object_new_int(mode->height));
-                json_object_object_add(mode_object, "refresh",
-                        json_object_new_int(mode->refresh));
                json_object_array_add(modes_array, mode_object);
        }
        json_object_object_add(object, "modes", modes_array);
-        json_object *current_mode_object = json_object_new_object();
+        json_object *current_mode_object;
-        json_object_object_add(current_mode_object, "width",
+        if (wlr_output->current_mode != NULL) {
-                json_object_new_int(wlr_output->width));
+                current_mode_object =
-        json_object_object_add(current_mode_object, "height",
+                        ipc_json_output_mode_description(wlr_output->current_mode);
-                json_object_new_int(wlr_output->height));
+        } else {
-        json_object_object_add(current_mode_object, "refresh",
+                current_mode_object = json_object_new_object();
-                json_object_new_int(wlr_output->refresh));
+                json_object_object_add(current_mode_object, "width",
+                        json_object_new_int(wlr_output->width));
+                json_object_object_add(current_mode_object, "height",
+                        json_object_new_int(wlr_output->height));
+                json_object_object_add(current_mode_object, "refresh",
+                        json_object_new_int(wlr_output->refresh));
+        }
        json_object_object_add(object, "current_mode", current_mode_object);
        struct sway_node *parent = node_get_parent(&output->node);
@@ -325,33 +405,15 @@ json_object *ipc_json_describe_disabled_output(struct sway_output *output) {
        json_object *object = json_object_new_object();
+        ipc_json_describe_output(output, object);
+        json_object_object_add(object, "non_desktop", json_object_new_boolean(false));
        json_object_object_add(object, "type", json_object_new_string("output"));
        json_object_object_add(object, "name",
                        json_object_new_string(wlr_output->name));
        json_object_object_add(object, "active", json_object_new_boolean(false));
        json_object_object_add(object, "dpms", json_object_new_boolean(false));
-        json_object_object_add(object, "primary", json_object_new_boolean(false));
+        json_object_object_add(object, "power", json_object_new_boolean(false));
-        json_object_object_add(object, "make",
-                        json_object_new_string(wlr_output->make));
-        json_object_object_add(object, "model",
-                        json_object_new_string(wlr_output->model));
-        json_object_object_add(object, "serial",
-                        json_object_new_string(wlr_output->serial));
-        json_object *modes_array = json_object_new_array();
-        struct wlr_output_mode *mode;
-        wl_list_for_each(mode, &wlr_output->modes, link) {
-                json_object *mode_object = json_object_new_object();
-                json_object_object_add(mode_object, "width",
-                        json_object_new_int(mode->width));
-                json_object_object_add(mode_object, "height",
-                        json_object_new_int(mode->height));
-                json_object_object_add(mode_object, "refresh",
-                        json_object_new_int(mode->refresh));
-                json_object_array_add(modes_array, mode_object);
-        }
-        json_object_object_add(object, "modes", modes_array);
        json_object_object_add(object, "current_workspace", NULL);
@@ -367,6 +429,21 @@ json_object *ipc_json_describe_disabled_output(struct sway_output *output) {
        return object;
 }
+json_object *ipc_json_describe_non_desktop_output(struct sway_output_non_desktop *output) {
+        struct wlr_output *wlr_output = output->wlr_output;
+        json_object *object = json_object_new_object();
+        ipc_json_describe_wlr_output(wlr_output, object);
+        json_object_object_add(object, "non_desktop", json_object_new_boolean(true));
+        json_object_object_add(object, "type", json_object_new_string("output"));
+        json_object_object_add(object, "name",
+                                json_object_new_string(wlr_output->name));
+        return object;
+}
 static json_object *ipc_json_describe_scratchpad_output(void) {
        struct wlr_box box;
        root_get_box(root, &box);
@@ -453,7 +530,9 @@ static void ipc_json_describe_workspace(struct sway_workspace *workspace,
 static void get_deco_rect(struct sway_container *c, struct wlr_box *deco_rect) {
        enum sway_container_layout parent_layout = container_parent_layout(c);
-        bool tab_or_stack = parent_layout == L_TABBED || parent_layout == L_STACKED;
+        list_t *siblings = container_get_siblings(c);
+        bool tab_or_stack = (parent_layout == L_TABBED || parent_layout == L_STACKED)
+                && ((siblings && siblings->length > 1) || !config->hide_lone_tab);
        if (((!tab_or_stack || container_is_floating(c)) &&
                                c->current.border != B_NORMAL) ||
                        c->pending.fullscreen_mode != FULLSCREEN_NONE ||
@@ -500,7 +579,7 @@ static void ipc_json_describe_view(struct sway_container *c, json_object *object
        struct wlr_box window_box = {
                c->pending.content_x - c->pending.x,
-                (c->current.border == B_PIXEL) ? c->current.border_thickness : 0,
+                (c->current.border == B_PIXEL) ? c->pending.content_y - c->pending.y : 0,
                c->pending.content_width,
                c->pending.content_height
        };
@@ -544,7 +623,17 @@ static void ipc_json_describe_view(struct sway_container *c, json_object *object
        json_object_object_add(object, "idle_inhibitors", idle_inhibitors);
-#if HAVE_XWAYLAND
+        enum wp_content_type_v1_type content_type = WP_CONTENT_TYPE_V1_TYPE_NONE;
+        if (c->view->surface != NULL) {
+                content_type = wlr_surface_get_content_type_v1(server.content_type_manager_v1,
+                        c->view->surface);
+        }
+        if (content_type != WP_CONTENT_TYPE_V1_TYPE_NONE) {
+                json_object_object_add(object, "content_type",
+                        json_object_new_string(ipc_json_content_type_description(content_type)));
+        }
+#if WLR_HAS_XWAYLAND
        if (c->view->type == SWAY_VIEW_XWAYLAND) {
                json_object_object_add(object, "window",
                                json_object_new_int(view_get_x11_window_id(c->view)));
@@ -588,7 +677,8 @@ static void ipc_json_describe_view(struct sway_container *c, json_object *object
 static void ipc_json_describe_container(struct sway_container *c, json_object *object) {
        json_object_object_add(object, "name",
                        c->title ? json_object_new_string(c->title) : NULL);
-        if (container_is_floating(c)) {
+        bool floating = container_is_floating(c);
+        if (floating) {
                json_object_object_add(object, "type",
                                json_object_new_string("floating_con"));
        }
@@ -606,9 +696,17 @@ static void ipc_json_describe_container(struct sway_container *c, json_object *o
        json_object_object_add(object, "urgent", json_object_new_boolean(urgent));
        json_object_object_add(object, "sticky", json_object_new_boolean(c->is_sticky));
+        // sway doesn't track the floating reason, so we can't use "auto_on" or "user_off"
+        json_object_object_add(object, "floating",
+                        json_object_new_string(floating ? "user_on" : "auto_off"));
        json_object_object_add(object, "fullscreen_mode",
                        json_object_new_int(c->pending.fullscreen_mode));
+        // sway doesn't track if window was resized in scratchpad, so we can't use "changed"
+        json_object_object_add(object, "scratchpad_state",
+                        json_object_new_string(!c->scratchpad ? "none" : "fresh"));
        struct sway_node *parent = node_get_parent(&c->node);
        struct wlr_box parent_box = {0, 0, 0, 0};
@@ -706,7 +804,7 @@ json_object *ipc_json_describe_node(struct sway_node *node) {
        case N_ROOT:
                break;
        case N_OUTPUT:
-                ipc_json_describe_output(node->sway_output, object);
+                ipc_json_describe_enabled_output(node->sway_output, object);
                break;
        case N_CONTAINER:
                ipc_json_describe_container(node->sway_container, object);
@@ -764,6 +862,7 @@ json_object *ipc_json_describe_node_recursive(struct sway_node *node) {
        return object;
 }
+#if WLR_HAS_LIBINPUT_BACKEND
 static json_object *describe_libinput_device(struct libinput_device *device) {
        json_object *object = json_object_new_object();
@@ -847,6 +946,11 @@ static json_object *describe_libinput_device(struct libinput_device *device) {
                case LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE:
                        accel_profile = "adaptive";
                        break;
+#if HAVE_LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM
+                case LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM:
+                        accel_profile = "custom";
+                        break;
+#endif
                }
                json_object_object_add(object, "accel_profile",
                                json_object_new_string(accel_profile));
@@ -926,6 +1030,17 @@ static json_object *describe_libinput_device(struct libinput_device *device) {
                        uint32_t button = libinput_device_config_scroll_get_button(device);
                        json_object_object_add(object, "scroll_button",
                                        json_object_new_int(button));
+                        const char *lock = "unknown";
+                        switch (libinput_device_config_scroll_get_button_lock(device)) {
+                        case LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED:
+                                lock = "enabled";
+                                break;
+                        case LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED:
+                                lock = "disabled";
+                                break;
+                        }
+                        json_object_object_add(object, "scroll_button_lock",
+                                        json_object_new_string(lock));
                }
        }
@@ -942,6 +1057,19 @@ static json_object *describe_libinput_device(struct libinput_device *device) {
                json_object_object_add(object, "dwt", json_object_new_string(dwt));
        }
+        if (libinput_device_config_dwtp_is_available(device)) {
+                const char *dwtp = "unknown";
+                switch (libinput_device_config_dwtp_get_enabled(device)) {
+                case LIBINPUT_CONFIG_DWTP_ENABLED:
+                        dwtp = "enabled";
+                        break;
+                case LIBINPUT_CONFIG_DWTP_DISABLED:
+                        dwtp = "disabled";
+                        break;
+                }
+                json_object_object_add(object, "dwtp", json_object_new_string(dwtp));
+        }
        if (libinput_device_config_calibration_has_matrix(device)) {
                float matrix[6];
                libinput_device_config_calibration_get_matrix(device, matrix);
@@ -956,6 +1084,7 @@ static json_object *describe_libinput_device(struct libinput_device *device) {
        return object;
 }
+#endif
 json_object *ipc_json_describe_input(struct sway_input_device *device) {
        if (!(sway_assert(device, "Device must not be null"))) {
@@ -968,19 +1097,21 @@ json_object *ipc_json_describe_input(struct sway_input_device *device) {
                json_object_new_string(device->identifier));
        json_object_object_add(object, "name",
                json_object_new_string(device->wlr_device->name));
-        json_object_object_add(object, "vendor",
-                json_object_new_int(device->wlr_device->vendor));
-        json_object_object_add(object, "product",
-                json_object_new_int(device->wlr_device->product));
        json_object_object_add(object, "type",
                json_object_new_string(
                        input_device_get_type(device)));
        if (device->wlr_device->type == WLR_INPUT_DEVICE_KEYBOARD) {
-                struct wlr_keyboard *keyboard = device->wlr_device->keyboard;
+                struct wlr_keyboard *keyboard =
+                        wlr_keyboard_from_input_device(device->wlr_device);
                struct xkb_keymap *keymap = keyboard->keymap;
                struct xkb_state *state = keyboard->xkb_state;
+                json_object_object_add(object, "repeat_delay", 
+                        json_object_new_int(keyboard->repeat_info.delay));
+                json_object_object_add(object, "repeat_rate", 
+                        json_object_new_int(keyboard->repeat_info.rate));
                json_object *layouts_arr = json_object_new_array();
                json_object_object_add(object, "xkb_layout_names", layouts_arr);
@@ -1005,20 +1136,26 @@ json_object *ipc_json_describe_input(struct sway_input_device *device) {
        if (device->wlr_device->type == WLR_INPUT_DEVICE_POINTER) {
                struct input_config *ic = input_device_get_config(device);
                float scroll_factor = 1.0f;
-                if (ic != NULL && !isnan(ic->scroll_factor) && 
+                if (ic != NULL && !isnan(ic->scroll_factor) &&
                                ic->scroll_factor != FLT_MIN) {
                        scroll_factor = ic->scroll_factor;
                }
-                json_object_object_add(object, "scroll_factor", 
+                json_object_object_add(object, "scroll_factor",
                                json_object_new_double(scroll_factor));
        }
+#if WLR_HAS_LIBINPUT_BACKEND
        if (wlr_input_device_is_libinput(device->wlr_device)) {
                struct libinput_device *libinput_dev;
                libinput_dev = wlr_libinput_get_device_handle(device->wlr_device);
                json_object_object_add(object, "libinput",
                                describe_libinput_device(libinput_dev));
+                json_object_object_add(object, "vendor",
+                        json_object_new_int(libinput_device_get_id_vendor(libinput_dev)));
+                json_object_object_add(object, "product",
+                        json_object_new_int(libinput_device_get_id_product(libinput_dev)));
        }
+#endif
        return object;
 }
diff --git a/sway/ipc-server.c b/sway/ipc-server.c
index aad9a7b5..7f353c0e 100644
--- a/sway/ipc-server.c
+++ b/sway/ipc-server.c
@@ -1,5 +1,4 @@
 // See https://i3wm.org/docs/ipc.html for protocol information
-#define _POSIX_C_SOURCE 200112L
 #include <linux/input-event-codes.h>
 #include <assert.h>
 #include <errno.h>
@@ -56,7 +55,6 @@ struct ipc_client {
        enum ipc_command_type pending_type;
 };
-struct sockaddr_un *ipc_user_sockaddr(void);
 int ipc_handle_connection(int fd, uint32_t mask, void *data);
 int ipc_client_handle_readable(int client_fd, uint32_t mask, void *data);
 int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data);
@@ -150,7 +148,6 @@ struct sockaddr_un *ipc_user_sockaddr(void) {
 int ipc_handle_connection(int fd, uint32_t mask, void *data) {
        (void) fd;
        struct sway_server *server = data;
-        sway_log(SWAY_DEBUG, "Event on IPC listening socket");
        assert(mask == WL_EVENT_READABLE);
        int client_fd = accept(ipc_socket, NULL, NULL);
@@ -211,13 +208,10 @@ int ipc_client_handle_readable(int client_fd, uint32_t mask, void *data) {
        }
        if (mask & WL_EVENT_HANGUP) {
-                sway_log(SWAY_DEBUG, "Client %d hung up", client->fd);
                ipc_client_disconnect(client);
                return 0;
        }
-        sway_log(SWAY_DEBUG, "Client %d readable", client->fd);
        int read_available;
        if (ioctl(client_fd, FIONREAD, &read_available) == -1) {
                sway_log_errno(SWAY_INFO, "Unable to read IPC socket buffer size");
@@ -513,6 +507,20 @@ void ipc_event_input(const char *change, struct sway_input_device *device) {
        json_object_put(json);
 }
+void ipc_event_output(void) {
+        if (!ipc_has_event_listeners(IPC_EVENT_OUTPUT)) {
+                return;
+        }
+        sway_log(SWAY_DEBUG, "Sending output event");
+        json_object *json = json_object_new_object();
+        json_object_object_add(json, "change", json_object_new_string("unspecified"));
+        const char *json_string = json_object_to_json_string(json);
+        ipc_send_event(json_string, IPC_EVENT_OUTPUT);
+        json_object_put(json);
+}
 int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data) {
        struct ipc_client *client = data;
@@ -523,7 +531,6 @@ int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data) {
        }
        if (mask & WL_EVENT_HANGUP) {
-                sway_log(SWAY_DEBUG, "Client %d hung up", client->fd);
                ipc_client_disconnect(client);
                return 0;
        }
@@ -532,8 +539,6 @@ int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data) {
                return 0;
        }
-        sway_log(SWAY_DEBUG, "Client %d writable", client->fd);
        ssize_t written = write(client->fd, client->write_buffer, client->write_buffer_len);
        if (written == -1 && errno == EAGAIN) {
@@ -687,11 +692,17 @@ void ipc_client_handle_command(struct ipc_client *client, uint32_t payload_lengt
                }
                struct sway_output *output;
                wl_list_for_each(output, &root->all_outputs, link) {
-                        if (!output->enabled && output != root->noop_output) {
+                        if (!output->enabled && output != root->fallback_output) {
                                json_object_array_add(outputs,
                                                ipc_json_describe_disabled_output(output));
                        }
                }
+                for (int i = 0; i < root->non_desktop_outputs->length; i++) {
+                        struct sway_output_non_desktop *non_desktop_output = root->non_desktop_outputs->items[i];
+                        json_object_array_add(outputs, ipc_json_describe_non_desktop_output(non_desktop_output));
+                }
                const char *json_string = json_object_to_json_string(outputs);
                ipc_send_reply(client, payload_type, json_string,
                        (uint32_t)strlen(json_string));
@@ -727,6 +738,8 @@ void ipc_client_handle_command(struct ipc_client *client, uint32_t payload_lengt
                        const char *event_type = json_object_get_string(json_object_array_get_idx(request, i));
                        if (strcmp(event_type, "workspace") == 0) {
                                client->subscribed_events |= event_mask(IPC_EVENT_WORKSPACE);
+                        } else if (strcmp(event_type, "output") == 0) {
+                                client->subscribed_events |= event_mask(IPC_EVENT_OUTPUT);
                        } else if (strcmp(event_type, "barconfig_update") == 0) {
                                client->subscribed_events |= event_mask(IPC_EVENT_BARCONFIG_UPDATE);
                        } else if (strcmp(event_type, "bar_state_update") == 0) {
@@ -911,7 +924,6 @@ void ipc_client_handle_command(struct ipc_client *client, uint32_t payload_lengt
 exit_cleanup:
        free(buf);
-        return;
 }
 bool ipc_send_reply(struct ipc_client *client, enum ipc_command_type payload_type,
@@ -955,7 +967,5 @@ bool ipc_send_reply(struct ipc_client *client, enum ipc_command_type payload_typ
                                ipc_client_handle_writable, client);
        }
-        sway_log(SWAY_DEBUG, "Added IPC reply of type 0x%x to client %d queue: %s",
-                payload_type, client->fd, payload);
        return true;
 }
diff --git a/sway/lock.c b/sway/lock.c
new file mode 100644
index 00000000..289e8ca4
--- /dev/null
+++ b/sway/lock.c
@@ -0,0 +1,354 @@
+#include <assert.h>
+#include <wlr/types/wlr_scene.h>
+#include <wlr/types/wlr_session_lock_v1.h>
+#include "log.h"
+#include "sway/input/cursor.h"
+#include "sway/input/keyboard.h"
+#include "sway/input/seat.h"
+#include "sway/layers.h"
+#include "sway/output.h"
+#include "sway/server.h"
+struct sway_session_lock_output {
+        struct wlr_scene_tree *tree;
+        struct wlr_scene_rect *background;
+        struct sway_session_lock *lock;
+        struct sway_output *output;
+        struct wl_list link; // sway_session_lock::outputs
+        struct wl_listener destroy;
+        struct wl_listener commit;
+        struct wlr_session_lock_surface_v1 *surface;
+        // invalid if surface is NULL
+        struct wl_listener surface_destroy;
+        struct wl_listener surface_map;
+};
+static void focus_surface(struct sway_session_lock *lock,
+                struct wlr_surface *focused) {
+        lock->focused = focused;
+        struct sway_seat *seat;
+        wl_list_for_each(seat, &server.input->seats, link) {
+                seat_set_focus_surface(seat, focused, false);
+        }
+}
+static void refocus_output(struct sway_session_lock_output *output) {
+        // Move the seat focus to another surface if one is available
+        if (output->lock->focused == output->surface->surface) {
+                struct wlr_surface *next_focus = NULL;
+                struct sway_session_lock_output *candidate;
+                wl_list_for_each(candidate, &output->lock->outputs, link) {
+                        if (candidate == output || !candidate->surface) {
+                                continue;
+                        }
+                        if (candidate->surface->surface->mapped) {
+                                next_focus = candidate->surface->surface;
+                                break;
+                        }
+                }
+                focus_surface(output->lock, next_focus);
+        }
+}
+static void handle_surface_map(struct wl_listener *listener, void *data) {
+        struct sway_session_lock_output *surf = wl_container_of(listener, surf, surface_map);
+        if (surf->lock->focused == NULL) {
+                focus_surface(surf->lock, surf->surface->surface);
+        }
+        cursor_rebase_all();
+}
+static void handle_surface_destroy(struct wl_listener *listener, void *data) {
+        struct sway_session_lock_output *output =
+                wl_container_of(listener, output, surface_destroy);
+        refocus_output(output);
+        sway_assert(output->surface, "Trying to destroy a surface that the lock doesn't think exists");
+        output->surface = NULL;
+        wl_list_remove(&output->surface_destroy.link);
+        wl_list_remove(&output->surface_map.link);
+}
+static void lock_output_reconfigure(struct sway_session_lock_output *output) {
+        int width = output->output->width;
+        int height = output->output->height;
+        wlr_scene_rect_set_size(output->background, width, height);
+        if (output->surface) {
+                wlr_session_lock_surface_v1_configure(output->surface, width, height);
+        }
+}
+static void handle_new_surface(struct wl_listener *listener, void *data) {
+        struct sway_session_lock *lock = wl_container_of(listener, lock, new_surface);
+        struct wlr_session_lock_surface_v1 *lock_surface = data;
+        struct sway_output *output = lock_surface->output->data;
+        sway_log(SWAY_DEBUG, "new lock layer surface");
+        struct sway_session_lock_output *current_lock_output, *lock_output = NULL;
+        wl_list_for_each(current_lock_output, &lock->outputs, link) {
+                if (current_lock_output->output == output) {
+                        lock_output = current_lock_output;
+                        break;
+                }
+        }
+        sway_assert(lock_output, "Couldn't find output to lock");
+        sway_assert(!lock_output->surface, "Tried to reassign a surface to an existing output");
+        lock_output->surface = lock_surface;
+        wlr_scene_subsurface_tree_create(lock_output->tree, lock_surface->surface);
+        lock_output->surface_destroy.notify = handle_surface_destroy;
+        wl_signal_add(&lock_surface->events.destroy, &lock_output->surface_destroy);
+        lock_output->surface_map.notify = handle_surface_map;
+        wl_signal_add(&lock_surface->surface->events.map, &lock_output->surface_map);
+        lock_output_reconfigure(lock_output);
+}
+static void sway_session_lock_output_destroy(struct sway_session_lock_output *output) {
+        if (output->surface) {
+                refocus_output(output);
+                wl_list_remove(&output->surface_destroy.link);
+                wl_list_remove(&output->surface_map.link);
+        }
+        wl_list_remove(&output->commit.link);
+        wl_list_remove(&output->destroy.link);
+        wl_list_remove(&output->link);
+        free(output);
+}
+static void lock_node_handle_destroy(struct wl_listener *listener, void *data) {
+        struct sway_session_lock_output *output =
+                wl_container_of(listener, output, destroy);
+        sway_session_lock_output_destroy(output);
+}
+static void lock_output_handle_commit(struct wl_listener *listener, void *data) {
+        struct wlr_output_event_commit *event = data;
+        struct sway_session_lock_output *output =
+                wl_container_of(listener, output, commit);
+        if (event->state->committed & (
+                        WLR_OUTPUT_STATE_MODE |
+                        WLR_OUTPUT_STATE_SCALE |
+                        WLR_OUTPUT_STATE_TRANSFORM)) {
+                lock_output_reconfigure(output);
+        }
+}
+static struct sway_session_lock_output *session_lock_output_create(
+                struct sway_session_lock *lock, struct sway_output *output) {
+        struct sway_session_lock_output *lock_output = calloc(1, sizeof(*lock_output));
+        if (!lock_output) {
+                sway_log(SWAY_ERROR, "failed to allocate a session lock output");
+                return NULL;
+        }
+        struct wlr_scene_tree *tree = wlr_scene_tree_create(output->layers.session_lock);
+        if (!tree) {
+                sway_log(SWAY_ERROR, "failed to allocate a session lock output scene tree");
+                free(lock_output);
+                return NULL;
+        }
+        struct wlr_scene_rect *background = wlr_scene_rect_create(tree, 0, 0, (float[4]){
+                lock->abandoned ? 1.f : 0.f,
+                0.f,
+                0.f,
+                1.f,
+        });
+        if (!background) {
+                sway_log(SWAY_ERROR, "failed to allocate a session lock output scene background");
+                wlr_scene_node_destroy(&tree->node);
+                free(lock_output);
+                return NULL;
+        }
+        lock_output->output = output;
+        lock_output->tree = tree;
+        lock_output->background = background;
+        lock_output->lock = lock;
+        lock_output->destroy.notify = lock_node_handle_destroy;
+        wl_signal_add(&tree->node.events.destroy, &lock_output->destroy);
+        lock_output->commit.notify = lock_output_handle_commit;
+        wl_signal_add(&output->wlr_output->events.commit, &lock_output->commit);
+        lock_output_reconfigure(lock_output);
+        wl_list_insert(&lock->outputs, &lock_output->link);
+        return lock_output;
+}
+static void sway_session_lock_destroy(struct sway_session_lock* lock) {
+        struct sway_session_lock_output *lock_output, *tmp_lock_output;
+        wl_list_for_each_safe(lock_output, tmp_lock_output, &lock->outputs, link) {
+                // destroying the node will also destroy the whole lock output
+                wlr_scene_node_destroy(&lock_output->tree->node);
+        }
+        if (server.session_lock.lock == lock) {
+                server.session_lock.lock = NULL;
+        }
+        if (!lock->abandoned) {
+                wl_list_remove(&lock->destroy.link);
+                wl_list_remove(&lock->unlock.link);
+                wl_list_remove(&lock->new_surface.link);
+        }
+        free(lock);
+}
+static void handle_unlock(struct wl_listener *listener, void *data) {
+        struct sway_session_lock *lock = wl_container_of(listener, lock, unlock);
+        sway_log(SWAY_DEBUG, "session unlocked");
+        sway_session_lock_destroy(lock);
+        struct sway_seat *seat;
+        wl_list_for_each(seat, &server.input->seats, link) {
+                // copied from seat_set_focus_layer -- deduplicate?
+                struct sway_node *previous = seat_get_focus_inactive(seat, &root->node);
+                if (previous) {
+                        // Hack to get seat to re-focus the return value of get_focus
+                        seat_set_focus(seat, NULL);
+                        seat_set_focus(seat, previous);
+                }
+        }
+        // Triggers a refocus of the topmost surface layer if necessary
+        // TODO: Make layer surface focus per-output based on cursor position
+        for (int i = 0; i < root->outputs->length; ++i) {
+                struct sway_output *output = root->outputs->items[i];
+                arrange_layers(output);
+        }
+}
+static void handle_abandon(struct wl_listener *listener, void *data) {
+        struct sway_session_lock *lock = wl_container_of(listener, lock, destroy);
+        sway_log(SWAY_INFO, "session lock abandoned");
+        struct sway_session_lock_output *lock_output;
+        wl_list_for_each(lock_output, &lock->outputs, link) {
+                wlr_scene_rect_set_color(lock_output->background,
+                        (float[4]){ 1.f, 0.f, 0.f, 1.f });
+        }
+        lock->abandoned = true;
+        wl_list_remove(&lock->destroy.link);
+        wl_list_remove(&lock->unlock.link);
+        wl_list_remove(&lock->new_surface.link);
+}
+static void handle_session_lock(struct wl_listener *listener, void *data) {
+        struct wlr_session_lock_v1 *lock = data;
+        struct wl_client *client = wl_resource_get_client(lock->resource);
+        if (server.session_lock.lock) {
+                if (server.session_lock.lock->abandoned) {
+                        sway_log(SWAY_INFO, "Replacing abandoned lock");
+                        sway_session_lock_destroy(server.session_lock.lock);
+                } else {
+                        sway_log(SWAY_ERROR, "Cannot lock an already locked session");
+                        wlr_session_lock_v1_destroy(lock);
+                        return;
+                }
+        }
+        struct sway_session_lock *sway_lock = calloc(1, sizeof(*sway_lock));
+        if (!sway_lock) {
+                sway_log(SWAY_ERROR, "failed to allocate a session lock object");
+                wlr_session_lock_v1_destroy(lock);
+                return;
+        }
+        wl_list_init(&sway_lock->outputs);
+        sway_log(SWAY_DEBUG, "session locked");
+        struct sway_seat *seat;
+        wl_list_for_each(seat, &server.input->seats, link) {
+                seat_unfocus_unless_client(seat, client);
+        }
+        struct sway_output *output;
+        wl_list_for_each(output, &root->all_outputs, link) {
+                sway_session_lock_add_output(sway_lock, output);
+        }
+        sway_lock->new_surface.notify = handle_new_surface;
+        wl_signal_add(&lock->events.new_surface, &sway_lock->new_surface);
+        sway_lock->unlock.notify = handle_unlock;
+        wl_signal_add(&lock->events.unlock, &sway_lock->unlock);
+        sway_lock->destroy.notify = handle_abandon;
+        wl_signal_add(&lock->events.destroy, &sway_lock->destroy);
+        wlr_session_lock_v1_send_locked(lock);
+        server.session_lock.lock = sway_lock;
+}
+static void handle_session_lock_destroy(struct wl_listener *listener, void *data) {
+        // if the server shuts down while a lock is active, destroy the lock
+        if (server.session_lock.lock) {
+                sway_session_lock_destroy(server.session_lock.lock);
+        }
+        wl_list_remove(&server.session_lock.new_lock.link);
+        wl_list_remove(&server.session_lock.manager_destroy.link);
+        server.session_lock.manager = NULL;
+}
+void sway_session_lock_add_output(struct sway_session_lock *lock,
+                struct sway_output *output) {
+        struct sway_session_lock_output *lock_output =
+                session_lock_output_create(lock, output);
+        // if we run out of memory while trying to lock the screen, the best we
+        // can do is kill the sway process. Security conscious users will have
+        // the sway session fall back to a login shell.
+        if (!lock_output) {
+                sway_log(SWAY_ERROR, "aborting: failed to allocate a lock output");
+                abort();
+        }
+}
+bool sway_session_lock_has_surface(struct sway_session_lock *lock,
+                struct wlr_surface *surface) {
+        struct sway_session_lock_output *lock_output;
+        wl_list_for_each(lock_output, &lock->outputs, link) {
+                if (lock_output->surface && lock_output->surface->surface == surface) {
+                        return true;
+                }
+        }
+        return false;
+}
+void sway_session_lock_init(void) {
+        server.session_lock.manager = wlr_session_lock_manager_v1_create(server.wl_display);
+        server.session_lock.new_lock.notify = handle_session_lock;
+        server.session_lock.manager_destroy.notify = handle_session_lock_destroy;
+        wl_signal_add(&server.session_lock.manager->events.new_lock,
+                &server.session_lock.new_lock);
+        wl_signal_add(&server.session_lock.manager->events.destroy,
+                &server.session_lock.manager_destroy);
+}
diff --git a/sway/main.c b/sway/main.c
index 0611e80b..1c4939aa 100644
--- a/sway/main.c
+++ b/sway/main.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <getopt.h>
 #include <pango/pangocairo.h>
 #include <signal.h>
@@ -6,6 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -27,6 +27,7 @@
 static bool terminate_request = false;
 static int exit_value = 0;
+static struct rlimit original_nofile_rlimit = {0};
 struct sway_server server = {0};
 struct sway_debug debug = {0};
@@ -47,44 +48,6 @@ void sig_handler(int signal) {
        sway_terminate(EXIT_SUCCESS);
 }
-void detect_proprietary(int allow_unsupported_gpu) {
-        FILE *f = fopen("/proc/modules", "r");
-        if (!f) {
-                return;
-        }
-        char *line = NULL;
-        size_t line_size = 0;
-        while (getline(&line, &line_size, f) != -1) {
-                if (strncmp(line, "nvidia ", 7) == 0) {
-                        if (allow_unsupported_gpu) {
-                                sway_log(SWAY_ERROR,
-                                                "!!! Proprietary Nvidia drivers are in use !!!");
-                        } else {
-                                sway_log(SWAY_ERROR,
-                                        "Proprietary Nvidia drivers are NOT supported. "
-                                        "Use Nouveau. To launch sway anyway, launch with "
-                                        "--my-next-gpu-wont-be-nvidia and DO NOT report issues.");
-                                exit(EXIT_FAILURE);
-                        }
-                        break;
-                }
-                if (strstr(line, "fglrx")) {
-                        if (allow_unsupported_gpu) {
-                                sway_log(SWAY_ERROR,
-                                                "!!! Proprietary AMD drivers are in use !!!");
-                        } else {
-                                sway_log(SWAY_ERROR, "Proprietary AMD drivers do NOT support "
-                                        "Wayland. Use radeon. To try anyway, launch sway with "
-                                        "--unsupported-gpu and DO NOT report issues.");
-                                exit(EXIT_FAILURE);
-                        }
-                        break;
-                }
-        }
-        free(line);
-        fclose(f);
-}
 void run_as_ipc_client(char *command, char *socket_path) {
        int socketfd = ipc_open_socket(socket_path);
        uint32_t len = strlen(command);
@@ -148,33 +111,49 @@ static void log_kernel(void) {
        pclose(f);
 }
+static bool detect_suid(void) {
-static bool drop_permissions(void) {
+        if (geteuid() != 0 && getegid() != 0) {
-        if (getuid() != geteuid() || getgid() != getegid()) {
+                return false;
-                // Set the gid and uid in the correct order.
-                if (setgid(getgid()) != 0) {
-                        sway_log(SWAY_ERROR, "Unable to drop root group, refusing to start");
-                        return false;
-                }
-                if (setuid(getuid()) != 0) {
-                        sway_log(SWAY_ERROR, "Unable to drop root user, refusing to start");
-                        return false;
-                }
        }
-        if (setgid(0) != -1 || setuid(0) != -1) {
-                sway_log(SWAY_ERROR, "Unable to drop root (we shouldn't be able to "
+        if (getuid() == geteuid() && getgid() == getegid()) {
-                        "restore it after setuid), refusing to start");
                return false;
        }
+        sway_log(SWAY_ERROR, "SUID operation is no longer supported, refusing to start. "
+                        "This check will be removed in a future release.");
        return true;
 }
+static void increase_nofile_limit(void) {
+        if (getrlimit(RLIMIT_NOFILE, &original_nofile_rlimit) != 0) {
+                sway_log_errno(SWAY_ERROR, "Failed to bump max open files limit: "
+                        "getrlimit(NOFILE) failed");
+                return;
+        }
+        struct rlimit new_rlimit = original_nofile_rlimit;
+        new_rlimit.rlim_cur = new_rlimit.rlim_max;
+        if (setrlimit(RLIMIT_NOFILE, &new_rlimit) != 0) {
+                sway_log_errno(SWAY_ERROR, "Failed to bump max open files limit: "
+                        "setrlimit(NOFILE) failed");
+                sway_log(SWAY_INFO, "Running with %d max open files",
+                        (int)original_nofile_rlimit.rlim_cur);
+        }
+}
+void restore_nofile_limit(void) {
+        if (original_nofile_rlimit.rlim_cur == 0) {
+                return;
+        }
+        if (setrlimit(RLIMIT_NOFILE, &original_nofile_rlimit) != 0) {
+                sway_log_errno(SWAY_ERROR, "Failed to restore max open files limit: "
+                        "setrlimit(NOFILE) failed");
+        }
+}
 void enable_debug_flag(const char *flag) {
-        if (strcmp(flag, "damage=highlight") == 0) {
+        if (strcmp(flag, "noatomic") == 0) {
-                debug.damage = DAMAGE_HIGHLIGHT;
-        } else if (strcmp(flag, "damage=rerender") == 0) {
-                debug.damage = DAMAGE_RERENDER;
-        } else if (strcmp(flag, "noatomic") == 0) {
                debug.noatomic = true;
        } else if (strcmp(flag, "txn-wait") == 0) {
                debug.txn_wait = true;
@@ -182,6 +161,8 @@ void enable_debug_flag(const char *flag) {
                debug.txn_timings = true;
        } else if (strncmp(flag, "txn-timeout=", 12) == 0) {
                server.txn_timeout_ms = atoi(&flag[12]);
+        } else if (strcmp(flag, "legacy-wl-drm") == 0) {
+                debug.legacy_wl_drm = true;
        } else {
                sway_log(SWAY_ERROR, "Unknown debug flag: %s", flag);
        }
@@ -206,36 +187,35 @@ static void handle_wlr_log(enum wlr_log_importance importance,
        _sway_vlog(convert_wlr_log_importance(importance), sway_fmt, args);
 }
+static const struct option long_options[] = {
+        {"help", no_argument, NULL, 'h'},
+        {"config", required_argument, NULL, 'c'},
+        {"validate", no_argument, NULL, 'C'},
+        {"debug", no_argument, NULL, 'd'},
+        {"version", no_argument, NULL, 'v'},
+        {"verbose", no_argument, NULL, 'V'},
+        {"get-socketpath", no_argument, NULL, 'p'},
+        {"unsupported-gpu", no_argument, NULL, 'u'},
+        {0, 0, 0, 0}
+};
+static const char usage[] =
+        "Usage: sway [options] [command]\n"
+        "\n"
+        "  -h, --help             Show help message and quit.\n"
+        "  -c, --config <config>  Specify a config file.\n"
+        "  -C, --validate         Check the validity of the config file, then exit.\n"
+        "  -d, --debug            Enables full logging, including debug information.\n"
+        "  -v, --version          Show the version number and quit.\n"
+        "  -V, --verbose          Enables more verbose logging.\n"
+        "      --get-socketpath   Gets the IPC socket path and prints it, then exits.\n"
+        "\n";
 int main(int argc, char **argv) {
-        static int verbose = 0, debug = 0, validate = 0, allow_unsupported_gpu = 0;
+        static bool verbose = false, debug = false, validate = false;
-        static const struct option long_options[] = {
-                {"help", no_argument, NULL, 'h'},
-                {"config", required_argument, NULL, 'c'},
-                {"validate", no_argument, NULL, 'C'},
-                {"debug", no_argument, NULL, 'd'},
-                {"version", no_argument, NULL, 'v'},
-                {"verbose", no_argument, NULL, 'V'},
-                {"get-socketpath", no_argument, NULL, 'p'},
-                {"unsupported-gpu", no_argument, NULL, 'u'},
-                {"my-next-gpu-wont-be-nvidia", no_argument, NULL, 'u'},
-                {0, 0, 0, 0}
-        };
        char *config_path = NULL;
-        const char* usage =
-                "Usage: sway [options] [command]\n"
-                "\n"
-                "  -h, --help             Show help message and quit.\n"
-                "  -c, --config <config>  Specify a config file.\n"
-                "  -C, --validate         Check the validity of the config file, then exit.\n"
-                "  -d, --debug            Enables full logging, including debug information.\n"
-                "  -v, --version          Show the version number and quit.\n"
-                "  -V, --verbose          Enables more verbose logging.\n"
-                "      --get-socketpath   Gets the IPC socket path and prints it, then exits.\n"
-                "\n";
        int c;
        while (1) {
                int option_index = 0;
@@ -253,25 +233,25 @@ int main(int argc, char **argv) {
                        config_path = strdup(optarg);
                        break;
                case 'C': // validate
-                        validate = 1;
+                        validate = true;
                        break;
                case 'd': // debug
-                        debug = 1;
+                        debug = true;
                        break;
                case 'D': // extended debug options
                        enable_debug_flag(optarg);
                        break;
                case 'u':
-                        allow_unsupported_gpu = 1;
+                        allow_unsupported_gpu = true;
                        break;
                case 'v': // version
                        printf("sway version " SWAY_VERSION "\n");
                        exit(EXIT_SUCCESS);
                        break;
                case 'V': // verbose
-                        verbose = 1;
+                        verbose = true;
                        break;
-                case 'p': ; // --get-socketpath
+                case 'p': // --get-socketpath
                        if (getenv("SWAYSOCK")) {
                                printf("%s\n", getenv("SWAYSOCK"));
                                exit(EXIT_SUCCESS);
@@ -286,6 +266,11 @@ int main(int argc, char **argv) {
                }
        }
+        // SUID operation is deprecated, so block it for now.
+        if (detect_suid()) {
+                exit(EXIT_FAILURE);
+        }
        // Since wayland requires XDG_RUNTIME_DIR to be set, abort with just the
        // clear error message (when not running as an IPC client).
        if (!getenv("XDG_RUNTIME_DIR") && optind == argc) {
@@ -312,7 +297,6 @@ int main(int argc, char **argv) {
        log_kernel();
        log_distro();
        log_env();
-        detect_proprietary(allow_unsupported_gpu);
        if (optind < argc) { // Behave as IPC client
                if (optind != 1) {
@@ -325,9 +309,6 @@ int main(int argc, char **argv) {
                                        "`sway -d 2>sway.log`.");
                        exit(EXIT_FAILURE);
                }
-                if (!drop_permissions()) {
-                        exit(EXIT_FAILURE);
-                }
                char *socket_path = getenv("SWAYSOCK");
                if (!socket_path) {
                        sway_log(SWAY_ERROR, "Unable to retrieve socket path");
@@ -339,14 +320,7 @@ int main(int argc, char **argv) {
                return 0;
        }
-        if (!server_privileged_prepare(&server)) {
+        increase_nofile_limit();
-                return 1;
-        }
-        if (!drop_permissions()) {
-                server_fini(&server);
-                exit(EXIT_FAILURE);
-        }
        // handle SIGTERM signals
        signal(SIGTERM, sig_handler);
@@ -357,12 +331,14 @@ int main(int argc, char **argv) {
        sway_log(SWAY_INFO, "Starting sway version " SWAY_VERSION);
-        root = root_create();
        if (!server_init(&server)) {
                return 1;
        }
+        if (server.linux_dmabuf_v1) {
+                wlr_scene_set_linux_dmabuf_v1(root->root_scene, server.linux_dmabuf_v1);
+        }
        if (validate) {
                bool valid = load_main_config(config_path, false, true);
                free(config_path);
@@ -377,6 +353,8 @@ int main(int argc, char **argv) {
                goto shutdown;
        }
+        set_rr_scheduling();
        if (!server_start(&server)) {
                sway_terminate(EXIT_FAILURE);
                goto shutdown;
diff --git a/sway/meson.build b/sway/meson.build
index 1402db15..47b51d0c 100644
--- a/sway/meson.build
+++ b/sway/meson.build
@@ -5,25 +5,26 @@ sway_sources = files(
        'decoration.c',
        'ipc-json.c',
        'ipc-server.c',
+        'lock.c',
        'main.c',
+        'realtime.c',
+        'scene_descriptor.c',
        'server.c',
+        'sway_text_node.c',
        'swaynag.c',
        'xdg_activation_v1.c',
        'xdg_decoration.c',
-        'desktop/desktop.c',
        'desktop/idle_inhibit_v1.c',
        'desktop/layer_shell.c',
        'desktop/output.c',
-        'desktop/render.c',
-        'desktop/surface.c',
        'desktop/transaction.c',
        'desktop/xdg_shell.c',
+        'desktop/launcher.c',
        'input/input-manager.c',
        'input/cursor.c',
        'input/keyboard.c',
-        'input/libinput.c',
        'input/seat.c',
        'input/seatop_default.c',
        'input/seatop_down.c',
@@ -65,6 +66,7 @@ sway_sources = files(
        'commands/force_focus_wrapping.c',
        'commands/fullscreen.c',
        'commands/gaps.c',
+        'commands/gesture.c',
        'commands/hide_edge_borders.c',
        'commands/inhibit_idle.c',
        'commands/kill.c',
@@ -83,6 +85,7 @@ sway_sources = files(
        'commands/nop.c',
        'commands/output.c',
        'commands/popup_during_fullscreen.c',
+        'commands/primary_selection.c',
        'commands/reload.c',
        'commands/rename.c',
        'commands/resize.c',
@@ -154,6 +157,7 @@ sway_sources = files(
        'commands/input/drag.c',
        'commands/input/drag_lock.c',
        'commands/input/dwt.c',
+        'commands/input/dwtp.c',
        'commands/input/events.c',
        'commands/input/left_handed.c',
        'commands/input/map_from_region.c',
@@ -162,9 +166,11 @@ sway_sources = files(
        'commands/input/middle_emulation.c',
        'commands/input/natural_scroll.c',
        'commands/input/pointer_accel.c',
+        'commands/input/rotation_angle.c',
        'commands/input/repeat_delay.c',
        'commands/input/repeat_rate.c',
        'commands/input/scroll_button.c',
+        'commands/input/scroll_button_lock.c',
        'commands/input/scroll_factor.c',
        'commands/input/scroll_method.c',
        'commands/input/tap.c',
@@ -188,11 +194,14 @@ sway_sources = files(
        'commands/output/max_render_time.c',
        'commands/output/mode.c',
        'commands/output/position.c',
+        'commands/output/power.c',
+        'commands/output/render_bit_depth.c',
        'commands/output/scale.c',
        'commands/output/scale_filter.c',
        'commands/output/subpixel.c',
        'commands/output/toggle.c',
        'commands/output/transform.c',
+        'commands/output/unplug.c',
        'tree/arrange.c',
        'tree/container.c',
@@ -212,23 +221,27 @@ sway_deps = [
        libudev,
        math,
        pango,
-        pcre,
+        pcre2,
-        glesv2,
        pixman,
-        server_protos,
+        threads,
        wayland_server,
        wlroots,
        xkbcommon,
+        xcb,
+        xcb_icccm,
 ]
-if have_xwayland
+if wlroots_features['xwayland']
        sway_sources += 'desktop/xwayland.c'
-        sway_deps += xcb
+endif
+if wlroots_features['libinput_backend']
+        sway_sources += 'input/libinput.c'
 endif
 executable(
        'sway',
-        sway_sources,
+        sway_sources + wl_protos_src,
        include_directories: [sway_inc],
        dependencies: sway_deps,
        link_with: [lib_sway_common],
diff --git a/sway/realtime.c b/sway/realtime.c
new file mode 100644
index 00000000..11154af0
--- /dev/null
+++ b/sway/realtime.c
@@ -0,0 +1,40 @@
+#include <sys/resource.h>
+#include <sched.h>
+#include <unistd.h>
+#include <pthread.h>
+#include "sway/server.h"
+#include "log.h"
+static void child_fork_callback(void) {
+        struct sched_param param;
+        param.sched_priority = 0;
+        int ret = pthread_setschedparam(pthread_self(), SCHED_OTHER, &param);
+        if (ret != 0) {
+                sway_log(SWAY_ERROR, "Failed to reset scheduler policy on fork");
+        }
+}
+void set_rr_scheduling(void) {
+        int prio = sched_get_priority_min(SCHED_RR);
+        int old_policy;
+        int ret;
+        struct sched_param param;
+        ret = pthread_getschedparam(pthread_self(), &old_policy, &param);
+        if (ret != 0) {
+                sway_log(SWAY_DEBUG, "Failed to get old scheduling priority");
+                return;
+        }
+        param.sched_priority = prio;
+        ret = pthread_setschedparam(pthread_self(), SCHED_RR, &param);
+        if (ret != 0) {
+                sway_log(SWAY_INFO, "Failed to set scheduling priority to %d", prio);
+                return;
+        }
+        pthread_atfork(NULL, NULL, child_fork_callback);
+}
diff --git a/sway/scene_descriptor.c b/sway/scene_descriptor.c
new file mode 100644
index 00000000..a30d4664
--- /dev/null
+++ b/sway/scene_descriptor.c
@@ -0,0 +1,66 @@
+#include <stdlib.h>
+#include <wlr/util/addon.h>
+#include "log.h"
+#include "sway/scene_descriptor.h"
+struct scene_descriptor {
+        void *data;
+        struct wlr_addon addon;
+};
+static const struct wlr_addon_interface addon_interface;
+static struct scene_descriptor *scene_node_get_descriptor(
+                struct wlr_scene_node *node, enum sway_scene_descriptor_type type) {
+        struct wlr_addon *addon = wlr_addon_find(&node->addons, (void *)type, &addon_interface);
+        if (!addon) {
+                return NULL;
+        }
+        struct scene_descriptor *desc = wl_container_of(addon, desc, addon);
+        return desc;
+}
+static void descriptor_destroy(struct scene_descriptor *desc) {
+        wlr_addon_finish(&desc->addon);
+        free(desc);
+}
+void *scene_descriptor_try_get(struct wlr_scene_node *node,
+                enum sway_scene_descriptor_type type) {
+        struct scene_descriptor *desc = scene_node_get_descriptor(node, type);
+        if (!desc) {
+                return NULL;
+        }
+        return desc->data;
+}
+void scene_descriptor_destroy(struct wlr_scene_node *node,
+                enum sway_scene_descriptor_type type) {
+        struct scene_descriptor *desc = scene_node_get_descriptor(node, type);
+        descriptor_destroy(desc);
+}
+static void addon_handle_destroy(struct wlr_addon *addon) {
+        struct scene_descriptor *desc = wl_container_of(addon, desc, addon);
+        descriptor_destroy(desc);
+}
+static const struct wlr_addon_interface addon_interface = {
+        .name = "sway_scene_descriptor",
+        .destroy = addon_handle_destroy,
+};
+bool scene_descriptor_assign(struct wlr_scene_node *node,
+                enum sway_scene_descriptor_type type, void *data) {
+        struct scene_descriptor *desc = calloc(1, sizeof(*desc));
+        if (!desc) {
+                sway_log(SWAY_ERROR, "Could not allocate a scene descriptor");
+                return false;
+        }
+        wlr_addon_init(&desc->addon, &node->addons, (void *)type, &addon_interface);
+        desc->data = data;
+        return true;
+}
diff --git a/sway/server.c b/sway/server.c
index 2e5ab104..4b48e8e5 100644
--- a/sway/server.c
+++ b/sway/server.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -7,21 +6,35 @@
 #include <wlr/backend.h>
 #include <wlr/backend/headless.h>
 #include <wlr/backend/multi.h>
-#include <wlr/backend/noop.h>
-#include <wlr/backend/session.h>
 #include <wlr/config.h>
+#include <wlr/render/allocator.h>
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_compositor.h>
+#include <wlr/types/wlr_content_type_v1.h>
+#include <wlr/types/wlr_cursor_shape_v1.h>
 #include <wlr/types/wlr_data_control_v1.h>
+#include <wlr/types/wlr_data_device.h>
+#include <wlr/types/wlr_drm.h>
 #include <wlr/types/wlr_export_dmabuf_v1.h>
+#include <wlr/types/wlr_ext_foreign_toplevel_list_v1.h>
+#include <wlr/types/wlr_foreign_toplevel_management_v1.h>
+#include <wlr/types/wlr_fractional_scale_v1.h>
 #include <wlr/types/wlr_gamma_control_v1.h>
-#include <wlr/types/wlr_idle.h>
+#include <wlr/types/wlr_idle_notify_v1.h>
 #include <wlr/types/wlr_layer_shell_v1.h>
+#include <wlr/types/wlr_linux_dmabuf_v1.h>
+#include <wlr/types/wlr_output_management_v1.h>
+#include <wlr/types/wlr_output_power_management_v1.h>
 #include <wlr/types/wlr_pointer_constraints_v1.h>
+#include <wlr/types/wlr_presentation_time.h>
 #include <wlr/types/wlr_primary_selection_v1.h>
 #include <wlr/types/wlr_relative_pointer_v1.h>
 #include <wlr/types/wlr_screencopy_v1.h>
+#include <wlr/types/wlr_security_context_v1.h>
 #include <wlr/types/wlr_server_decoration.h>
+#include <wlr/types/wlr_session_lock_v1.h>
+#include <wlr/types/wlr_single_pixel_buffer_v1.h>
+#include <wlr/types/wlr_subcompositor.h>
 #include <wlr/types/wlr_tablet_v2.h>
 #include <wlr/types/wlr_viewporter.h>
 #include <wlr/types/wlr_xcursor_manager.h>
@@ -31,6 +44,7 @@
 #include <wlr/types/wlr_xdg_foreign_v1.h>
 #include <wlr/types/wlr_xdg_foreign_v2.h>
 #include <wlr/types/wlr_xdg_output_v1.h>
+#include <xf86drm.h>
 #include "config.h"
 #include "list.h"
 #include "log.h"
@@ -39,41 +53,221 @@
 #include "sway/input/input-manager.h"
 #include "sway/output.h"
 #include "sway/server.h"
+#include "sway/input/cursor.h"
 #include "sway/tree/root.h"
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
+#include <wlr/xwayland/shell.h>
 #include "sway/xwayland.h"
 #endif
-bool server_privileged_prepare(struct sway_server *server) {
+#if WLR_HAS_DRM_BACKEND
-        sway_log(SWAY_DEBUG, "Preparing Wayland server initialization");
+#include <wlr/types/wlr_drm_lease_v1.h>
+#endif
+#define SWAY_XDG_SHELL_VERSION 5
+#define SWAY_LAYER_SHELL_VERSION 4
+#define SWAY_FOREIGN_TOPLEVEL_LIST_VERSION 1
+bool allow_unsupported_gpu = false;
+#if WLR_HAS_DRM_BACKEND
+static void handle_drm_lease_request(struct wl_listener *listener, void *data) {
+        /* We only offer non-desktop outputs, but in the future we might want to do
+         * more logic here. */
+        struct wlr_drm_lease_request_v1 *req = data;
+        struct wlr_drm_lease_v1 *lease = wlr_drm_lease_request_v1_grant(req);
+        if (!lease) {
+                sway_log(SWAY_ERROR, "Failed to grant lease request");
+                wlr_drm_lease_request_v1_reject(req);
+        }
+}
+#endif
+static bool is_privileged(const struct wl_global *global) {
+#if WLR_HAS_DRM_BACKEND
+        if (server.drm_lease_manager != NULL) {
+                struct wlr_drm_lease_device_v1 *drm_lease_dev;
+                wl_list_for_each(drm_lease_dev, &server.drm_lease_manager->devices, link) {
+                        if (drm_lease_dev->global == global) {
+                                return true;
+                        }
+                }
+        }
+#endif
+        return
+                global == server.output_manager_v1->global ||
+                global == server.output_power_manager_v1->global ||
+                global == server.input_method->global ||
+                global == server.foreign_toplevel_list->global ||
+                global == server.foreign_toplevel_manager->global ||
+                global == server.data_control_manager_v1->global ||
+                global == server.screencopy_manager_v1->global ||
+                global == server.export_dmabuf_manager_v1->global ||
+                global == server.security_context_manager_v1->global ||
+                global == server.gamma_control_manager_v1->global ||
+                global == server.layer_shell->global ||
+                global == server.session_lock.manager->global ||
+                global == server.input->keyboard_shortcuts_inhibit->global ||
+                global == server.input->virtual_keyboard->global ||
+                global == server.input->virtual_pointer->global ||
+                global == server.input->transient_seat_manager->global;
+}
+static bool filter_global(const struct wl_client *client,
+                const struct wl_global *global, void *data) {
+#if WLR_HAS_XWAYLAND
+        struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
+        if (xwayland && global == xwayland->shell_v1->global) {
+                return xwayland->server != NULL && client == xwayland->server->client;
+        }
+#endif
+        // Restrict usage of privileged protocols to unsandboxed clients
+        // TODO: add a way for users to configure an allow-list
+        const struct wlr_security_context_v1_state *security_context =
+                wlr_security_context_manager_v1_lookup_client(
+                server.security_context_manager_v1, (struct wl_client *)client);
+        if (is_privileged(global)) {
+                return security_context == NULL;
+        }
+        return true;
+}
+static void detect_proprietary(struct wlr_backend *backend, void *data) {
+        int drm_fd = wlr_backend_get_drm_fd(backend);
+        if (drm_fd < 0) {
+                return;
+        }
+        drmVersion *version = drmGetVersion(drm_fd);
+        if (version == NULL) {
+                sway_log(SWAY_ERROR, "drmGetVersion() failed");
+                return;
+        }
+        bool is_unsupported = false;
+        if (strcmp(version->name, "nvidia-drm") == 0) {
+                is_unsupported = true;
+                sway_log(SWAY_ERROR, "!!! Proprietary Nvidia drivers are in use !!!");
+                if (!allow_unsupported_gpu) {
+                        sway_log(SWAY_ERROR, "Use Nouveau instead");
+                }
+        }
+        if (strcmp(version->name, "evdi") == 0) {
+                is_unsupported = true;
+                sway_log(SWAY_ERROR, "!!! Proprietary DisplayLink drivers are in use !!!");
+        }
+        if (!allow_unsupported_gpu && is_unsupported) {
+                sway_log(SWAY_ERROR,
+                        "Proprietary drivers are NOT supported. To launch sway anyway, "
+                        "launch with --unsupported-gpu and DO NOT report issues.");
+                exit(EXIT_FAILURE);
+        }
+        drmFreeVersion(version);
+}
+static void handle_renderer_lost(struct wl_listener *listener, void *data) {
+        struct sway_server *server = wl_container_of(listener, server, renderer_lost);
+        sway_log(SWAY_INFO, "Re-creating renderer after GPU reset");
+        struct wlr_renderer *renderer = wlr_renderer_autocreate(server->backend);
+        if (renderer == NULL) {
+                sway_log(SWAY_ERROR, "Unable to create renderer");
+                return;
+        }
+        struct wlr_allocator *allocator =
+                wlr_allocator_autocreate(server->backend, renderer);
+        if (allocator == NULL) {
+                sway_log(SWAY_ERROR, "Unable to create allocator");
+                wlr_renderer_destroy(renderer);
+                return;
+        }
+        struct wlr_renderer *old_renderer = server->renderer;
+        struct wlr_allocator *old_allocator = server->allocator;
+        server->renderer = renderer;
+        server->allocator = allocator;
+        wl_list_remove(&server->renderer_lost.link);
+        wl_signal_add(&server->renderer->events.lost, &server->renderer_lost);
+        wlr_compositor_set_renderer(server->compositor, renderer);
+        for (int i = 0; i < root->outputs->length; ++i) {
+                struct sway_output *output = root->outputs->items[i];
+                wlr_output_init_render(output->wlr_output,
+                        server->allocator, server->renderer);
+        }
+        wlr_allocator_destroy(old_allocator);
+        wlr_renderer_destroy(old_renderer);
+}
+bool server_init(struct sway_server *server) {
+        sway_log(SWAY_DEBUG, "Initializing Wayland server");
        server->wl_display = wl_display_create();
        server->wl_event_loop = wl_display_get_event_loop(server->wl_display);
-        server->backend = wlr_backend_autocreate(server->wl_display);
+        wl_display_set_global_filter(server->wl_display, filter_global, NULL);
+        root = root_create(server->wl_display);
+        server->backend = wlr_backend_autocreate(server->wl_event_loop, &server->session);
        if (!server->backend) {
                sway_log(SWAY_ERROR, "Unable to create backend");
                return false;
        }
-        return true;
-}
-bool server_init(struct sway_server *server) {
+        wlr_multi_for_each_backend(server->backend, detect_proprietary, NULL);
-        sway_log(SWAY_DEBUG, "Initializing Wayland server");
-        struct wlr_renderer *renderer = wlr_backend_get_renderer(server->backend);
+        server->renderer = wlr_renderer_autocreate(server->backend);
-        assert(renderer);
+        if (!server->renderer) {
+                sway_log(SWAY_ERROR, "Failed to create renderer");
+                return false;
+        }
+        server->renderer_lost.notify = handle_renderer_lost;
+        wl_signal_add(&server->renderer->events.lost, &server->renderer_lost);
-        wlr_renderer_init_wl_display(renderer, server->wl_display);
+        wlr_renderer_init_wl_shm(server->renderer, server->wl_display);
-        server->compositor = wlr_compositor_create(server->wl_display, renderer);
+        if (wlr_renderer_get_texture_formats(server->renderer, WLR_BUFFER_CAP_DMABUF) != NULL) {
-        server->compositor_new_surface.notify = handle_compositor_new_surface;
+                server->linux_dmabuf_v1 = wlr_linux_dmabuf_v1_create_with_renderer(
-        wl_signal_add(&server->compositor->events.new_surface,
+                        server->wl_display, 4, server->renderer);
-                &server->compositor_new_surface);
+                if (debug.legacy_wl_drm) {
+                        wlr_drm_create(server->wl_display, server->renderer);
+                }
+        }
+        server->allocator = wlr_allocator_autocreate(server->backend,
+                server->renderer);
+        if (!server->allocator) {
+                sway_log(SWAY_ERROR, "Failed to create allocator");
+                return false;
+        }
+        server->compositor = wlr_compositor_create(server->wl_display, 6,
+                server->renderer);
+        wlr_subcompositor_create(server->wl_display);
        server->data_device_manager =
                wlr_data_device_manager_create(server->wl_display);
-        wlr_gamma_control_manager_v1_create(server->wl_display);
+        server->gamma_control_manager_v1 =
+                wlr_gamma_control_manager_v1_create(server->wl_display);
+        server->gamma_control_set_gamma.notify = handle_gamma_control_set_gamma;
+        wl_signal_add(&server->gamma_control_manager_v1->events.set_gamma,
+                &server->gamma_control_set_gamma);
        server->new_output.notify = handle_new_output;
        wl_signal_add(&server->backend->events.new_output, &server->new_output);
@@ -83,19 +277,20 @@ bool server_init(struct sway_server *server) {
        wlr_xdg_output_manager_v1_create(server->wl_display, root->output_layout);
-        server->idle = wlr_idle_create(server->wl_display);
+        server->idle_notifier_v1 = wlr_idle_notifier_v1_create(server->wl_display);
-        server->idle_inhibit_manager_v1 =
+        sway_idle_inhibit_manager_v1_init();
-                sway_idle_inhibit_manager_v1_create(server->wl_display, server->idle);
-        server->layer_shell = wlr_layer_shell_v1_create(server->wl_display);
+        server->layer_shell = wlr_layer_shell_v1_create(server->wl_display,
+                SWAY_LAYER_SHELL_VERSION);
        wl_signal_add(&server->layer_shell->events.new_surface,
                &server->layer_shell_surface);
        server->layer_shell_surface.notify = handle_layer_shell_surface;
-        server->xdg_shell = wlr_xdg_shell_create(server->wl_display);
+        server->xdg_shell = wlr_xdg_shell_create(server->wl_display,
-        wl_signal_add(&server->xdg_shell->events.new_surface,
+                SWAY_XDG_SHELL_VERSION);
-                &server->xdg_shell_surface);
+        wl_signal_add(&server->xdg_shell->events.new_toplevel,
-        server->xdg_shell_surface.notify = handle_xdg_shell_surface;
+                &server->xdg_shell_toplevel);
+        server->xdg_shell_toplevel.notify = handle_xdg_shell_toplevel;
        server->tablet_v2 = wlr_tablet_v2_create(server->wl_display);
@@ -126,8 +321,7 @@ bool server_init(struct sway_server *server) {
        wl_signal_add(&server->pointer_constraints->events.new_constraint,
                &server->pointer_constraint);
-        server->presentation =
+        wlr_presentation_create(server->wl_display, server->backend);
-                wlr_presentation_create(server->wl_display, server->backend);
        server->output_manager_v1 =
                wlr_output_manager_v1_create(server->wl_display);
@@ -146,14 +340,35 @@ bool server_init(struct sway_server *server) {
                &server->output_power_manager_set_mode);
        server->input_method = wlr_input_method_manager_v2_create(server->wl_display);
        server->text_input = wlr_text_input_manager_v3_create(server->wl_display);
+        server->foreign_toplevel_list =
+                wlr_ext_foreign_toplevel_list_v1_create(server->wl_display, SWAY_FOREIGN_TOPLEVEL_LIST_VERSION);
        server->foreign_toplevel_manager =
                wlr_foreign_toplevel_manager_v1_create(server->wl_display);
-        wlr_export_dmabuf_manager_v1_create(server->wl_display);
+        sway_session_lock_init();
-        wlr_screencopy_manager_v1_create(server->wl_display);
-        wlr_data_control_manager_v1_create(server->wl_display);
+#if WLR_HAS_DRM_BACKEND
-        wlr_primary_selection_v1_device_manager_create(server->wl_display);
+        server->drm_lease_manager=
+                wlr_drm_lease_v1_manager_create(server->wl_display, server->backend);
+        if (server->drm_lease_manager) {
+                server->drm_lease_request.notify = handle_drm_lease_request;
+                wl_signal_add(&server->drm_lease_manager->events.request,
+                                &server->drm_lease_request);
+        } else {
+                sway_log(SWAY_DEBUG, "Failed to create wlr_drm_lease_device_v1");
+                sway_log(SWAY_INFO, "VR will not be available");
+        }
+#endif
+        server->export_dmabuf_manager_v1 = wlr_export_dmabuf_manager_v1_create(server->wl_display);
+        server->screencopy_manager_v1 = wlr_screencopy_manager_v1_create(server->wl_display);
+        server->data_control_manager_v1 = wlr_data_control_manager_v1_create(server->wl_display);
+        server->security_context_manager_v1 = wlr_security_context_manager_v1_create(server->wl_display);
        wlr_viewporter_create(server->wl_display);
+        wlr_single_pixel_buffer_manager_v1_create(server->wl_display);
+        server->content_type_manager_v1 =
+                wlr_content_type_manager_v1_create(server->wl_display, 1);
+        wlr_fractional_scale_manager_v1_create(server->wl_display, 1);
        struct wlr_xdg_foreign_registry *foreign_registry =
                wlr_xdg_foreign_registry_create(server->wl_display);
@@ -165,11 +380,22 @@ bool server_init(struct sway_server *server) {
                xdg_activation_v1_handle_request_activate;
        wl_signal_add(&server->xdg_activation_v1->events.request_activate,
                &server->xdg_activation_v1_request_activate);
+        server->xdg_activation_v1_new_token.notify =
+                xdg_activation_v1_handle_new_token;
+        wl_signal_add(&server->xdg_activation_v1->events.new_token,
+                &server->xdg_activation_v1_new_token);
+        struct wlr_cursor_shape_manager_v1 *cursor_shape_manager =
+                wlr_cursor_shape_manager_v1_create(server->wl_display, 1);
+        server->request_set_cursor_shape.notify = handle_request_set_cursor_shape;
+        wl_signal_add(&cursor_shape_manager->events.request_set_shape, &server->request_set_cursor_shape);
+        wl_list_init(&server->pending_launcher_ctxs);
        // Avoid using "wayland-0" as display socket
        char name_candidate[16];
-        for (int i = 1; i <= 32; ++i) {
+        for (unsigned int i = 1; i <= 32; ++i) {
-                sprintf(name_candidate, "wayland-%d", i);
+                snprintf(name_candidate, sizeof(name_candidate), "wayland-%u", i);
                if (wl_display_add_socket(server->wl_display, name_candidate) >= 0) {
                        server->socket = strdup(name_candidate);
                        break;
@@ -182,20 +408,20 @@ bool server_init(struct sway_server *server) {
                return false;
        }
-        server->noop_backend = wlr_noop_backend_create(server->wl_display);
+        server->headless_backend = wlr_headless_backend_create(server->wl_event_loop);
-        struct wlr_output *wlr_output = wlr_noop_add_output(server->noop_backend);
-        root->noop_output = output_create(wlr_output);
-        server->headless_backend =
-                wlr_headless_backend_create_with_renderer(server->wl_display, renderer);
        if (!server->headless_backend) {
-                sway_log(SWAY_INFO, "Failed to create secondary headless backend, "
+                sway_log(SWAY_ERROR, "Failed to create secondary headless backend");
-                        "starting without it");
+                wlr_backend_destroy(server->backend);
+                return false;
        } else {
                wlr_multi_backend_add(server->backend, server->headless_backend);
        }
+        struct wlr_output *wlr_output =
+                        wlr_headless_add_output(server->headless_backend, 800, 600);
+        wlr_output_set_name(wlr_output, "FALLBACK");
+        root->fallback_output = output_create(wlr_output);
        // This may have been set already via -Dtxn-timeout
        if (!server->txn_timeout_ms) {
                server->txn_timeout_ms = 200;
@@ -211,16 +437,17 @@ bool server_init(struct sway_server *server) {
 void server_fini(struct sway_server *server) {
        // TODO: free sway-specific resources
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        wlr_xwayland_destroy(server->xwayland.wlr_xwayland);
 #endif
        wl_display_destroy_clients(server->wl_display);
+        wlr_backend_destroy(server->backend);
        wl_display_destroy(server->wl_display);
        list_free(server->dirty_nodes);
 }
 bool server_start(struct sway_server *server) {
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        if (config->xwayland != XWAYLAND_MODE_DISABLED) {
                sway_log(SWAY_DEBUG, "Initializing Xwayland (lazy=%d)",
                                config->xwayland == XWAYLAND_MODE_LAZY);
@@ -245,6 +472,10 @@ bool server_start(struct sway_server *server) {
        }
 #endif
+        if (config->primary_selection) {
+                wlr_primary_selection_v1_device_manager_create(server->wl_display);
+        }
        sway_log(SWAY_INFO, "Starting backend on wayland display '%s'",
                        server->socket);
        if (!wlr_backend_start(server->backend)) {
@@ -252,6 +483,7 @@ bool server_start(struct sway_server *server) {
                wlr_backend_destroy(server->backend);
                return false;
        }
        return true;
 }
diff --git a/sway/sway-bar.5.scd b/sway/sway-bar.5.scd
index 80d08449..42e59d57 100644
--- a/sway/sway-bar.5.scd
+++ b/sway/sway-bar.5.scd
@@ -40,7 +40,7 @@ runtime.
 *font* <font>
        Specifies the font to be used in the bar. _font_ should be specified as a
        pango font description. For more information on pango font descriptions,
-        see https://developer.gnome.org/pango/stable/pango-Fonts.html#pango-font-description-from-string
+        see https://docs.gtk.org/Pango/type_func.FontDescription.from_string.html#description
 *gaps* <all> | <horizontal> <vertical> | <top> <right> <bottom> <left>
        Sets the gaps from the edge of the screen for the bar. Gaps can either be
diff --git a/sway/sway-input.5.scd b/sway/sway-input.5.scd
index 25f6de18..442311bb 100644
--- a/sway/sway-input.5.scd
+++ b/sway/sway-input.5.scd
@@ -121,11 +121,16 @@ The following commands may only be used in the configuration file.
 *input* <identifier> map_from_region <X1xY1> <X2xY2>
        Ignores inputs from this device that do not occur within the specified
-        region. Can be in millimeters (e.g. 10x20mm 20x40mm) or in terms of 0..1
+        region. Can be in millimeters (e.g. 10x20mm 20x40mm) or the fraction of the
-        (e.g. 0.5x0.5 0.7x0.7). Not all devices support millimeters. Only meaningful
+        full available space in terms of 0..1 (e.g. 0.5x0.5 0.7x0.7). Not all
-        if the device is not a keyboard and provides events in absolute terms (such
+        devices support millimeters. Only meaningful if the device is not a
-        as a drawing tablet or touch screen - most pointers provide events relative
+        keyboard and provides events in absolute terms (such as a drawing tablet
-        to the previous frame).
+        or touch screen - most pointers provide events relative to the previous
+        frame).
+        Commonly used to maintain the aspect ratio of the input device and screen.
+        Cropping a 16:10 input region to match a 16:9 display can use 0x0 1x0.9 as
+        the argument.
 ## LIBINPUT CONFIGURATION
@@ -147,6 +152,10 @@ The following commands may only be used in the configuration file.
 *input* <identifier> dwt enabled|disabled
        Enables or disables disable-while-typing for the specified input device.
+*input* <identifier> dwtp enabled|disabled
+        Enables or disables disable-while-trackpointing for the specified input
+        device.
 *input* <identifier> events enabled|disabled|disabled_on_external_mouse|toggle [<toggle-modes>]
        Enables or disables send_events for specified input device. Disabling
        send_events disables the input device.
@@ -171,12 +180,19 @@ The following commands may only be used in the configuration file.
 *input* <identifier> pointer_accel [<-1|1>]
        Changes the pointer acceleration for the specified input device.
+*input* <identifier> rotation_angle <angle>
+        Sets the rotation angle of the device to the given clockwise angle in
+        degrees. The angle must be between 0.0 (inclusive) and 360.0 (exclusive).
 *input* <identifier> scroll_button disable|button[1-3,8,9]|<event-code-or-name>
        Sets the button used for scroll_method on_button_down. The button can
        be given as an event name or code, which can be obtained from *libinput
        debug-events*, or as a x11 mouse button (button[1-3,8,9]). If set to
        _disable_, it disables the scroll_method on_button_down.
+*input* <identifier> scroll_button_lock enabled|disabled
+        Enables or disables scroll button lock for specified input device.
 *input* <identifier> scroll_factor <floating point value>
        Changes the scroll factor for the specified input device. Scroll speed will
        be scaled by the given value, which must be non-negative.
@@ -220,6 +236,8 @@ correct seat.
        absolute coordinates (with respect to the global coordinate space).
        Specifying either value as 0 will not update that coordinate.
+        Deprecated: use the virtual-pointer Wayland protocol instead.
 *seat* <seat> cursor press|release button[1-9]|<event-name-or-code>
        Simulate pressing (or releasing) the specified mouse button on the
        specified seat. The button can either be provided as a button event name or
@@ -228,12 +246,14 @@ correct seat.
        event will be simulated, however _press_ and _release_ will be ignored and
        both will occur.
+        Deprecated: use the virtual-pointer Wayland protocol instead.
 *seat* <name> fallback true|false
        Set this seat as the fallback seat. A fallback seat will attach any device
        not explicitly attached to another seat (similar to a "default" seat).
 *seat* <name> hide_cursor <timeout>|when-typing [enable|disable]
-        Hides the cursor image after the specified event occured.
+        Hides the cursor image after the specified event occurred.
        If _timeout_ is specified, then the cursor will be hidden after _timeout_
        (in milliseconds) has elapsed with no activity on the cursor. A timeout of 0
@@ -243,18 +263,16 @@ correct seat.
        If _when-typing_ is enabled, then the cursor will be hidden whenever a key
        is pressed.
+        Be aware that this setting can interfere with input handling in games and
+        certain types of software (Gimp, Blender etc) that rely on simultaneous
+        input from mouse and keyboard.
 *seat* <name> idle_inhibit <sources...>
        Sets the set of input event sources which can prevent the seat from
        becoming idle, as a space separated list of source names. Valid names are
        "keyboard", "pointer", "touchpad", "touch", "tablet_pad", "tablet_tool",
        and "switch". The default behavior is to prevent idle on any event.
-*seat* <name> idle_wake <sources...>
-        Sets the set of input event sources which can wake the seat from
-        its idle state, as a space separated list of source names. Valid names are
-        "keyboard", "pointer", "touchpad", "touch", "tablet_pad", "tablet_tool",
-        and "switch". The default behavior is to wake from idle on any event.
 *seat* <name> keyboard_grouping none|smart
        Set how the keyboards in the seat are grouped together. Currently, there
        are two options. _none_ will disable all keyboard grouping. This will make
@@ -277,7 +295,7 @@ correct seat.
        whether future inhibitors are honoured by default, i.e. activated
        automatically, the default being _enable_. When used at runtime,
        _disable_ also disables any currently active inhibitors. _activate_,
-        _deactivate_ and _toggle_ are only useable at runtime and change the
+        _deactivate_ and _toggle_ are only usable at runtime and change the
        state of a potentially existing inhibitor on the currently focused
        window. This can be used with the current seat alias (_-_) to affect
        only the currently focused window of the current seat. Subcommand
diff --git a/sway/sway-ipc.7.scd b/sway/sway-ipc.7.scd
index 373e9dce..2f697248 100644
--- a/sway/sway-ipc.7.scd
+++ b/sway/sway-ipc.7.scd
@@ -213,7 +213,10 @@ following properties:
 :  Whether this output is active/enabled
 |- dpms
 :  boolean
-:  Whether this output is on/off (via DPMS)
+:  (Deprecated, use _power_ instead) Whether this output is on/off (via DPMS)
+|- power
+:  boolean
+:  Whether this output is on/off
 |- primary
 :  boolean
 :  For i3 compatibility, this will be false. It does not make sense in Wayland
@@ -294,7 +297,7 @@ following properties:
 Retrieve a JSON representation of the tree
 *REPLY*++
-An array of object the represent the current tree. Each object represents one
+An array of objects that represent the current tree. Each object represents one
 node and will have the following properties:
 [- *PROPERTY*
@@ -334,8 +337,9 @@ node and will have the following properties:
   this, but borders are included.
 |- window_rect
 :  object
-:  The geometry of the contents inside the node. The window decorations are
+:  The geometry of the content inside the node. These coordinates are relative
-   excluded from this calculation, but borders are included.
+   to the node itself. Window decorations and borders are outside the
+   _window_rect_
 |- deco_rect
 :  object
 :  The geometry of the decorations for the node relative to the parent node
@@ -370,8 +374,14 @@ node and will have the following properties:
   that can be used as an aid in submitting reproduction steps for bug reports
 |- fullscreen_mode
 :  integer
-:  (Only containers and views) The fullscreen mode of the node. 0 means none, 1 means 
+:  (Only containers and views) The fullscreen mode of the node. 0 means none, 1 means
   full workspace, and 2 means global fullscreen
+|- floating
+:  string
+:  Floating state of container. Can be either "auto_off" or "user_on"
+|- scratchpad_state
+:  string
+:  Whether the window is in the scratchpad. Can be either "none" or "fresh"
 |- app_id
 :  string
 :  (Only views) For an xdg-shell view, the name of the application, if set.
@@ -1036,7 +1046,7 @@ An object with a single string property containing the contents of the config
 *Example Reply:*
 ```
 {
-        "config": "set $mod Mod4\nbindsym $mod+q exit\n"
+        "config": "set $mod Mod4\\nbindsym $mod+q exit\\n"
 }
 ```
@@ -1191,9 +1201,16 @@ following properties will be included for devices that support them:
 :  int
 :  The scroll button to use when _scroll_method_ is _on_button_down_. This
   will be given as an input event code
+|- scroll_button_lock
+:  string
+:  Whether scroll button lock is enabled. It can be _enabled_ or _disabled_
 |- dwt
 :  string
 :  Whether disable-while-typing is enabled. It can be _enabled_ or _disabled_
+|- dwtp
+:  string
+:  Whether disable-while-trackpointing is enabled. It can be _enabled_ or
+  _disabled_
 |- calibration_matrix
 :  array
 :  An array of 6 floats representing the calibration matrix for absolute
@@ -1233,7 +1250,8 @@ following properties will be included for devices that support them:
                        "click_method": "button_areas",
                        "middle_emulation": "disabled",
                        "scroll_method": "edge",
-                        "dwt": "enabled"
+                        "dwt": "enabled",
+                        "dwtp": "enabled"
                }
        },
        {
@@ -1360,7 +1378,8 @@ one seat. Each object has the following properties:
                                        "click_method": "button_areas",
                                        "middle_emulation": "disabled",
                                        "scroll_method": "edge",
-                                        "dwt": "enabled"
+                                        "dwt": "enabled",
+                                        "dwtp": "enabled"
                                }
                        },
                        {
@@ -1436,6 +1455,9 @@ available:
 :  workspace
 :[ Sent whenever an event involving a workspace occurs such as initialization
   of a new workspace or a different workspace gains focus
+|- 0x80000001
+:  output
+:  Sent when outputs are updated
 |- 0x80000002
 :  mode
 :  Sent whenever the binding mode changes
@@ -1556,6 +1578,20 @@ The following change types are currently available:
 }
 ```
+## 0x80000001. OUTPUT
+Sent whenever an output is added, removed, or its configuration is changed.
+The event is a single object with the property _change_, which is a string
+containing the reason for the change. Currently, the only value for _change_ is
+_unspecified_.
+*Example Event:*
+```
+{
+        "change": "unspecified"
+}
+```
 ## 0x80000002. MODE
 Sent whenever the binding mode changes. The event consists of a single object
diff --git a/sway/sway-output.5.scd b/sway/sway-output.5.scd
index 2828c841..7d088d5d 100644
--- a/sway/sway-output.5.scd
+++ b/sway/sway-output.5.scd
@@ -24,7 +24,7 @@ must be separated by one space. For example:
 # COMMANDS
-*output* <name> mode|resolution|res [--custom] <WIDTHxHEIGHT>[@<RATE>Hz]
+*output* <name> mode|resolution|res [--custom] <width>x<height>[@<rate>Hz]
        Configures the specified output to use the given mode. Modes are a
        combination of width and height (in pixels) and a refresh rate that your
        display can be configured to use. For a list of available modes for each
@@ -40,6 +40,16 @@ must be separated by one space. For example:
                output HDMI-A-1 mode 1920x1080@60Hz
+*output* <name> modeline <clock> <hdisplay> <hsync_start> <hsync_end> <htotal> <vdisplay> <vsync_start> <vsync_end> <vtotal> <hsync> <vsync>
+        Configures the specified output to use the given modeline. It can be
+        generated using *cvt*(1) and *gtf*(1) commands. See *xorg.conf*(5).
+        Only supported on DRM backend.
+        Example:
+                output HDMI-A-1 modeline 173.00 1920 2048 2248 2576 1080 1083 1088 1120 -hsync +vsync
 *output* <name> position|pos <X> <Y>
        Places the specified output at the specific position in the global
        coordinate space. The cursor may only be moved between immediately
@@ -62,13 +72,11 @@ must be separated by one space. For example:
 *output* <name> scale <factor>
        Scales the specified output by the specified scale _factor_. An integer is
-        recommended, but fractional values are also supported. If a fractional
+        recommended, but fractional values are also supported. You may be better
-        value are specified, be warned that it is not possible to faithfully
+        served by setting an integer scale factor and adjusting the font size of
-        represent the contents of your windows - they will be rendered at the next
+        your applications to taste. HiDPI isn't supported with Xwayland clients
-        highest integer scale factor and downscaled. You may be better served by
+        (windows will blur). A fractional scale may be slightly adjusted to match
-        setting an integer scale factor and adjusting the font size of your
+        requirements of the protocol.
-        applications to taste. HiDPI isn't supported with Xwayland clients (windows
-        will blur).
 *output* <name> scale_filter linear|nearest|smart
        Indicates how to scale application buffers that are rendered at a scale
@@ -109,12 +117,20 @@ must be separated by one space. For example:
        Enables or disables the specified output (all outputs are enabled by
        default).
+        As opposed to the _power_ command, the output will lose its current
+        workspace and windows.
 *output* <name> toggle
        Toggle the specified output.
+*output* <name> power on|off|toggle
+        Turns on or off the specified output.
+        As opposed to the _enable_ and _disable_ commands, the output keeps its
+        current workspaces and windows.
 *output* <name> dpms on|off|toggle
-        Enables or disables the specified output via DPMS. To turn an output off
+        Deprecated. Alias for _power_.
-        (ie. blank the screen but keep workspaces as-is), one can set DPMS to off.
 *output* <name> max_render_time off|<msec>
        Controls when sway composites the output, as a positive number of
@@ -147,6 +163,21 @@ must be separated by one space. For example:
        adaptive sync can improve latency, but can cause flickering on some
        hardware.
+*output* <name> render_bit_depth 8|10
+        Controls the color channel bit depth at which frames are rendered; the
+        default is currently 8 bits per channel.
+        Setting higher values will not have an effect if hardware and software lack
+        support for such bit depths. Successfully increasing the render bit depth
+        will not necessarily increase the bit depth of the frames sent to a display.
+        An increased render bit depth may provide smoother rendering of gradients,
+        and screenshots which can more precisely store the colors of programs
+        which display high bit depth colors.
+        Warnings: this can break screenshot/screencast programs which have not been
+        updated to work with different bit depths. This command is experimental,
+        and may be removed or changed in the future.
 # SEE ALSO
 *sway*(5) *sway-input*(5)
diff --git a/sway/sway.5.scd b/sway/sway.5.scd
index 8958c7e3..9f823947 100644
--- a/sway/sway.5.scd
+++ b/sway/sway.5.scd
@@ -176,6 +176,12 @@ set|plus|minus|toggle <amount>
 *layout* default|splith|splitv|stacking|tabbed
        Sets the layout mode of the focused container.
+        When using the _stacking_ layout, only the focused window in the container is
+        displayed, with the opened windows' list on the top of the container.
+        The _tabbed_ layout is similar to _stacking_, but the windows’ list is vertically
+        split.
 *layout* toggle [split|all]
        Cycles the layout mode of the focused container though a preset list of
        layouts. If no argument is given, then it cycles through stacking, tabbed
@@ -210,15 +216,14 @@ set|plus|minus|toggle <amount>
        further details.
 *move* left|right|up|down [<px> px]
-        Moves the focused container in the direction specified. If the container,
+        Moves the focused container in the direction specified. The optional _px_
-        the optional _px_ argument specifies how many pixels to move the container.
+        argument specifies how many pixels to move the container. If unspecified,
-        If unspecified, the default is 10 pixels. Pixels are ignored when moving
+        the default is 10 pixels. Pixels are ignored when moving tiled containers.
-        tiled containers.
-*move* [absolute] position <pos_x> [px|ppt] <pos_y> [px|ptt]
+*move* [absolute] position <pos_x> [px|ppt] <pos_y> [px|ppt]
        Moves the focused container to the specified position in the workspace.
        The position can be specified in pixels or percentage points, omitting
-        the unit defaults to pixels. If _absolute_ is used, the position is
+        the unit defaults to pixels. If _absolute_ is used, the position is
        relative to all outputs. _absolute_ can not be used with percentage points.
 *move* [absolute] position center
@@ -319,8 +324,10 @@ set|plus|minus|toggle <amount>
        established by the *seat* subcommand of the same name. See
        *sway-input*(5) for more ways to affect inhibitors.
-*split* vertical|v|horizontal|h|toggle|t
+*split* vertical|v|horizontal|h|none|n|toggle|t
-        Splits the current container, vertically or horizontally. When _toggle_ is
+        Splits the current container, vertically or horizontally. When _none_ is
+        specified, the effect of a previous split is undone if the current
+        container is the only child of a split parent. When _toggle_ is
        specified, the current container is split opposite to the parent
        container's layout.
@@ -382,8 +389,8 @@ runtime.
                for_window <criteria> move container to output <output>
 *bindsym* [--whole-window] [--border] [--exclude-titlebar] [--release] [--locked] \
-[--to-code] [--input-device=<device>] [--no-warn] [--no-repeat] [Group<1-4>+]<key combo> \
+[--to-code] [--input-device=<device>] [--no-warn] [--no-repeat] [--inhibited] \
-<command>
+[Group<1-4>+]<key combo> <command>
        Binds _key combo_ to execute the sway command _command_ when pressed. You
        may use XKB key names here (*wev*(1) is a good tool for discovering these).
        With the flag _--release_, the command is executed when the key combo is
@@ -393,6 +400,12 @@ runtime.
        only be available for that group. By default, if you overwrite a binding,
        swaynag will give you a warning. To silence this, use the _--no-warn_ flag.
+        For specifying modifier keys, you can use the XKB modifier names _Shift_,
+        _Lock_ (for Caps Lock), _Control_, _Mod1_ (for Alt), _Mod2_ (for Num Lock),
+        _Mod3_ (for XKB modifier Mod3), _Mod4_ (for the Logo key), and _Mod5_ (for
+        AltGr). In addition, you can use the aliases  _Ctrl_ (for Control), _Alt_
+        (for Alt), and _Super_ (for the Logo key).
        Unless the flag _--locked_ is set, the command will not be run when a
        screen locking program is active. If there is a matching binding with
        and without _--locked_, the one with will be preferred when locked and the
@@ -404,7 +417,7 @@ runtime.
        a keyboard shortcuts inhibitor is active for the currently focused
        window. Such inhibitors are usually requested by remote desktop and
        virtualization software to enable the user to send keyboard shortcuts
-        to the remote or virtual session. The _--inhibited_ flag allows to
+        to the remote or virtual session. The _--inhibited_ flag allows one to
        define bindings which will be exempt from pass-through to such
        software. The same preference logic as for _--locked_ applies.
@@ -447,7 +460,8 @@ runtime.
 ```
        *bindcode* [--whole-window] [--border] [--exclude-titlebar] [--release] \
-[--locked] [--input-device=<device>] [--no-warn] [Group<1-4>+]<code> <command>
+[--locked] [--input-device=<device>] [--no-warn] [--no-repeat] [--inhibited] \
+[Group<1-4>+]<code> <command>
        is also available for binding with key/button codes instead of key/button names.
 *bindswitch* [--locked] [--no-warn] [--reload] <switch>:<state> <command>
@@ -480,6 +494,62 @@ runtime.
                bindswitch lid:toggle exec echo "Lid moved"
 ```
+*bindgesture* [--exact] [--input-device=<device>] [--no-warn] \
+<gesture>[:<fingers>][:directions] <command>
+        Binds _gesture_ to execute the sway command _command_ when detected.
+        Currently supports the _hold_, _pinch_ or _swipe_ gesture. Optionally
+        can be limited to bind to a certain number of _fingers_ or, for a
+        _pinch_ or _swipe_ gesture, to certain _directions_.
+[[ *type*
+:[ *fingers*
+:< *direction*
+|  hold
+:- 1 - 5
+:  none
+|  swipe
+:  3 - 5
+:  up, down, left, right
+|  pinch
+:  2 - 5
+:  all above + inward, outward, clockwise, counterclockwise
+        The _fingers_ can be limited to any sensible number or left empty to accept
+        any finger counts.
+        Valid directions are _up_, _down_, _left_ and _right_, as well as _inward_,
+        _outward_, _clockwise_, _counterclockwise_ for the _pinch_ gesture.
+        Multiple directions can be combined by a plus.
+        If a _input-device_ is given, the binding will only be executed for
+        that input device and will be executed instead of any binding that is
+        generic to all devices. By default, if you overwrite a binding,
+        swaynag will give you a warning. To silence this, use the _--no-warn_ flag.
+        The _--exact_ flag can be used to ensure a binding only matches when exactly
+        all specified directions are matched and nothing more. If there is matching
+        binding with _--exact_, it will be preferred.
+        The priority for matching bindings is as follows: input device, then
+        exact matches followed by matches with the highest number of matching
+        directions.
+        Gestures executed while the pointer is above a bar are not handled by sway.
+        See the respective documentation, e.g. *bindgesture* in *sway-bar*(5).
+        Example:
+```
+                # Allow switching between workspaces with left and right swipes
+                bindgesture swipe:right workspace prev
+                bindgesture swipe:left workspace next
+                # Allow container movements by pinching them
+                bindgesture pinch:inward+up move up
+                bindgesture pinch:inward+down move down
+                bindgesture pinch:inward+left move left
+                bindgesture pinch:inward+right move right
+```
 *client.background* <color>
        This command is ignored and is only present for i3 compatibility.
@@ -497,6 +567,12 @@ runtime.
        *client.focused_inactive*
                The most recently focused view within a container which is not focused.
+        *client.focused_tab_title*
+                A view that has focused descendant container.
+                Tab or stack container title that is the parent of the focused container
+                but is not directly focused. Defaults to focused_inactive if not
+                specified and does not use the indicator and child_border colors.
        *client.placeholder*
                Ignored (present for i3 compatibility).
@@ -552,6 +628,12 @@ The default colors are:
 :  #ffffff
 :  #484e50
 :  #5f676a
+|  *focused_tab_title*
+:  #333333
+:  #5f676a
+:  #ffffff
+:  n/a
+:  n/a
 |  *unfocused*
 :  #333333
 :  #222222
@@ -573,7 +655,8 @@ The default colors are:
 *default_border* normal|none|pixel [<n>]
-        Set default border style for new tiled windows.
+        Set default border style for new tiled windows. Config reload won't affect
+        existing windows, only newly created ones after the reload.
 *default_floating_border* normal|none|pixel [<n>]
        Set default border style for new floating windows. This only applies to
@@ -606,11 +689,11 @@ The default colors are:
        after switching between workspaces.
 *focus_on_window_activation* smart|urgent|focus|none
-        This option determines what to do when an xwayland client requests
+        This option determines what to do when a client requests window activation.
-        window activation. If set to _urgent_, the urgent state will be set
+        If set to _urgent_, the urgent state will be set for that window. If set to
-        for that window. If set to _focus_, the window will become focused.
+        _focus_, the window will become focused. If set to _smart_, the window will
-        If set to _smart_, the window will become focused only if it is already
+        become focused only if it is already visible, otherwise the urgent state
-        visible, otherwise the urgent state will be set. Default is _urgent_.
+        will be set. Default is _urgent_.
 *focus_wrapping* yes|no|force|workspace
        This option determines what to do when attempting to focus over the edge
@@ -630,14 +713,14 @@ The default colors are:
        should be used instead. Regardless of whether pango markup is enabled,
        _font_ should be specified as a pango font description. For more
        information on pango font descriptions, see
-        https://developer.gnome.org/pango/stable/pango-Fonts.html#pango-font-description-from-string
+        https://docs.gtk.org/Pango/type_func.FontDescription.from_string.html#description
 *force_display_urgency_hint* <timeout> [ms]
        If an application on another workspace sets an urgency hint, switching to this
        workspace may lead to immediate focus of the application, which also means the
-        window decoration color would be immediately resetted to *client.focused*. This
+        window decoration color would be immediately reset to *client.focused*. This
        may make it unnecessarily hard to tell which window originally raised the
-        event. This option allows to set a _timeout_ in ms to delay the urgency hint reset.
+        event. This option allows one to set a _timeout_ in ms to delay the urgency hint reset.
 *titlebar_border_thickness* <thickness>
        Thickness of the titlebar border in pixels
@@ -690,9 +773,10 @@ The default colors are:
        borders will only be enabled if the workspace has more than one visible
        child and gaps equal to zero.
-*smart_gaps* on|off
+*smart_gaps* on|off|toggle|inverse_outer
        If smart_gaps are _on_ gaps will only be enabled if a workspace has more
-        than one child.
+        than one child. If smart_gaps are _inverse_outer_ outer gaps will only
+        be enabled if a workspace has exactly one child.
 *mark* --add|--replace [--toggle] <identifier>
        Marks are arbitrary labels that can be used to identify certain windows and
@@ -731,6 +815,10 @@ The default colors are:
        dialog will not be rendered. If _leave_fullscreen_, the view will exit
        fullscreen mode and the dialog will be rendered.
+*primary_selection* enabled|disabled
+        Enable or disable the primary selection clipboard. May only be configured
+        at launch. Default is _enabled_.
 *set* $<name> <value>
        Sets variable $_name_ to _value_. You can use the new variable in the
        arguments of future commands. When the variable is used, it can be escaped
@@ -771,6 +859,11 @@ The default colors are:
 *unbindswitch* <switch>:<state>
        Removes a binding for when <switch> changes to <state>.
+*unbindgesture* [--exact] [--input-device=<device>] \
+<gesture>[:<fingers>][:directions]
+        Removes a binding for the specified _gesture_, _fingers_
+        and _directions_ combination.
 *unbindsym* [--whole-window] [--border] [--exclude-titlebar] [--release] [--locked] \
 [--to-code] [--input-device=<device>] <key combo>
        Removes the binding for _key combo_ that was previously bound with the
@@ -876,6 +969,9 @@ properties in practice for your applications.
 The following attributes may be matched with:
+*all*
+        Matches all windows.
 *app_id*
        Compare value against the app id. Can be a regular expression. If value is
        \_\_focused\_\_, then the app id must be the same as that of the currently
@@ -884,7 +980,8 @@ The following attributes may be matched with:
 *class*
        Compare value against the window class. Can be a regular expression. If
        value is \_\_focused\_\_, then the window class must be the same as that of
-        the currently focused window. _class_ are specific to X11 applications.
+        the currently focused window. _class_ are specific to X11 applications and
+        require XWayland.
 *con_id*
        Compare against the internal container ID, which you can find via IPC. If
@@ -898,12 +995,14 @@ The following attributes may be matched with:
        Matches floating windows.
 *id*
-        Compare value against the X11 window ID. Must be numeric.
+        Compare value against the X11 window ID. Must be numeric. id is specific to
+        X11 applications and requires XWayland.
 *instance*
        Compare value against the window instance. Can be a regular expression. If
        value is \_\_focused\_\_, then the window instance must be the same as that
-        of the currently focused window.
+        of the currently focused window. instance is specific to X11 applications and
+        requires XWayland.
 *pid*
        Compare value against the window's process ID. Must be numeric.
@@ -928,12 +1027,14 @@ The following attributes may be matched with:
 *window_role*
        Compare against the window role (WM_WINDOW_ROLE). Can be a regular
        expression. If value is \_\_focused\_\_, then the window role must be the
-        same as that of the currently focused window.
+        same as that of the currently focused window. window_role is specific to X11
+        applications and requires XWayland.
 *window_type*
        Compare against the window type (\_NET_WM_WINDOW_TYPE). Possible values
        are normal, dialog, utility, toolbar, splash, menu, dropdown_menu,
-        popup_menu, tooltip and notification.
+        popup_menu, tooltip and notification. window_type is specific to X11
+        applications and requires XWayland.
 *workspace*
        Compare against the workspace name for this view. Can be a regular
diff --git a/sway/sway_text_node.c b/sway/sway_text_node.c
new file mode 100644
index 00000000..4b7ee999
--- /dev/null
+++ b/sway/sway_text_node.c
@@ -0,0 +1,308 @@
+#include <drm_fourcc.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wlr/types/wlr_buffer.h>
+#include <wlr/interfaces/wlr_buffer.h>
+#include "cairo_util.h"
+#include "log.h"
+#include "pango.h"
+#include "sway/config.h"
+#include "sway/sway_text_node.h"
+struct cairo_buffer {
+        struct wlr_buffer base;
+        cairo_surface_t *surface;
+        cairo_t *cairo;
+};
+static void cairo_buffer_handle_destroy(struct wlr_buffer *wlr_buffer) {
+        struct cairo_buffer *buffer = wl_container_of(wlr_buffer, buffer, base);
+        cairo_surface_destroy(buffer->surface);
+        cairo_destroy(buffer->cairo);
+        free(buffer);
+}
+static bool cairo_buffer_handle_begin_data_ptr_access(struct wlr_buffer *wlr_buffer,
+                uint32_t flags, void **data, uint32_t *format, size_t *stride) {
+        struct cairo_buffer *buffer = wl_container_of(wlr_buffer, buffer, base);
+        *data = cairo_image_surface_get_data(buffer->surface);
+        *stride = cairo_image_surface_get_stride(buffer->surface);
+        *format = DRM_FORMAT_ARGB8888;
+        return true;
+}
+static void cairo_buffer_handle_end_data_ptr_access(struct wlr_buffer *wlr_buffer) {
+        // This space is intentionally left blank
+}
+static const struct wlr_buffer_impl cairo_buffer_impl = {
+        .destroy = cairo_buffer_handle_destroy,
+        .begin_data_ptr_access = cairo_buffer_handle_begin_data_ptr_access,
+        .end_data_ptr_access = cairo_buffer_handle_end_data_ptr_access,
+};
+struct text_buffer {
+        struct wlr_scene_buffer *buffer_node;
+        char *text;
+        struct sway_text_node props;
+        bool visible;
+        float scale;
+        enum wl_output_subpixel subpixel;
+        struct wl_listener outputs_update;
+        struct wl_listener destroy;
+};
+static int get_text_width(struct sway_text_node *props) {
+        int width = props->width;
+        if (props->max_width >= 0) {
+                width = MIN(width, props->max_width);
+        }
+        return MAX(width, 0);
+}
+static void update_source_box(struct text_buffer *buffer) {
+        struct sway_text_node *props = &buffer->props;
+        struct wlr_fbox source_box = {
+                .x = 0,
+                .y = 0,
+                .width = ceil(get_text_width(props) * buffer->scale),
+                .height = ceil(props->height * buffer->scale),
+        };
+        wlr_scene_buffer_set_source_box(buffer->buffer_node, &source_box);
+}
+static void render_backing_buffer(struct text_buffer *buffer) {
+        if (!buffer->visible) {
+                return;
+        }
+        if (buffer->props.max_width == 0) {
+                wlr_scene_buffer_set_buffer(buffer->buffer_node, NULL);
+                return;
+        }
+        float scale = buffer->scale;
+        int width = ceil(buffer->props.width * scale);
+        int height = ceil(buffer->props.height * scale);
+        float *color = (float *)&buffer->props.color;
+        float *background = (float *)&buffer->props.background;
+        PangoContext *pango = NULL;
+        cairo_font_options_t *fo = cairo_font_options_create();
+        cairo_font_options_set_hint_style(fo, CAIRO_HINT_STYLE_FULL);
+        enum wl_output_subpixel subpixel = buffer->subpixel;
+        if (subpixel == WL_OUTPUT_SUBPIXEL_NONE || subpixel == WL_OUTPUT_SUBPIXEL_UNKNOWN) {
+                cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_GRAY);
+        } else {
+                cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_SUBPIXEL);
+                cairo_font_options_set_subpixel_order(fo, to_cairo_subpixel_order(subpixel));
+        }
+        cairo_surface_t *surface = cairo_image_surface_create(
+                        CAIRO_FORMAT_ARGB32, width, height);
+        cairo_status_t status = cairo_surface_status(surface);
+        if (status != CAIRO_STATUS_SUCCESS) {
+                sway_log(SWAY_ERROR, "cairo_image_surface_create failed: %s",
+                        cairo_status_to_string(status));
+                goto err;
+        }
+        struct cairo_buffer *cairo_buffer = calloc(1, sizeof(*cairo_buffer));
+        if (!cairo_buffer) {
+                sway_log(SWAY_ERROR, "cairo_buffer allocation failed");
+                goto err;
+        }
+        cairo_t *cairo = cairo_create(surface);
+        if (!cairo) {
+                sway_log(SWAY_ERROR, "cairo_create failed");
+                free(cairo_buffer);
+                goto err;
+        }
+        cairo_set_antialias(cairo, CAIRO_ANTIALIAS_BEST);
+        cairo_set_font_options(cairo, fo);
+        pango = pango_cairo_create_context(cairo);
+        cairo_set_source_rgba(cairo, background[0], background[1], background[2], background[3]);
+        cairo_rectangle(cairo, 0, 0, width, height);
+        cairo_fill(cairo);
+        cairo_set_source_rgba(cairo, color[0], color[1], color[2], color[3]);
+        cairo_move_to(cairo, 0, (config->font_baseline - buffer->props.baseline) * scale);
+        render_text(cairo, config->font_description, scale, buffer->props.pango_markup,
+                "%s", buffer->text);
+        cairo_surface_flush(surface);
+        wlr_buffer_init(&cairo_buffer->base, &cairo_buffer_impl, width, height);
+        cairo_buffer->surface = surface;
+        cairo_buffer->cairo = cairo;
+        wlr_scene_buffer_set_buffer(buffer->buffer_node, &cairo_buffer->base);
+        wlr_buffer_drop(&cairo_buffer->base);
+        update_source_box(buffer);
+        pixman_region32_t opaque;
+        pixman_region32_init(&opaque);
+        if (background[3] == 1) {
+                pixman_region32_union_rect(&opaque, &opaque, 0, 0,
+                        buffer->props.width, buffer->props.height);
+        }
+        wlr_scene_buffer_set_opaque_region(buffer->buffer_node, &opaque);
+        pixman_region32_fini(&opaque);
+err:
+        if (pango) g_object_unref(pango);
+        cairo_font_options_destroy(fo);
+}
+static void handle_outputs_update(struct wl_listener *listener, void *data) {
+        struct text_buffer *buffer = wl_container_of(listener, buffer, outputs_update);
+        struct wlr_scene_outputs_update_event *event = data;
+        float scale = 0;
+        enum wl_output_subpixel subpixel = WL_OUTPUT_SUBPIXEL_UNKNOWN;
+        for (size_t i = 0; i < event->size; i++) {
+                struct wlr_scene_output *output = event->active[i];
+                if (subpixel == WL_OUTPUT_SUBPIXEL_UNKNOWN) {
+                        subpixel = output->output->subpixel;
+                } else if (subpixel != output->output->subpixel) {
+                        subpixel = WL_OUTPUT_SUBPIXEL_NONE;
+                }
+                if (scale != 0 && scale != output->output->scale) {
+                        // drop down to gray scale if we encounter outputs with different
+                        // scales or else we will have chromatic aberations
+                        subpixel = WL_OUTPUT_SUBPIXEL_NONE;
+                }
+                if (scale < output->output->scale) {
+                        scale = output->output->scale;
+                }
+        }
+        buffer->visible = event->size > 0;
+        if (scale != buffer->scale || subpixel != buffer->subpixel) {
+                buffer->scale = scale;
+                buffer->subpixel = subpixel;
+                render_backing_buffer(buffer);
+        }
+}
+static void handle_destroy(struct wl_listener *listener, void *data) {
+        struct text_buffer *buffer = wl_container_of(listener, buffer, destroy);
+        wl_list_remove(&buffer->outputs_update.link);
+        wl_list_remove(&buffer->destroy.link);
+        free(buffer->text);
+        free(buffer);
+}
+static void text_calc_size(struct text_buffer *buffer) {
+        struct sway_text_node *props = &buffer->props;
+        cairo_t *c = cairo_create(NULL);
+        if (!c) {
+                sway_log(SWAY_ERROR, "cairo_t allocation failed");
+                return;
+        }
+        cairo_set_antialias(c, CAIRO_ANTIALIAS_BEST);
+        get_text_size(c, config->font_description, &props->width, NULL,
+                &props->baseline, 1, props->pango_markup, "%s", buffer->text);
+        cairo_destroy(c);
+        wlr_scene_buffer_set_dest_size(buffer->buffer_node,
+                get_text_width(props), props->height);
+}
+struct sway_text_node *sway_text_node_create(struct wlr_scene_tree *parent,
+                char *text, float color[4], bool pango_markup) {
+        struct text_buffer *buffer = calloc(1, sizeof(*buffer));
+        if (!buffer) {
+                return NULL;
+        }
+        struct wlr_scene_buffer *node = wlr_scene_buffer_create(parent, NULL);
+        if (!node) {
+                free(buffer);
+                return NULL;
+        }
+        buffer->buffer_node = node;
+        buffer->props.node = &node->node;
+        buffer->props.max_width = -1;
+        buffer->text = strdup(text);
+        if (!buffer->text) {
+                free(buffer);
+                wlr_scene_node_destroy(&node->node);
+                return NULL;
+        }
+        buffer->props.height = config->font_height;
+        buffer->props.pango_markup = pango_markup;
+        memcpy(&buffer->props.color, color, sizeof(*color) * 4);
+        buffer->destroy.notify = handle_destroy;
+        wl_signal_add(&node->node.events.destroy, &buffer->destroy);
+        buffer->outputs_update.notify = handle_outputs_update;
+        wl_signal_add(&node->events.outputs_update, &buffer->outputs_update);
+        text_calc_size(buffer);
+        return &buffer->props;
+}
+void sway_text_node_set_color(struct sway_text_node *node, float color[4]) {
+        if (memcmp(&node->color, color, sizeof(*color) * 4) == 0) {
+                return;
+        }
+        memcpy(&node->color, color, sizeof(*color) * 4);
+        struct text_buffer *buffer = wl_container_of(node, buffer, props);
+        render_backing_buffer(buffer);
+}
+void sway_text_node_set_text(struct sway_text_node *node, char *text) {
+        struct text_buffer *buffer = wl_container_of(node, buffer, props);
+        if (strcmp(buffer->text, text) == 0) {
+                return;
+        }
+        char *new_text = strdup(text);
+        if (!new_text) {
+                return;
+        }
+        free(buffer->text);
+        buffer->text = new_text;
+        text_calc_size(buffer);
+        render_backing_buffer(buffer);
+}
+void sway_text_node_set_max_width(struct sway_text_node *node, int max_width) {
+        struct text_buffer *buffer = wl_container_of(node, buffer, props);
+        buffer->props.max_width = max_width;
+        wlr_scene_buffer_set_dest_size(buffer->buffer_node,
+                get_text_width(&buffer->props), buffer->props.height);
+        update_source_box(buffer);
+        render_backing_buffer(buffer);
+}
+void sway_text_node_set_background(struct sway_text_node *node, float background[4]) {
+        struct text_buffer *buffer = wl_container_of(node, buffer, props);
+        memcpy(&node->background, background, sizeof(*background) * 4);
+        render_backing_buffer(buffer);
+}
diff --git a/sway/swaynag.c b/sway/swaynag.c
index ba582989..bc5e23ea 100644
--- a/sway/swaynag.c
+++ b/sway/swaynag.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <signal.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -64,6 +63,8 @@ bool swaynag_spawn(const char *swaynag_command,
                sway_log(SWAY_ERROR, "Failed to create fork for swaynag");
                goto failed;
        } else if (pid == 0) {
+                restore_nofile_limit();
                pid = fork();
                if (pid < 0) {
                        sway_log_errno(SWAY_ERROR, "fork failed");
@@ -143,22 +144,16 @@ void swaynag_log(const char *swaynag_command, struct swaynag_instance *swaynag,
        va_list args;
        va_start(args, fmt);
-        size_t length = vsnprintf(NULL, 0, fmt, args) + 1;
+        char *str = vformat_str(fmt, args);
        va_end(args);
+        if (!str) {
-        char *temp = malloc(length + 1);
-        if (!temp) {
                sway_log(SWAY_ERROR, "Failed to allocate buffer for swaynag log entry.");
                return;
        }
-        va_start(args, fmt);
+        write(swaynag->fd[1], str, strlen(str));
-        vsnprintf(temp, length, fmt, args);
-        va_end(args);
-        write(swaynag->fd[1], temp, length);
-        free(temp);
+        free(str);
 }
 void swaynag_show(struct swaynag_instance *swaynag) {
diff --git a/sway/tree/arrange.c b/sway/tree/arrange.c
index 4aa82c35..d4003fe6 100644
--- a/sway/tree/arrange.c
+++ b/sway/tree/arrange.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <ctype.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -264,6 +263,9 @@ void arrange_workspace(struct sway_workspace *workspace) {
                        area->width, area->height, area->x, area->y);
        bool first_arrange = workspace->width == 0 && workspace->height == 0;
+        struct wlr_box prev_box;
+        workspace_get_box(workspace, &prev_box);
        double prev_x = workspace->x - workspace->current_gaps.left;
        double prev_y = workspace->y - workspace->current_gaps.top;
        workspace->width = area->width;
@@ -277,13 +279,14 @@ void arrange_workspace(struct sway_workspace *workspace) {
        if (!first_arrange && (diff_x != 0 || diff_y != 0)) {
                for (int i = 0; i < workspace->floating->length; ++i) {
                        struct sway_container *floater = workspace->floating->items[i];
-                        container_floating_translate(floater, diff_x, diff_y);
-                        double center_x = floater->pending.x + floater->pending.width / 2;
-                        double center_y = floater->pending.y + floater->pending.height / 2;
                        struct wlr_box workspace_box;
                        workspace_get_box(workspace, &workspace_box);
-                        if (!wlr_box_contains_point(&workspace_box, center_x, center_y)) {
+                        floating_fix_coordinates(floater, &prev_box, &workspace_box);
-                                container_floating_move_to_center(floater);
+                        // Set transformation for scratchpad windows.
+                        if (floater->scratchpad) {
+                                struct wlr_box output_box;
+                                output_get_box(output, &output_box);
+                                floater->transform = output_box;
                        }
                }
        }
@@ -311,12 +314,13 @@ void arrange_output(struct sway_output *output) {
        if (config->reloading) {
                return;
        }
-        const struct wlr_box *output_box = wlr_output_layout_get_box(
+        struct wlr_box output_box;
-                        root->output_layout, output->wlr_output);
+        wlr_output_layout_get_box(root->output_layout,
-        output->lx = output_box->x;
+                output->wlr_output, &output_box);
-        output->ly = output_box->y;
+        output->lx = output_box.x;
-        output->width = output_box->width;
+        output->ly = output_box.y;
-        output->height = output_box->height;
+        output->width = output_box.width;
+        output->height = output_box.height;
        for (int i = 0; i < output->workspaces->length; ++i) {
                struct sway_workspace *workspace = output->workspaces->items[i];
@@ -328,12 +332,12 @@ void arrange_root(void) {
        if (config->reloading) {
                return;
        }
-        const struct wlr_box *layout_box =
+        struct wlr_box layout_box;
-                wlr_output_layout_get_box(root->output_layout, NULL);
+        wlr_output_layout_get_box(root->output_layout, NULL, &layout_box);
-        root->x = layout_box->x;
+        root->x = layout_box.x;
-        root->y = layout_box->y;
+        root->y = layout_box.y;
-        root->width = layout_box->width;
+        root->width = layout_box.width;
-        root->height = layout_box->height;
+        root->height = layout_box.height;
        if (root->fullscreen_global) {
                struct sway_container *fs = root->fullscreen_global;
diff --git a/sway/tree/container.c b/sway/tree/container.c
index 1e84e603..80ef34fe 100644
--- a/sway/tree/container.c
+++ b/sway/tree/container.c
@@ -1,29 +1,77 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <drm_fourcc.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <string.h>
-#include <strings.h>
 #include <wayland-server-core.h>
+#include <wlr/types/wlr_foreign_toplevel_management_v1.h>
+#include <wlr/types/wlr_linux_dmabuf_v1.h>
 #include <wlr/types/wlr_output_layout.h>
-#include "cairo_util.h"
+#include <wlr/types/wlr_subcompositor.h>
-#include "pango.h"
+#include "linux-dmabuf-unstable-v1-protocol.h"
 #include "sway/config.h"
-#include "sway/desktop.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/seat.h"
 #include "sway/ipc-server.h"
+#include "sway/scene_descriptor.h"
+#include "sway/sway_text_node.h"
 #include "sway/output.h"
 #include "sway/server.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/view.h"
 #include "sway/tree/workspace.h"
+#include "sway/xdg_decoration.h"
 #include "list.h"
 #include "log.h"
 #include "stringop.h"
+static void handle_output_enter(
+                struct wl_listener *listener, void *data) {
+        struct sway_container *con = wl_container_of(
+                        listener, con, output_enter);
+        struct wlr_scene_output *output = data;
+        if (con->view->foreign_toplevel) {
+                wlr_foreign_toplevel_handle_v1_output_enter(
+                        con->view->foreign_toplevel, output->output);
+        }
+}
+static void handle_output_leave(
+                struct wl_listener *listener, void *data) {
+        struct sway_container *con = wl_container_of(
+                        listener, con, output_leave);
+        struct wlr_scene_output *output = data;
+        if (con->view->foreign_toplevel) {
+                wlr_foreign_toplevel_handle_v1_output_leave(
+                        con->view->foreign_toplevel, output->output);
+        }
+}
+static bool handle_point_accepts_input(
+                struct wlr_scene_buffer *buffer, double *x, double *y) {
+        return false;
+}
+static struct wlr_scene_rect *alloc_rect_node(struct wlr_scene_tree *parent,
+                bool *failed) {
+        if (*failed) {
+                return NULL;
+        }
+        // just pass in random values. These will be overwritten when
+        // they need to be used.
+        struct wlr_scene_rect *rect = wlr_scene_rect_create(
+                parent, 0, 0, (float[4]){0.f, 0.f, 0.f, 1.f});
+        if (!rect) {
+                sway_log(SWAY_ERROR, "Failed to allocate a wlr_scene_rect");
+                *failed = true;
+        }
+        return rect;
+}
 struct sway_container *container_create(struct sway_view *view) {
        struct sway_container *c = calloc(1, sizeof(struct sway_container));
        if (!c) {
@@ -31,23 +79,415 @@ struct sway_container *container_create(struct sway_view *view) {
                return NULL;
        }
        node_init(&c->node, N_CONTAINER, c);
-        c->pending.layout = L_NONE;
-        c->view = view;
+        // Container tree structure
-        c->alpha = 1.0f;
+        // - scene tree
+        //   - title bar
+        //     - border
+        //     - background
+        //     - title text
+        //     - marks text
+        //   - border
+        //     - border top/bottom/left/right
+        //     - content_tree (we put the content node here so when we disable the
+        //       border everything gets disabled. We only render the content iff there
+        //       is a border as well)
+        //     - buffer used for output enter/leave events for foreign_toplevel
+        bool failed = false;
+        c->scene_tree = alloc_scene_tree(root->staging, &failed);
+        c->title_bar.tree = alloc_scene_tree(c->scene_tree, &failed);
+        c->title_bar.border = alloc_scene_tree(c->title_bar.tree, &failed);
+        c->title_bar.background = alloc_scene_tree(c->title_bar.tree, &failed);
+        // for opacity purposes we need to carfully create the scene such that
+        // none of our rect nodes as well as text buffers don't overlap. To do
+        // this we have to create rects such that they go around text buffers
+        for (int i = 0; i < 4; i++) {
+                alloc_rect_node(c->title_bar.border, &failed);
+        }
+        for (int i = 0; i < 5; i++) {
+                alloc_rect_node(c->title_bar.background, &failed);
+        }
+        c->border.tree = alloc_scene_tree(c->scene_tree, &failed);
+        c->content_tree = alloc_scene_tree(c->border.tree, &failed);
+        if (view) {
+                // only containers with views can have borders
+                c->border.top = alloc_rect_node(c->border.tree, &failed);
+                c->border.bottom = alloc_rect_node(c->border.tree, &failed);
+                c->border.left = alloc_rect_node(c->border.tree, &failed);
+                c->border.right = alloc_rect_node(c->border.tree, &failed);
+                c->output_handler = wlr_scene_buffer_create(c->border.tree, NULL);
+                if (!c->output_handler) {
+                        sway_log(SWAY_ERROR, "Failed to allocate a scene node");
+                        failed = true;
+                }
+                if (!failed) {
+                        c->output_enter.notify = handle_output_enter;
+                        wl_signal_add(&c->output_handler->events.output_enter,
+                                        &c->output_enter);
+                        c->output_leave.notify = handle_output_leave;
+                        wl_signal_add(&c->output_handler->events.output_leave,
+                                        &c->output_leave);
+                        c->output_handler->point_accepts_input = handle_point_accepts_input;
+                }
+        }
+        if (!failed && !scene_descriptor_assign(&c->scene_tree->node,
+                        SWAY_SCENE_DESC_CONTAINER, c)) {
+                failed = true;
+        }
+        if (failed) {
+                wlr_scene_node_destroy(&c->scene_tree->node);
+                free(c);
+                return NULL;
+        }
        if (!view) {
                c->pending.children = create_list();
                c->current.children = create_list();
        }
+        c->pending.layout = L_NONE;
+        c->view = view;
+        c->alpha = 1.0f;
        c->marks = create_list();
-        c->outputs = create_list();
        wl_signal_init(&c->events.destroy);
-        wl_signal_emit(&root->events.new_node, &c->node);
+        wl_signal_emit_mutable(&root->events.new_node, &c->node);
+        container_update(c);
        return c;
 }
+static bool container_is_focused(struct sway_container *con, void *data) {
+        return con->current.focused;
+}
+static bool container_has_focused_child(struct sway_container *con) {
+        return container_find_child(con, container_is_focused, NULL);
+}
+static bool container_is_current_parent_focused(struct sway_container *con) {
+        if (con->current.parent) {
+                struct sway_container *parent = con->current.parent;
+                return parent->current.focused || container_is_current_parent_focused(parent);
+        } else if (con->current.workspace) {
+                struct sway_workspace *ws = con->current.workspace;
+                return ws->current.focused;
+        }
+        return false;
+}
+static struct border_colors *container_get_current_colors(
+                struct sway_container *con) {
+        struct border_colors *colors;
+        bool urgent = con->view ?
+                view_is_urgent(con->view) : container_has_urgent_child(con);
+        struct sway_container *active_child;
+        if (con->current.parent) {
+                active_child = con->current.parent->current.focused_inactive_child;
+        } else if (con->current.workspace) {
+                active_child = con->current.workspace->current.focused_inactive_child;
+        } else {
+                active_child = NULL;
+        }
+        if (urgent) {
+                colors = &config->border_colors.urgent;
+        } else if (con->current.focused || container_is_current_parent_focused(con)) {
+                colors = &config->border_colors.focused;
+        } else if (config->has_focused_tab_title && container_has_focused_child(con)) {
+                colors = &config->border_colors.focused_tab_title;
+        } else if (con == active_child) {
+                colors = &config->border_colors.focused_inactive;
+        } else {
+                colors = &config->border_colors.unfocused;
+        }
+        return colors;
+}
+static bool container_is_current_floating(struct sway_container *container) {
+        if (!container->current.parent && container->current.workspace &&
+                        list_find(container->current.workspace->floating, container) != -1) {
+                return true;
+        }
+        if (container->scratchpad) {
+                return true;
+        }
+        return false;
+}
+// scene rect wants premultiplied colors
+static void scene_rect_set_color(struct wlr_scene_rect *rect,
+                const float color[4], float opacity) {
+        const float premultiplied[] = {
+                color[0] * color[3] * opacity,
+                color[1] * color[3] * opacity,
+                color[2] * color[3] * opacity,
+                color[3] * opacity,
+        };
+        wlr_scene_rect_set_color(rect, premultiplied);
+}
+void container_update(struct sway_container *con) {
+        struct border_colors *colors = container_get_current_colors(con);
+        list_t *siblings = NULL;
+        enum sway_container_layout layout = L_NONE;
+        float alpha = con->alpha;
+        if (con->current.parent) {
+                siblings = con->current.parent->current.children;
+                layout = con->current.parent->current.layout;
+        } else if (con->current.workspace) {
+                siblings = con->current.workspace->current.tiling;
+                layout = con->current.workspace->current.layout;
+        }
+        float bottom[4], right[4];
+        memcpy(bottom, colors->child_border, sizeof(bottom));
+        memcpy(right, colors->child_border, sizeof(right));
+        if (!container_is_current_floating(con) && siblings && siblings->length == 1) {
+                if (layout == L_HORIZ) {
+                        memcpy(right, colors->indicator, sizeof(right));
+                } else if (layout == L_VERT) {
+                        memcpy(bottom, colors->indicator, sizeof(bottom));
+                }
+        }
+        struct wlr_scene_node *node;
+        wl_list_for_each(node, &con->title_bar.border->children, link) {
+                struct wlr_scene_rect *rect = wlr_scene_rect_from_node(node);
+                scene_rect_set_color(rect, colors->border, alpha);
+        }
+        wl_list_for_each(node, &con->title_bar.background->children, link) {
+                struct wlr_scene_rect *rect = wlr_scene_rect_from_node(node);
+                scene_rect_set_color(rect, colors->background, alpha);
+        }
+        if (con->view) {
+                scene_rect_set_color(con->border.top, colors->child_border, alpha);
+                scene_rect_set_color(con->border.bottom, bottom, alpha);
+                scene_rect_set_color(con->border.left, colors->child_border, alpha);
+                scene_rect_set_color(con->border.right, right, alpha);
+        }
+        if (con->title_bar.title_text) {
+                sway_text_node_set_color(con->title_bar.title_text, colors->text);
+                sway_text_node_set_background(con->title_bar.title_text, colors->background);
+        }
+        if (con->title_bar.marks_text) {
+                sway_text_node_set_color(con->title_bar.marks_text, colors->text);
+                sway_text_node_set_background(con->title_bar.marks_text, colors->background);
+        }
+}
+void container_update_itself_and_parents(struct sway_container *con) {
+        container_update(con);
+        if (con->current.parent) {
+                container_update_itself_and_parents(con->current.parent);
+        }
+}
+static void update_rect_list(struct wlr_scene_tree *tree, pixman_region32_t *region) {
+        int len;
+        const pixman_box32_t *rects = pixman_region32_rectangles(region, &len);
+        wlr_scene_node_set_enabled(&tree->node, len > 0);
+        if (len == 0) {
+                return;
+        }
+        int i = 0;
+        struct wlr_scene_node *node;
+        wl_list_for_each(node, &tree->children, link) {
+                struct wlr_scene_rect *rect = wlr_scene_rect_from_node(node);
+                wlr_scene_node_set_enabled(&rect->node, i < len);
+                if (i < len) {
+                        const pixman_box32_t *box = &rects[i++];
+                        wlr_scene_node_set_position(&rect->node, box->x1, box->y1);
+                        wlr_scene_rect_set_size(rect, box->x2 - box->x1, box->y2 - box->y1);
+                }
+        }
+}
+void container_arrange_title_bar(struct sway_container *con) {
+        enum alignment title_align = config->title_align;
+        int marks_buffer_width = 0;
+        int width = con->title_width;
+        int height = container_titlebar_height();
+        pixman_region32_t text_area;
+        pixman_region32_init(&text_area);
+        if (con->title_bar.marks_text) {
+                struct sway_text_node *node = con->title_bar.marks_text;
+                marks_buffer_width = node->width;
+                int h_padding;
+                if (title_align == ALIGN_RIGHT) {
+                        h_padding = config->titlebar_h_padding;
+                } else {
+                        h_padding = width - config->titlebar_h_padding - marks_buffer_width;
+                }
+                h_padding = MAX(h_padding, 0);
+                int alloc_width = MIN((int)node->width,
+                        width - h_padding - config->titlebar_h_padding);
+                alloc_width = MAX(alloc_width, 0);
+                sway_text_node_set_max_width(node, alloc_width);
+                wlr_scene_node_set_position(node->node,
+                        h_padding, (height - node->height) >> 1);
+                pixman_region32_union_rect(&text_area, &text_area,
+                        node->node->x, node->node->y, alloc_width, node->height);
+        }
+        if (con->title_bar.title_text) {
+                struct sway_text_node *node = con->title_bar.title_text;
+                int h_padding;
+                if (title_align == ALIGN_RIGHT) {
+                        h_padding = width - config->titlebar_h_padding - node->width;
+                } else if (title_align == ALIGN_CENTER) {
+                        h_padding = ((int)width - marks_buffer_width - node->width) >> 1;
+                } else {
+                        h_padding = config->titlebar_h_padding;
+                }
+                h_padding = MAX(h_padding, 0);
+                int alloc_width = MIN((int) node->width,
+                        width - h_padding - config->titlebar_h_padding);
+                alloc_width = MAX(alloc_width, 0);
+                sway_text_node_set_max_width(node, alloc_width);
+                wlr_scene_node_set_position(node->node,
+                        h_padding, (height - node->height) >> 1);
+                pixman_region32_union_rect(&text_area, &text_area,
+                        node->node->x, node->node->y, alloc_width, node->height);
+        }
+        // silence pixman errors
+        if (width <= 0 || height <= 0) {
+                pixman_region32_fini(&text_area);
+                return;
+        }
+        pixman_region32_t background, border;
+        int thickness = config->titlebar_border_thickness;
+        pixman_region32_init_rect(&background,
+                thickness, thickness,
+                width - thickness * 2, height - thickness * 2);
+        pixman_region32_init_rect(&border, 0, 0, width, height);
+        pixman_region32_subtract(&border, &border, &background);
+        pixman_region32_subtract(&background, &background, &text_area);
+        pixman_region32_fini(&text_area);
+        update_rect_list(con->title_bar.background, &background);
+        pixman_region32_fini(&background);
+        update_rect_list(con->title_bar.border, &border);
+        pixman_region32_fini(&border);
+        container_update(con);
+}
+void container_update_marks(struct sway_container *con) {
+        char *buffer = NULL;
+        if (config->show_marks && con->marks->length) {
+                size_t len = 0;
+                for (int i = 0; i < con->marks->length; ++i) {
+                        char *mark = con->marks->items[i];
+                        if (mark[0] != '_') {
+                                len += strlen(mark) + 2;
+                        }
+                }
+                buffer = calloc(len + 1, 1);
+                char *part = malloc(len + 1);
+                if (!sway_assert(buffer && part, "Unable to allocate memory")) {
+                        free(buffer);
+                        return;
+                }
+                for (int i = 0; i < con->marks->length; ++i) {
+                        char *mark = con->marks->items[i];
+                        if (mark[0] != '_') {
+                                snprintf(part, len + 1, "[%s]", mark);
+                                strcat(buffer, part);
+                        }
+                }
+                free(part);
+        }
+        if (!buffer) {
+                if (con->title_bar.marks_text) {
+                        wlr_scene_node_destroy(con->title_bar.marks_text->node);
+                        con->title_bar.marks_text = NULL;
+                }
+        } else if (!con->title_bar.marks_text) {
+                struct border_colors *colors = container_get_current_colors(con);
+                con->title_bar.marks_text = sway_text_node_create(con->title_bar.tree,
+                        buffer, colors->text, false);
+        } else {
+                sway_text_node_set_text(con->title_bar.marks_text, buffer);
+        }
+        container_arrange_title_bar(con);
+        free(buffer);
+}
+void container_update_title_bar(struct sway_container *con) {
+        if (!con->formatted_title) {
+                return;
+        }
+        struct border_colors *colors = container_get_current_colors(con);
+        if (con->title_bar.title_text) {
+                wlr_scene_node_destroy(con->title_bar.title_text->node);
+                con->title_bar.title_text = NULL;
+        }
+        con->title_bar.title_text = sway_text_node_create(con->title_bar.tree,
+                con->formatted_title, colors->text, config->pango_markup);
+        // we always have to remake these text buffers completely for text font
+        // changes etc...
+        if (con->title_bar.marks_text) {
+                wlr_scene_node_destroy(con->title_bar.marks_text->node);
+                con->title_bar.marks_text = NULL;
+        }
+        container_update_marks(con);
+        container_arrange_title_bar(con);
+}
 void container_destroy(struct sway_container *con) {
        if (!sway_assert(con->node.destroying,
                                "Tried to free container which wasn't marked as destroying")) {
@@ -59,29 +499,21 @@ void container_destroy(struct sway_container *con) {
        }
        free(con->title);
        free(con->formatted_title);
-        wlr_texture_destroy(con->title_focused);
-        wlr_texture_destroy(con->title_focused_inactive);
-        wlr_texture_destroy(con->title_unfocused);
-        wlr_texture_destroy(con->title_urgent);
        list_free(con->pending.children);
        list_free(con->current.children);
-        list_free(con->outputs);
        list_free_items_and_destroy(con->marks);
-        wlr_texture_destroy(con->marks_focused);
-        wlr_texture_destroy(con->marks_focused_inactive);
-        wlr_texture_destroy(con->marks_unfocused);
-        wlr_texture_destroy(con->marks_urgent);
-        if (con->view) {
+        if (con->view && con->view->container == con) {
-                if (con->view->container == con) {
+                con->view->container = NULL;
-                        con->view->container = NULL;
+                wlr_scene_node_destroy(&con->output_handler->node);
-                }
                if (con->view->destroying) {
                        view_destroy(con->view);
                }
        }
+        scene_node_disown_children(con->content_tree);
+        wlr_scene_node_destroy(&con->scene_tree->node);
        free(con);
 }
@@ -98,7 +530,7 @@ void container_begin_destroy(struct sway_container *con) {
                container_fullscreen_disable(con);
        }
-        wl_signal_emit(&con->node.events.destroy, &con->node);
+        wl_signal_emit_mutable(&con->node.events.destroy, &con->node);
        container_end_mouse_operation(con);
@@ -168,267 +600,6 @@ struct sway_container *container_find_child(struct sway_container *container,
        return NULL;
 }
-static struct sway_container *surface_at_view(struct sway_container *con, double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        if (!sway_assert(con->view, "Expected a view")) {
-                return NULL;
-        }
-        struct sway_view *view = con->view;
-        double view_sx = lx - con->surface_x + view->geometry.x;
-        double view_sy = ly - con->surface_y + view->geometry.y;
-        double _sx, _sy;
-        struct wlr_surface *_surface = NULL;
-        switch (view->type) {
-#if HAVE_XWAYLAND
-        case SWAY_VIEW_XWAYLAND:
-                _surface = wlr_surface_surface_at(view->surface,
-                                view_sx, view_sy, &_sx, &_sy);
-                break;
-#endif
-        case SWAY_VIEW_XDG_SHELL:
-                _surface = wlr_xdg_surface_surface_at(
-                                view->wlr_xdg_surface,
-                                view_sx, view_sy, &_sx, &_sy);
-                break;
-        }
-        if (_surface) {
-                *sx = _sx;
-                *sy = _sy;
-                *surface = _surface;
-                return con;
-        }
-        return NULL;
-}
-/**
- * container_at for a container with layout L_TABBED.
- */
-static struct sway_container *container_at_tabbed(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        struct wlr_box box;
-        node_get_box(parent, &box);
-        if (lx < box.x || lx > box.x + box.width ||
-                        ly < box.y || ly > box.y + box.height) {
-                return NULL;
-        }
-        struct sway_seat *seat = input_manager_current_seat();
-        list_t *children = node_get_children(parent);
-        if (!children->length) {
-                return NULL;
-        }
-        // Tab titles
-        int title_height = container_titlebar_height();
-        if (ly < box.y + title_height) {
-                int tab_width = box.width / children->length;
-                int child_index = (lx - box.x) / tab_width;
-                if (child_index >= children->length) {
-                        child_index = children->length - 1;
-                }
-                struct sway_container *child = children->items[child_index];
-                return child;
-        }
-        // Surfaces
-        struct sway_node *current = seat_get_active_tiling_child(seat, parent);
-        return current ? tiling_container_at(current, lx, ly, surface, sx, sy) : NULL;
-}
-/**
- * container_at for a container with layout L_STACKED.
- */
-static struct sway_container *container_at_stacked(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        struct wlr_box box;
-        node_get_box(parent, &box);
-        if (lx < box.x || lx > box.x + box.width ||
-                        ly < box.y || ly > box.y + box.height) {
-                return NULL;
-        }
-        struct sway_seat *seat = input_manager_current_seat();
-        list_t *children = node_get_children(parent);
-        // Title bars
-        int title_height = container_titlebar_height();
-        if (title_height > 0) {
-                int child_index = (ly - box.y) / title_height;
-                if (child_index < children->length) {
-                        struct sway_container *child = children->items[child_index];
-                        return child;
-                }
-        }
-        // Surfaces
-        struct sway_node *current = seat_get_active_tiling_child(seat, parent);
-        return current ? tiling_container_at(current, lx, ly, surface, sx, sy) : NULL;
-}
-/**
- * container_at for a container with layout L_HORIZ or L_VERT.
- */
-static struct sway_container *container_at_linear(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        list_t *children = node_get_children(parent);
-        for (int i = 0; i < children->length; ++i) {
-                struct sway_container *child = children->items[i];
-                struct sway_container *container =
-                        tiling_container_at(&child->node, lx, ly, surface, sx, sy);
-                if (container) {
-                        return container;
-                }
-        }
-        return NULL;
-}
-static struct sway_container *floating_container_at(double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        // For outputs with floating containers that overhang the output bounds,
-        // those at the end of the output list appear on top of floating
-        // containers from other outputs, so iterate the list in reverse.
-        for (int i = root->outputs->length - 1; i >= 0; --i) {
-                struct sway_output *output = root->outputs->items[i];
-                for (int j = 0; j < output->workspaces->length; ++j) {
-                        struct sway_workspace *ws = output->workspaces->items[j];
-                        if (!workspace_is_visible(ws)) {
-                                continue;
-                        }
-                        // Items at the end of the list are on top, so iterate the list in
-                        // reverse.
-                        for (int k = ws->floating->length - 1; k >= 0; --k) {
-                                struct sway_container *floater = ws->floating->items[k];
-                                struct sway_container *container =
-                                        tiling_container_at(&floater->node, lx, ly, surface, sx, sy);
-                                if (container) {
-                                        return container;
-                                }
-                        }
-                }
-        }
-        return NULL;
-}
-static struct sway_container *view_container_content_at(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        if (!sway_assert(node_is_view(parent), "Expected a view")) {
-                return NULL;
-        }
-        struct sway_container *container = parent->sway_container;
-        struct wlr_box box = {
-                .x = container->pending.content_x,
-                .y = container->pending.content_y,
-                .width = container->pending.content_width,
-                .height = container->pending.content_height,
-        };
-        if (wlr_box_contains_point(&box, lx, ly)) {
-                surface_at_view(parent->sway_container, lx, ly, surface, sx, sy);
-                return container;
-        }
-        return NULL;
-}
-static struct sway_container *view_container_at(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        if (!sway_assert(node_is_view(parent), "Expected a view")) {
-                return NULL;
-        }
-        struct sway_container *container = parent->sway_container;
-        struct wlr_box box = {
-                .x = container->pending.x,
-                .y = container->pending.y,
-                .width = container->pending.width,
-                .height = container->pending.height,
-        };
-        if (wlr_box_contains_point(&box, lx, ly)) {
-                surface_at_view(parent->sway_container, lx, ly, surface, sx, sy);
-                return container;
-        }
-        return NULL;
-}
-struct sway_container *tiling_container_at(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        if (node_is_view(parent)) {
-                return view_container_at(parent, lx, ly, surface, sx, sy);
-        }
-        if (!node_get_children(parent)) {
-                return NULL;
-        }
-        switch (node_get_layout(parent)) {
-        case L_HORIZ:
-        case L_VERT:
-                return container_at_linear(parent, lx, ly, surface, sx, sy);
-        case L_TABBED:
-                return container_at_tabbed(parent, lx, ly, surface, sx, sy);
-        case L_STACKED:
-                return container_at_stacked(parent, lx, ly, surface, sx, sy);
-        case L_NONE:
-                return NULL;
-        }
-        return NULL;
-}
-static bool surface_is_popup(struct wlr_surface *surface) {
-        if (wlr_surface_is_xdg_surface(surface)) {
-                struct wlr_xdg_surface *xdg_surface =
-                        wlr_xdg_surface_from_wlr_surface(surface);
-                while (xdg_surface && xdg_surface->role != WLR_XDG_SURFACE_ROLE_NONE) {
-                        if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP) {
-                                return true;
-                        }
-                        xdg_surface = xdg_surface->toplevel->parent;
-                }
-                return false;
-        }
-        return false;
-}
-struct sway_container *container_at(struct sway_workspace *workspace,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        struct sway_container *c;
-        struct sway_seat *seat = input_manager_current_seat();
-        struct sway_container *focus = seat_get_focused_container(seat);
-        bool is_floating = focus && container_is_floating_or_child(focus);
-        // Focused view's popups
-        if (focus && focus->view) {
-                c = surface_at_view(focus, lx, ly, surface, sx, sy);
-                if (c && surface_is_popup(*surface)) {
-                        return c;
-                }
-                *surface = NULL;
-        }
-        // Floating
-        if ((c = floating_container_at(lx, ly, surface ,sx ,sy))) {
-                return c;
-        }
-        // Tiling (focused)
-        if (focus && focus->view && !is_floating) {
-                if ((c = view_container_content_at(&focus->node, lx, ly, surface, sx, sy))) {
-                        return c;
-                }
-        }
-        // Tiling (non-focused)
-        if ((c = tiling_container_at(&workspace->node, lx, ly, surface, sx, sy))) {
-                return c;
-        }
-        return NULL;
-}
 void container_for_each_child(struct sway_container *container,
                void (*f)(struct sway_container *container, void *data),
                void *data) {
@@ -474,123 +645,6 @@ bool container_has_ancestor(struct sway_container *descendant,
        return false;
 }
-void container_damage_whole(struct sway_container *container) {
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                output_damage_whole_container(output, container);
-        }
-}
-/**
- * Return the output which will be used for scale purposes.
- * This is the most recently entered output.
- */
-struct sway_output *container_get_effective_output(struct sway_container *con) {
-        if (con->outputs->length == 0) {
-                return NULL;
-        }
-        return con->outputs->items[con->outputs->length - 1];
-}
-static void update_title_texture(struct sway_container *con,
-                struct wlr_texture **texture, struct border_colors *class) {
-        struct sway_output *output = container_get_effective_output(con);
-        if (!output) {
-                return;
-        }
-        if (*texture) {
-                wlr_texture_destroy(*texture);
-                *texture = NULL;
-        }
-        if (!con->formatted_title) {
-                return;
-        }
-        double scale = output->wlr_output->scale;
-        int width = 0;
-        int height = con->title_height * scale;
-        // We must use a non-nil cairo_t for cairo_set_font_options to work.
-        // Therefore, we cannot use cairo_create(NULL).
-        cairo_surface_t *dummy_surface = cairo_image_surface_create(
-                        CAIRO_FORMAT_ARGB32, 0, 0);
-        cairo_t *c = cairo_create(dummy_surface);
-        cairo_set_antialias(c, CAIRO_ANTIALIAS_BEST);
-        cairo_font_options_t *fo = cairo_font_options_create();
-        cairo_font_options_set_hint_style(fo, CAIRO_HINT_STYLE_FULL);
-        if (output->wlr_output->subpixel == WL_OUTPUT_SUBPIXEL_NONE) {
-                cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_GRAY);
-        } else {
-                cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_SUBPIXEL);
-                cairo_font_options_set_subpixel_order(fo,
-                        to_cairo_subpixel_order(output->wlr_output->subpixel));
-        }
-        cairo_set_font_options(c, fo);
-        get_text_size(c, config->font, &width, NULL, NULL, scale,
-                        config->pango_markup, "%s", con->formatted_title);
-        cairo_surface_destroy(dummy_surface);
-        cairo_destroy(c);
-        if (width == 0 || height == 0) {
-                return;
-        }
-        cairo_surface_t *surface = cairo_image_surface_create(
-                        CAIRO_FORMAT_ARGB32, width, height);
-        cairo_t *cairo = cairo_create(surface);
-        cairo_set_antialias(cairo, CAIRO_ANTIALIAS_BEST);
-        cairo_set_font_options(cairo, fo);
-        cairo_font_options_destroy(fo);
-        cairo_set_source_rgba(cairo, class->background[0], class->background[1],
-                        class->background[2], class->background[3]);
-        cairo_paint(cairo);
-        PangoContext *pango = pango_cairo_create_context(cairo);
-        cairo_set_source_rgba(cairo, class->text[0], class->text[1],
-                        class->text[2], class->text[3]);
-        cairo_move_to(cairo, 0, 0);
-        pango_printf(cairo, config->font, scale, config->pango_markup,
-                        "%s", con->formatted_title);
-        cairo_surface_flush(surface);
-        unsigned char *data = cairo_image_surface_get_data(surface);
-        int stride = cairo_image_surface_get_stride(surface);
-        struct wlr_renderer *renderer = wlr_backend_get_renderer(
-                        output->wlr_output->backend);
-        *texture = wlr_texture_from_pixels(
-                        renderer, DRM_FORMAT_ARGB8888, stride, width, height, data);
-        cairo_surface_destroy(surface);
-        g_object_unref(pango);
-        cairo_destroy(cairo);
-}
-void container_update_title_textures(struct sway_container *container) {
-        update_title_texture(container, &container->title_focused,
-                        &config->border_colors.focused);
-        update_title_texture(container, &container->title_focused_inactive,
-                        &config->border_colors.focused_inactive);
-        update_title_texture(container, &container->title_unfocused,
-                        &config->border_colors.unfocused);
-        update_title_texture(container, &container->title_urgent,
-                        &config->border_colors.urgent);
-        container_damage_whole(container);
-}
-void container_calculate_title_height(struct sway_container *container) {
-        if (!container->formatted_title) {
-                container->title_height = 0;
-                return;
-        }
-        cairo_t *cairo = cairo_create(NULL);
-        int height;
-        int baseline;
-        get_text_size(cairo, config->font, NULL, &height, &baseline, 1,
-                        config->pango_markup, "%s", container->formatted_title);
-        cairo_destroy(cairo);
-        container->title_height = height;
-        container->title_baseline = baseline;
-}
 /**
 * Calculate and return the length of the tree representation.
 * An example tree representation is: V[Terminal, Firefox]
@@ -656,8 +710,13 @@ void container_update_representation(struct sway_container *con) {
                }
                container_build_representation(con->pending.layout, con->pending.children,
                                con->formatted_title);
-                container_calculate_title_height(con);
-                container_update_title_textures(con);
+                if (con->title_bar.title_text) {
+                        sway_text_node_set_text(con->title_bar.title_text, con->formatted_title);
+                        container_arrange_title_bar(con);
+                } else {
+                        container_update_title_bar(con);
+                }
        }
        if (con->pending.parent) {
                container_update_representation(con->pending.parent);
@@ -688,12 +747,13 @@ void floating_calculate_constraints(int *min_width, int *max_width,
                *min_height = config->floating_minimum_height;
        }
-        struct wlr_box *box = wlr_output_layout_get_box(root->output_layout, NULL);
+        struct wlr_box box;
+        wlr_output_layout_get_box(root->output_layout, NULL, &box);
        if (config->floating_maximum_width == -1) { // no maximum
                *max_width = INT_MAX;
        } else if (config->floating_maximum_width == 0) { // automatic
-                *max_width = box->width;
+                *max_width = box.width;
        } else {
                *max_width = config->floating_maximum_width;
        }
@@ -701,13 +761,28 @@ void floating_calculate_constraints(int *min_width, int *max_width,
        if (config->floating_maximum_height == -1) { // no maximum
                *max_height = INT_MAX;
        } else if (config->floating_maximum_height == 0) { // automatic
-                *max_height = box->height;
+                *max_height = box.height;
        } else {
                *max_height = config->floating_maximum_height;
        }
 }
+void floating_fix_coordinates(struct sway_container *con, struct wlr_box *old, struct wlr_box *new) {
+        if (!old->width || !old->height) {
+                // Fall back to centering on the workspace.
+                container_floating_move_to_center(con);
+        } else {
+                int rel_x = con->pending.x - old->x + (con->pending.width / 2);
+                int rel_y = con->pending.y - old->y + (con->pending.height / 2);
+                con->pending.x = new->x + (double)(rel_x * new->width) / old->width - (con->pending.width / 2);
+                con->pending.y = new->y + (double)(rel_y * new->height) / old->height - (con->pending.height / 2);
+                sway_log(SWAY_DEBUG, "Transformed container %p to coords (%f, %f)", con, con->pending.x, con->pending.y);
+        }
+}
 static void floating_natural_resize(struct sway_container *con) {
        int min_width, max_width, min_height, max_height;
        floating_calculate_constraints(&min_width, &max_width,
@@ -733,9 +808,9 @@ void container_floating_resize_and_center(struct sway_container *con) {
                return;
        }
-        struct wlr_box *ob = wlr_output_layout_get_box(root->output_layout,
+        struct wlr_box ob;
-                        ws->output->wlr_output);
+        wlr_output_layout_get_box(root->output_layout, ws->output->wlr_output, &ob);
-        if (!ob) {
+        if (wlr_box_empty(&ob)) {
                // On NOOP output. Will be called again when moved to an output
                con->pending.x = 0;
                con->pending.y = 0;
@@ -747,8 +822,8 @@ void container_floating_resize_and_center(struct sway_container *con) {
        floating_natural_resize(con);
        if (!con->view) {
                if (con->pending.width > ws->width || con->pending.height > ws->height) {
-                        con->pending.x = ob->x + (ob->width - con->pending.width) / 2;
+                        con->pending.x = ob.x + (ob.width - con->pending.width) / 2;
-                        con->pending.y = ob->y + (ob->height - con->pending.height) / 2;
+                        con->pending.y = ob.y + (ob.height - con->pending.height) / 2;
                } else {
                        con->pending.x = ws->x + (ws->width - con->pending.width) / 2;
                        con->pending.y = ws->y + (ws->height - con->pending.height) / 2;
@@ -756,8 +831,8 @@ void container_floating_resize_and_center(struct sway_container *con) {
        } else {
                if (con->pending.content_width > ws->width
                                || con->pending.content_height > ws->height) {
-                        con->pending.content_x = ob->x + (ob->width - con->pending.content_width) / 2;
+                        con->pending.content_x = ob.x + (ob.width - con->pending.content_width) / 2;
-                        con->pending.content_y = ob->y + (ob->height - con->pending.content_height) / 2;
+                        con->pending.content_y = ob.y + (ob.height - con->pending.content_height) / 2;
                } else {
                        con->pending.content_x = ws->x + (ws->width - con->pending.content_width) / 2;
                        con->pending.content_y = ws->y + (ws->height - con->pending.content_height) / 2;
@@ -779,11 +854,11 @@ void container_floating_set_default_size(struct sway_container *con) {
        int min_width, max_width, min_height, max_height;
        floating_calculate_constraints(&min_width, &max_width,
                        &min_height, &max_height);
-        struct wlr_box *box = calloc(1, sizeof(struct wlr_box));
+        struct wlr_box box;
-        workspace_get_box(con->pending.workspace, box);
+        workspace_get_box(con->pending.workspace, &box);
-        double width = fmax(min_width, fmin(box->width * 0.5, max_width));
+        double width = fmax(min_width, fmin(box.width * 0.5, max_width));
-        double height = fmax(min_height, fmin(box->height * 0.75, max_height));
+        double height = fmax(min_height, fmin(box.height * 0.75, max_height));
        if (!con->view) {
                con->pending.width = width;
                con->pending.height = height;
@@ -792,8 +867,6 @@ void container_floating_set_default_size(struct sway_container *con) {
                con->pending.content_height = height;
                container_set_geometry_from_content(con);
        }
-        free(box);
 }
@@ -835,7 +908,13 @@ void container_set_floating(struct sway_container *container, bool enable) {
                if (container->view) {
                        view_set_tiled(container->view, false);
                        if (container->view->using_csd) {
+                                container->saved_border = container->pending.border;
                                container->pending.border = B_CSD;
+                                if (container->view->xdg_decoration) {
+                                        struct sway_xdg_decoration *deco = container->view->xdg_decoration;
+                                        wlr_xdg_toplevel_decoration_v1_set_mode(deco->wlr_xdg_decoration,
+                                                        WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE);
+                                }
                        }
                }
                container_floating_set_default_size(container);
@@ -873,6 +952,11 @@ void container_set_floating(struct sway_container *container, bool enable) {
                        view_set_tiled(container->view, true);
                        if (container->view->using_csd) {
                                container->pending.border = container->saved_border;
+                                if (container->view->xdg_decoration) {
+                                        struct sway_xdg_decoration *deco = container->view->xdg_decoration;
+                                        wlr_xdg_toplevel_decoration_v1_set_mode(deco->wlr_xdg_decoration,
+                                                        WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
+                                }
                        }
                }
                container->width_fraction = 0;
@@ -918,17 +1002,6 @@ bool container_is_floating(struct sway_container *container) {
        return false;
 }
-bool container_is_current_floating(struct sway_container *container) {
-        if (!container->current.parent && container->current.workspace &&
-                        list_find(container->current.workspace->floating, container) != -1) {
-                return true;
-        }
-        if (container->scratchpad) {
-                return true;
-        }
-        return false;
-}
 void container_get_box(struct sway_container *container, struct wlr_box *box) {
        box->x = container->pending.x;
        box->y = container->pending.y;
@@ -1012,6 +1085,13 @@ void container_floating_move_to(struct sway_container *con,
                workspace_add_floating(new_workspace, con);
                arrange_workspace(old_workspace);
                arrange_workspace(new_workspace);
+                // If the moved container was a visible scratchpad container, then
+                // update its transform.
+                if (con->scratchpad) {
+                        struct wlr_box output_box;
+                        output_get_box(new_output, &output_box);
+                        con->transform = output_box;
+                }
                workspace_detect_urgent(old_workspace);
                workspace_detect_urgent(new_workspace);
        }
@@ -1223,72 +1303,6 @@ bool container_is_fullscreen_or_child(struct sway_container *container) {
        return false;
 }
-static void surface_send_enter_iterator(struct wlr_surface *surface,
-                int x, int y, void *data) {
-        struct wlr_output *wlr_output = data;
-        wlr_surface_send_enter(surface, wlr_output);
-}
-static void surface_send_leave_iterator(struct wlr_surface *surface,
-                int x, int y, void *data) {
-        struct wlr_output *wlr_output = data;
-        wlr_surface_send_leave(surface, wlr_output);
-}
-void container_discover_outputs(struct sway_container *con) {
-        struct wlr_box con_box = {
-                .x = con->current.x,
-                .y = con->current.y,
-                .width = con->current.width,
-                .height = con->current.height,
-        };
-        struct sway_output *old_output = container_get_effective_output(con);
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                struct wlr_box output_box;
-                output_get_box(output, &output_box);
-                struct wlr_box intersection;
-                bool intersects =
-                        wlr_box_intersection(&intersection, &con_box, &output_box);
-                int index = list_find(con->outputs, output);
-                if (intersects && index == -1) {
-                        // Send enter
-                        sway_log(SWAY_DEBUG, "Container %p entered output %p", con, output);
-                        if (con->view) {
-                                view_for_each_surface(con->view,
-                                                surface_send_enter_iterator, output->wlr_output);
-                                if (con->view->foreign_toplevel) {
-                                        wlr_foreign_toplevel_handle_v1_output_enter(
-                                                        con->view->foreign_toplevel, output->wlr_output);
-                                }
-                        }
-                        list_add(con->outputs, output);
-                } else if (!intersects && index != -1) {
-                        // Send leave
-                        sway_log(SWAY_DEBUG, "Container %p left output %p", con, output);
-                        if (con->view) {
-                                view_for_each_surface(con->view,
-                                        surface_send_leave_iterator, output->wlr_output);
-                                if (con->view->foreign_toplevel) {
-                                        wlr_foreign_toplevel_handle_v1_output_leave(
-                                                        con->view->foreign_toplevel, output->wlr_output);
-                                }
-                        }
-                        list_del(con->outputs, index);
-                }
-        }
-        struct sway_output *new_output = container_get_effective_output(con);
-        double old_scale = old_output && old_output->enabled ?
-                old_output->wlr_output->scale : -1;
-        double new_scale = new_output ? new_output->wlr_output->scale : -1;
-        if (old_scale != new_scale) {
-                container_update_title_textures(con);
-                container_update_marks_textures(con);
-        }
-}
 enum sway_container_layout container_parent_layout(struct sway_container *con) {
        if (con->pending.parent) {
                return con->pending.parent->pending.layout;
@@ -1299,19 +1313,11 @@ enum sway_container_layout container_parent_layout(struct sway_container *con) {
        return L_NONE;
 }
-enum sway_container_layout container_current_parent_layout(
-                struct sway_container *con) {
-        if (con->current.parent) {
-                return con->current.parent->current.layout;
-        }
-        return con->current.workspace->current.layout;
-}
 list_t *container_get_siblings(struct sway_container *container) {
        if (container->pending.parent) {
                return container->pending.parent->pending.children;
        }
-        if (container_is_scratchpad_hidden(container)) {
+        if (!container->pending.workspace) {
                return NULL;
        }
        if (list_find(container->pending.workspace->tiling, container) != -1) {
@@ -1324,13 +1330,6 @@ int container_sibling_index(struct sway_container *child) {
        return list_find(container_get_siblings(child), child);
 }
-list_t *container_get_current_siblings(struct sway_container *container) {
-        if (container->current.parent) {
-                return container->current.parent->current.children;
-        }
-        return container->current.workspace->current.tiling;
-}
 void container_handle_fullscreen_reparent(struct sway_container *con) {
        if (con->pending.fullscreen_mode != FULLSCREEN_WORKSPACE || !con->pending.workspace ||
                        con->pending.workspace->fullscreen == con) {
@@ -1545,7 +1544,7 @@ bool container_find_and_unmark(char *mark) {
                if (strcmp(con_mark, mark) == 0) {
                        free(con_mark);
                        list_del(con->marks, i);
-                        container_update_marks_textures(con);
+                        container_update_marks(con);
                        ipc_event_window(con, "mark");
                        return true;
                }
@@ -1576,103 +1575,15 @@ void container_add_mark(struct sway_container *con, char *mark) {
        ipc_event_window(con, "mark");
 }
-static void update_marks_texture(struct sway_container *con,
-                struct wlr_texture **texture, struct border_colors *class) {
-        struct sway_output *output = container_get_effective_output(con);
-        if (!output) {
-                return;
-        }
-        if (*texture) {
-                wlr_texture_destroy(*texture);
-                *texture = NULL;
-        }
-        if (!con->marks->length) {
-                return;
-        }
-        size_t len = 0;
-        for (int i = 0; i < con->marks->length; ++i) {
-                char *mark = con->marks->items[i];
-                if (mark[0] != '_') {
-                        len += strlen(mark) + 2;
-                }
-        }
-        char *buffer = calloc(len + 1, 1);
-        char *part = malloc(len + 1);
-        if (!sway_assert(buffer && part, "Unable to allocate memory")) {
-                free(buffer);
-                return;
-        }
-        for (int i = 0; i < con->marks->length; ++i) {
-                char *mark = con->marks->items[i];
-                if (mark[0] != '_') {
-                        sprintf(part, "[%s]", mark);
-                        strcat(buffer, part);
-                }
-        }
-        free(part);
-        double scale = output->wlr_output->scale;
-        int width = 0;
-        int height = con->title_height * scale;
-        cairo_t *c = cairo_create(NULL);
-        get_text_size(c, config->font, &width, NULL, NULL, scale, false,
-                        "%s", buffer);
-        cairo_destroy(c);
-        if (width == 0 || height == 0) {
-                return;
-        }
-        cairo_surface_t *surface = cairo_image_surface_create(
-                        CAIRO_FORMAT_ARGB32, width, height);
-        cairo_t *cairo = cairo_create(surface);
-        cairo_set_source_rgba(cairo, class->background[0], class->background[1],
-                        class->background[2], class->background[3]);
-        cairo_paint(cairo);
-        PangoContext *pango = pango_cairo_create_context(cairo);
-        cairo_set_antialias(cairo, CAIRO_ANTIALIAS_BEST);
-        cairo_set_source_rgba(cairo, class->text[0], class->text[1],
-                        class->text[2], class->text[3]);
-        cairo_move_to(cairo, 0, 0);
-        pango_printf(cairo, config->font, scale, false, "%s", buffer);
-        cairo_surface_flush(surface);
-        unsigned char *data = cairo_image_surface_get_data(surface);
-        int stride = cairo_image_surface_get_stride(surface);
-        struct wlr_renderer *renderer = wlr_backend_get_renderer(
-                        output->wlr_output->backend);
-        *texture = wlr_texture_from_pixels(
-                        renderer, DRM_FORMAT_ARGB8888, stride, width, height, data);
-        cairo_surface_destroy(surface);
-        g_object_unref(pango);
-        cairo_destroy(cairo);
-        free(buffer);
-}
-void container_update_marks_textures(struct sway_container *con) {
-        if (!config->show_marks) {
-                return;
-        }
-        update_marks_texture(con, &con->marks_focused,
-                        &config->border_colors.focused);
-        update_marks_texture(con, &con->marks_focused_inactive,
-                        &config->border_colors.focused_inactive);
-        update_marks_texture(con, &con->marks_unfocused,
-                        &config->border_colors.unfocused);
-        update_marks_texture(con, &con->marks_urgent,
-                        &config->border_colors.urgent);
-        container_damage_whole(con);
-}
 void container_raise_floating(struct sway_container *con) {
        // Bring container to front by putting it at the end of the floating list.
        struct sway_container *floater = container_toplevel_ancestor(con);
        if (container_is_floating(floater) && floater->pending.workspace) {
+                // it's okay to just raise the scene directly instead of waiting
+                // for the transaction to go through. We won't be reconfiguring
+                // surfaces
+                wlr_scene_node_raise_to_top(&floater->scene_tree->node);
                list_move_to_end(floater->pending.workspace->floating, floater);
                node_set_dirty(&floater->pending.workspace->node);
        }
@@ -1756,3 +1667,177 @@ int container_squash(struct sway_container *con) {
        }
        return change;
 }
+static void swap_places(struct sway_container *con1,
+                struct sway_container *con2) {
+        struct sway_container *temp = malloc(sizeof(struct sway_container));
+        temp->pending.x = con1->pending.x;
+        temp->pending.y = con1->pending.y;
+        temp->pending.width = con1->pending.width;
+        temp->pending.height = con1->pending.height;
+        temp->width_fraction = con1->width_fraction;
+        temp->height_fraction = con1->height_fraction;
+        temp->pending.parent = con1->pending.parent;
+        temp->pending.workspace = con1->pending.workspace;
+        bool temp_floating = container_is_floating(con1);
+        con1->pending.x = con2->pending.x;
+        con1->pending.y = con2->pending.y;
+        con1->pending.width = con2->pending.width;
+        con1->pending.height = con2->pending.height;
+        con1->width_fraction = con2->width_fraction;
+        con1->height_fraction = con2->height_fraction;
+        con2->pending.x = temp->pending.x;
+        con2->pending.y = temp->pending.y;
+        con2->pending.width = temp->pending.width;
+        con2->pending.height = temp->pending.height;
+        con2->width_fraction = temp->width_fraction;
+        con2->height_fraction = temp->height_fraction;
+        int temp_index = container_sibling_index(con1);
+        if (con2->pending.parent) {
+                container_insert_child(con2->pending.parent, con1,
+                                container_sibling_index(con2));
+        } else if (container_is_floating(con2)) {
+                workspace_add_floating(con2->pending.workspace, con1);
+        } else {
+                workspace_insert_tiling(con2->pending.workspace, con1,
+                                container_sibling_index(con2));
+        }
+        if (temp->pending.parent) {
+                container_insert_child(temp->pending.parent, con2, temp_index);
+        } else if (temp_floating) {
+                workspace_add_floating(temp->pending.workspace, con2);
+        } else {
+                workspace_insert_tiling(temp->pending.workspace, con2, temp_index);
+        }
+        free(temp);
+}
+static void swap_focus(struct sway_container *con1,
+                struct sway_container *con2, struct sway_seat *seat,
+                struct sway_container *focus) {
+        if (focus == con1 || focus == con2) {
+                struct sway_workspace *ws1 = con1->pending.workspace;
+                struct sway_workspace *ws2 = con2->pending.workspace;
+                enum sway_container_layout layout1 = container_parent_layout(con1);
+                enum sway_container_layout layout2 = container_parent_layout(con2);
+                if (focus == con1 && (layout2 == L_TABBED || layout2 == L_STACKED)) {
+                        if (workspace_is_visible(ws2)) {
+                                seat_set_focus(seat, &con2->node);
+                        }
+                        seat_set_focus_container(seat, ws1 != ws2 ? con2 : con1);
+                } else if (focus == con2 && (layout1 == L_TABBED
+                                        || layout1 == L_STACKED)) {
+                        if (workspace_is_visible(ws1)) {
+                                seat_set_focus(seat, &con1->node);
+                        }
+                        seat_set_focus_container(seat, ws1 != ws2 ? con1 : con2);
+                } else if (ws1 != ws2) {
+                        seat_set_focus_container(seat, focus == con1 ? con2 : con1);
+                } else {
+                        seat_set_focus_container(seat, focus);
+                }
+        } else {
+                seat_set_focus_container(seat, focus);
+        }
+        if (root->fullscreen_global) {
+                seat_set_focus(seat,
+                                seat_get_focus_inactive(seat, &root->fullscreen_global->node));
+        }
+}
+void container_swap(struct sway_container *con1, struct sway_container *con2) {
+        if (!sway_assert(con1 && con2, "Cannot swap with nothing")) {
+                return;
+        }
+        if (!sway_assert(!container_has_ancestor(con1, con2)
+                                && !container_has_ancestor(con2, con1),
+                                "Cannot swap ancestor and descendant")) {
+                return;
+        }
+        sway_log(SWAY_DEBUG, "Swapping containers %zu and %zu",
+                        con1->node.id, con2->node.id);
+        bool scratch1 = con1->scratchpad;
+        bool hidden1 = container_is_scratchpad_hidden(con1);
+        bool scratch2 = con2->scratchpad;
+        bool hidden2 = container_is_scratchpad_hidden(con2);
+        if (scratch1) {
+                if (hidden1) {
+                        root_scratchpad_show(con1);
+                }
+                root_scratchpad_remove_container(con1);
+        }
+        if (scratch2) {
+                if (hidden2) {
+                        root_scratchpad_show(con2);
+                }
+                root_scratchpad_remove_container(con2);
+        }
+        enum sway_fullscreen_mode fs1 = con1->pending.fullscreen_mode;
+        if (fs1) {
+                container_fullscreen_disable(con1);
+        }
+        enum sway_fullscreen_mode fs2 = con2->pending.fullscreen_mode;
+        if (fs2) {
+                container_fullscreen_disable(con2);
+        }
+        struct sway_seat *seat = input_manager_current_seat();
+        struct sway_container *focus = seat_get_focused_container(seat);
+        struct sway_workspace *vis1 =
+                output_get_active_workspace(con1->pending.workspace->output);
+        struct sway_workspace *vis2 =
+                output_get_active_workspace(con2->pending.workspace->output);
+        if (!sway_assert(vis1 && vis2, "con1 or con2 are on an output without a"
+                                "workspace. This should not happen")) {
+                return;
+        }
+        char *stored_prev_name = NULL;
+        if (seat->prev_workspace_name) {
+                stored_prev_name = strdup(seat->prev_workspace_name);
+        }
+        swap_places(con1, con2);
+        if (!workspace_is_visible(vis1)) {
+                seat_set_focus(seat, seat_get_focus_inactive(seat, &vis1->node));
+        }
+        if (!workspace_is_visible(vis2)) {
+                seat_set_focus(seat, seat_get_focus_inactive(seat, &vis2->node));
+        }
+        swap_focus(con1, con2, seat, focus);
+        if (stored_prev_name) {
+                free(seat->prev_workspace_name);
+                seat->prev_workspace_name = stored_prev_name;
+        }
+        if (scratch1) {
+                root_scratchpad_add_container(con2, NULL);
+                if (!hidden1) {
+                        root_scratchpad_show(con2);
+                }
+        }
+        if (scratch2) {
+                root_scratchpad_add_container(con1, NULL);
+                if (!hidden2) {
+                        root_scratchpad_show(con1);
+                }
+        }
+        if (fs1) {
+                container_set_fullscreen(con2, fs1);
+        }
+        if (fs2) {
+                container_set_fullscreen(con1, fs2);
+        }
+}
diff --git a/sway/tree/node.c b/sway/tree/node.c
index bc7e2aa5..7aaf9762 100644
--- a/sway/tree/node.c
+++ b/sway/tree/node.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include "sway/output.h"
 #include "sway/server.h"
 #include "sway/tree/container.h"
@@ -18,13 +17,13 @@ void node_init(struct sway_node *node, enum sway_node_type type, void *thing) {
 const char *node_type_to_str(enum sway_node_type type) {
        switch (type) {
        case N_ROOT:
-                return "N_ROOT";
+                return "root";
        case N_OUTPUT:
-                return "N_OUTPUT";
+                return "output";
        case N_WORKSPACE:
-                return "N_WORKSPACE";
+                return "workspace";
        case N_CONTAINER:
-                return "N_CONTAINER";
+                return "container";
        }
        return "";
 }
@@ -159,3 +158,32 @@ bool node_has_ancestor(struct sway_node *node, struct sway_node *ancestor) {
        }
        return false;
 }
+void scene_node_disown_children(struct wlr_scene_tree *tree) {
+        // this function can be called as part of destruction code that will be invoked
+        // upon an allocation failure. Let's not crash on NULL due to an allocation error.
+        if (!tree) {
+                return;
+        }
+        struct wlr_scene_node *child, *tmp_child;
+        wl_list_for_each_safe(child, tmp_child, &tree->children, link) {
+                wlr_scene_node_reparent(child, root->staging);
+        }
+}
+struct wlr_scene_tree *alloc_scene_tree(struct wlr_scene_tree *parent,
+                bool *failed) {
+        // fallthrough
+        if (*failed) {
+                return NULL;
+        }
+        struct wlr_scene_tree *tree = wlr_scene_tree_create(parent);
+        if (!tree) {
+                sway_log(SWAY_ERROR, "Failed to allocate a scene node");
+                *failed = true;
+        }
+        return tree;
+}
diff --git a/sway/tree/output.c b/sway/tree/output.c
index c095dce0..2d11195e 100644
--- a/sway/tree/output.c
+++ b/sway/tree/output.c
@@ -1,14 +1,13 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <ctype.h>
 #include <string.h>
 #include <strings.h>
-#include <wlr/types/wlr_output_damage.h>
 #include "sway/ipc-server.h"
 #include "sway/layers.h"
 #include "sway/output.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/workspace.h"
+#include "sway/server.h"
 #include "log.h"
 #include "util.h"
@@ -56,8 +55,8 @@ static void restore_workspaces(struct sway_output *output) {
        }
        // Saved workspaces
-        while (root->noop_output->workspaces->length) {
+        while (root->fallback_output->workspaces->length) {
-                struct sway_workspace *ws = root->noop_output->workspaces->items[0];
+                struct sway_workspace *ws = root->fallback_output->workspaces->items[0];
                workspace_detach(ws);
                output_add_workspace(output, ws);
@@ -87,26 +86,63 @@ static void restore_workspaces(struct sway_output *output) {
        output_sort_workspaces(output);
 }
+static void destroy_scene_layers(struct sway_output *output) {
+        wlr_scene_node_destroy(&output->fullscreen_background->node);
+        scene_node_disown_children(output->layers.tiling);
+        scene_node_disown_children(output->layers.fullscreen);
+        wlr_scene_node_destroy(&output->layers.shell_background->node);
+        wlr_scene_node_destroy(&output->layers.shell_bottom->node);
+        wlr_scene_node_destroy(&output->layers.tiling->node);
+        wlr_scene_node_destroy(&output->layers.fullscreen->node);
+        wlr_scene_node_destroy(&output->layers.shell_top->node);
+        wlr_scene_node_destroy(&output->layers.shell_overlay->node);
+        wlr_scene_node_destroy(&output->layers.session_lock->node);
+}
 struct sway_output *output_create(struct wlr_output *wlr_output) {
        struct sway_output *output = calloc(1, sizeof(struct sway_output));
        node_init(&output->node, N_OUTPUT, output);
+        bool failed = false;
+        output->layers.shell_background = alloc_scene_tree(root->staging, &failed);
+        output->layers.shell_bottom = alloc_scene_tree(root->staging, &failed);
+        output->layers.tiling = alloc_scene_tree(root->staging, &failed);
+        output->layers.fullscreen = alloc_scene_tree(root->staging, &failed);
+        output->layers.shell_top = alloc_scene_tree(root->staging, &failed);
+        output->layers.shell_overlay = alloc_scene_tree(root->staging, &failed);
+        output->layers.session_lock = alloc_scene_tree(root->staging, &failed);
+        if (!failed) {
+                output->fullscreen_background = wlr_scene_rect_create(
+                        output->layers.fullscreen, 0, 0, (float[4]){0.f, 0.f, 0.f, 1.f});
+                if (!output->fullscreen_background) {
+                        sway_log(SWAY_ERROR, "Unable to allocate a background rect");
+                        failed = true;
+                }
+        }
+        if (failed) {
+                destroy_scene_layers(output);
+                wlr_scene_output_destroy(output->scene_output);
+                free(output);
+                return NULL;
+        }
        output->wlr_output = wlr_output;
        wlr_output->data = output;
        output->detected_subpixel = wlr_output->subpixel;
        output->scale_filter = SCALE_FILTER_NEAREST;
-        wl_signal_init(&output->events.destroy);
+        wl_signal_init(&output->events.disable);
        wl_list_insert(&root->all_outputs, &output->link);
        output->workspaces = create_list();
        output->current.workspaces = create_list();
-        size_t len = sizeof(output->layers) / sizeof(output->layers[0]);
-        for (size_t i = 0; i < len; ++i) {
-                wl_list_init(&output->layers[i]);
-        }
        return output;
 }
@@ -146,7 +182,7 @@ void output_enable(struct sway_output *output) {
        input_manager_configure_xcursor();
-        wl_signal_emit(&root->events.new_node, &output->node);
+        wl_signal_emit_mutable(&root->events.new_node, &output->node);
        arrange_layers(output);
        arrange_root();
@@ -192,7 +228,7 @@ static void output_evacuate(struct sway_output *output) {
                        new_output = fallback_output;
                }
                if (!new_output) {
-                        new_output = root->noop_output;
+                        new_output = root->fallback_output;
                }
                struct sway_workspace *new_output_ws =
@@ -238,20 +274,14 @@ void output_destroy(struct sway_output *output) {
                                "which is still referenced by transactions")) {
                return;
        }
+        destroy_scene_layers(output);
        list_free(output->workspaces);
        list_free(output->current.workspaces);
        wl_event_source_remove(output->repaint_timer);
        free(output);
 }
-static void untrack_output(struct sway_container *con, void *data) {
-        struct sway_output *output = data;
-        int index = list_find(con->outputs, output);
-        if (index != -1) {
-                list_del(con->outputs, index);
-        }
-}
 void output_disable(struct sway_output *output) {
        if (!sway_assert(output->enabled, "Expected an enabled output")) {
                return;
@@ -262,23 +292,20 @@ void output_disable(struct sway_output *output) {
        }
        sway_log(SWAY_DEBUG, "Disabling output '%s'", output->wlr_output->name);
-        wl_signal_emit(&output->events.destroy, output);
+        wl_signal_emit_mutable(&output->events.disable, output);
        output_evacuate(output);
-        root_for_each_container(untrack_output, output);
        list_del(root->outputs, index);
        output->enabled = false;
-        output->current_mode = NULL;
        arrange_root();
        // Reconfigure all devices, since devices with map_to_output directives for
        // an output that goes offline should stop sending events as long as the
        // output remains offline.
-        input_manager_configure_all_inputs();
+        input_manager_configure_all_input_mappings();
 }
 void output_begin_destroy(struct sway_output *output) {
@@ -286,13 +313,10 @@ void output_begin_destroy(struct sway_output *output) {
                return;
        }
        sway_log(SWAY_DEBUG, "Destroying output '%s'", output->wlr_output->name);
+        wl_signal_emit_mutable(&output->node.events.destroy, &output->node);
        output->node.destroying = true;
        node_set_dirty(&output->node);
-        wl_list_remove(&output->link);
-        output->wlr_output->data = NULL;
-        output->wlr_output = NULL;
 }
 struct sway_output *output_from_wlr_output(struct wlr_output *output) {
@@ -304,10 +328,10 @@ struct sway_output *output_get_in_direction(struct sway_output *reference,
        if (!sway_assert(direction, "got invalid direction: %d", direction)) {
                return NULL;
        }
-        struct wlr_box *output_box =
+        struct wlr_box output_box;
-                wlr_output_layout_get_box(root->output_layout, reference->wlr_output);
+        wlr_output_layout_get_box(root->output_layout, reference->wlr_output, &output_box);
-        int lx = output_box->x + output_box->width / 2;
+        int lx = output_box.x + output_box.width / 2;
-        int ly = output_box->y + output_box->height / 2;
+        int ly = output_box.y + output_box.height / 2;
        struct wlr_output *wlr_adjacent = wlr_output_layout_adjacent_output(
                        root->output_layout, direction, reference->wlr_output, lx, ly);
        if (!wlr_adjacent) {
@@ -393,6 +417,33 @@ void output_get_box(struct sway_output *output, struct wlr_box *box) {
        box->height = output->height;
 }
+static void handle_destroy_non_desktop(struct wl_listener *listener, void *data) {
+        struct sway_output_non_desktop *output =
+                wl_container_of(listener, output, destroy);
+        sway_log(SWAY_DEBUG, "Destroying non-desktop output '%s'", output->wlr_output->name);
+        int index = list_find(root->non_desktop_outputs, output);
+        list_del(root->non_desktop_outputs, index);
+        wl_list_remove(&output->destroy.link);
+        free(output);
+}
+struct sway_output_non_desktop *output_non_desktop_create(
+                struct wlr_output *wlr_output) {
+        struct sway_output_non_desktop *output =
+                calloc(1, sizeof(struct sway_output_non_desktop));
+        output->wlr_output = wlr_output;
+        wl_signal_add(&wlr_output->events.destroy, &output->destroy);
+        output->destroy.notify = handle_destroy_non_desktop;
+        return output;
+}
 enum sway_container_layout output_get_default_layout(
                struct sway_output *output) {
        if (config->default_orientation != L_NONE) {
diff --git a/sway/tree/root.c b/sway/tree/root.c
index dd4d8e33..20fcfa59 100644
--- a/sway/tree/root.c
+++ b/sway/tree/root.c
@@ -1,12 +1,14 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_scene.h>
+#include <wlr/util/transform.h>
 #include "sway/desktop/transaction.h"
 #include "sway/input/seat.h"
 #include "sway/ipc-server.h"
 #include "sway/output.h"
+#include "sway/scene_descriptor.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/container.h"
 #include "sway/tree/root.h"
@@ -23,21 +25,60 @@ static void output_layout_handle_change(struct wl_listener *listener,
        transaction_commit_dirty();
 }
-struct sway_root *root_create(void) {
+struct sway_root *root_create(struct wl_display *wl_display) {
        struct sway_root *root = calloc(1, sizeof(struct sway_root));
        if (!root) {
                sway_log(SWAY_ERROR, "Unable to allocate sway_root");
                return NULL;
        }
+        struct wlr_scene *root_scene = wlr_scene_create();
+        if (!root_scene) {
+                sway_log(SWAY_ERROR, "Unable to allocate root scene node");
+                free(root);
+                return NULL;
+        }
        node_init(&root->node, N_ROOT, root);
-        root->output_layout = wlr_output_layout_create();
+        root->root_scene = root_scene;
-        wl_list_init(&root->all_outputs);
-#if HAVE_XWAYLAND
+        bool failed = false;
-        wl_list_init(&root->xwayland_unmanaged);
+        root->staging = alloc_scene_tree(&root_scene->tree, &failed);
+        root->layer_tree = alloc_scene_tree(&root_scene->tree, &failed);
+        root->layers.shell_background = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.shell_bottom = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.tiling = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.floating = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.shell_top = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.fullscreen = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.fullscreen_global = alloc_scene_tree(root->layer_tree, &failed);
+#if WLR_HAS_XWAYLAND
+        root->layers.unmanaged = alloc_scene_tree(root->layer_tree, &failed);
 #endif
-        wl_list_init(&root->drag_icons);
+        root->layers.shell_overlay = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.popup = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.seat = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.session_lock = alloc_scene_tree(root->layer_tree, &failed);
+        if (!failed && !scene_descriptor_assign(&root->layers.seat->node,
+                        SWAY_SCENE_DESC_NON_INTERACTIVE, (void *)1)) {
+                failed = true;
+        }
+        if (failed) {
+                wlr_scene_node_destroy(&root_scene->tree.node);
+                free(root);
+                return NULL;
+        }
+        wlr_scene_node_set_enabled(&root->staging->node, false);
+        root->output_layout = wlr_output_layout_create(wl_display);
+        wl_list_init(&root->all_outputs);
        wl_signal_init(&root->events.new_node);
        root->outputs = create_list();
+        root->non_desktop_outputs = create_list();
        root->scratchpad = create_list();
        root->output_layout_change.notify = output_layout_handle_change;
@@ -49,11 +90,22 @@ struct sway_root *root_create(void) {
 void root_destroy(struct sway_root *root) {
        wl_list_remove(&root->output_layout_change.link);
        list_free(root->scratchpad);
+        list_free(root->non_desktop_outputs);
        list_free(root->outputs);
-        wlr_output_layout_destroy(root->output_layout);
+        wlr_scene_node_destroy(&root->root_scene->tree.node);
        free(root);
 }
+static void set_container_transform(struct sway_workspace *ws,
+                        struct sway_container *con) {
+        struct sway_output *output = ws->output;
+        struct wlr_box box = {0};
+        if (output) {
+                output_get_box(output, &box);
+        }
+        con->transform = box;
+}
 void root_scratchpad_add_container(struct sway_container *con, struct sway_workspace *ws) {
        if (!sway_assert(!con->scratchpad, "Container is already in scratchpad")) {
                return;
@@ -62,6 +114,8 @@ void root_scratchpad_add_container(struct sway_container *con, struct sway_works
        struct sway_container *parent = con->pending.parent;
        struct sway_workspace *workspace = con->pending.workspace;
+        set_container_transform(workspace, con);
        // Clear the fullscreen mode when sending to the scratchpad
        if (con->pending.fullscreen_mode != FULLSCREEN_NONE) {
                container_fullscreen_disable(con);
@@ -131,7 +185,10 @@ void root_scratchpad_show(struct sway_container *con) {
        // Show the container
        if (old_ws) {
                container_detach(con);
-                workspace_consider_destroy(old_ws);
+                // Make sure the last inactive container on the old workspace is above
+                // the workspace itself in the focus stack.
+                struct sway_node *node = seat_get_focus_inactive(seat, &old_ws->node);
+                seat_set_raw_focus(seat, node);
        } else {
                // Act on the ancestor of scratchpad hidden split containers
                while (con->pending.parent) {
@@ -140,18 +197,18 @@ void root_scratchpad_show(struct sway_container *con) {
        }
        workspace_add_floating(new_ws, con);
-        // Make sure the container's center point overlaps this workspace
+        if (new_ws->output) {
-        double center_lx = con->pending.x + con->pending.width / 2;
+                struct wlr_box output_box;
-        double center_ly = con->pending.y + con->pending.height / 2;
+                output_get_box(new_ws->output, &output_box);
+                floating_fix_coordinates(con, &con->transform, &output_box);
-        struct wlr_box workspace_box;
-        workspace_get_box(new_ws, &workspace_box);
-        if (!wlr_box_contains_point(&workspace_box, center_lx, center_ly)) {
-                container_floating_resize_and_center(con);
        }
+        set_container_transform(new_ws, con);
        arrange_workspace(new_ws);
        seat_set_focus(seat, seat_get_focus_inactive(seat, &con->node));
+        if (old_ws) {
+                workspace_consider_destroy(old_ws);
+        }
 }
 static void disable_fullscreen(struct sway_container *con, void *data) {
@@ -171,6 +228,8 @@ void root_scratchpad_hide(struct sway_container *con) {
                return;
        }
+        set_container_transform(con->pending.workspace, con);
        disable_fullscreen(con, NULL);
        container_for_each_child(con, disable_fullscreen, NULL);
        container_detach(con);
@@ -183,172 +242,6 @@ void root_scratchpad_hide(struct sway_container *con) {
        ipc_event_window(con, "move");
 }
-struct pid_workspace {
-        pid_t pid;
-        char *workspace;
-        struct timespec time_added;
-        struct sway_output *output;
-        struct wl_listener output_destroy;
-        struct wl_list link;
-};
-static struct wl_list pid_workspaces;
-/**
- * Get the pid of a parent process given the pid of a child process.
- *
- * Returns the parent pid or NULL if the parent pid cannot be determined.
- */
-static pid_t get_parent_pid(pid_t child) {
-        pid_t parent = -1;
-        char file_name[100];
-        char *buffer = NULL;
-        const char *sep = " ";
-        FILE *stat = NULL;
-        size_t buf_size = 0;
-        sprintf(file_name, "/proc/%d/stat", child);
-        if ((stat = fopen(file_name, "r"))) {
-                if (getline(&buffer, &buf_size, stat) != -1) {
-                        strtok(buffer, sep); // pid
-                        strtok(NULL, sep);   // executable name
-                        strtok(NULL, sep);   // state
-                        char *token = strtok(NULL, sep);   // parent pid
-                        parent = strtol(token, NULL, 10);
-                }
-                free(buffer);
-                fclose(stat);
-        }
-        if (parent) {
-                return (parent == child) ? -1 : parent;
-        }
-        return -1;
-}
-static void pid_workspace_destroy(struct pid_workspace *pw) {
-        wl_list_remove(&pw->output_destroy.link);
-        wl_list_remove(&pw->link);
-        free(pw->workspace);
-        free(pw);
-}
-struct sway_workspace *root_workspace_for_pid(pid_t pid) {
-        if (!pid_workspaces.prev && !pid_workspaces.next) {
-                wl_list_init(&pid_workspaces);
-                return NULL;
-        }
-        struct sway_workspace *ws = NULL;
-        struct pid_workspace *pw = NULL;
-        sway_log(SWAY_DEBUG, "Looking up workspace for pid %d", pid);
-        do {
-                struct pid_workspace *_pw = NULL;
-                wl_list_for_each(_pw, &pid_workspaces, link) {
-                        if (pid == _pw->pid) {
-                                pw = _pw;
-                                sway_log(SWAY_DEBUG,
-                                                "found pid_workspace for pid %d, workspace %s",
-                                                pid, pw->workspace);
-                                goto found;
-                        }
-                }
-                pid = get_parent_pid(pid);
-        } while (pid > 1);
-found:
-        if (pw && pw->workspace) {
-                ws = workspace_by_name(pw->workspace);
-                if (!ws) {
-                        sway_log(SWAY_DEBUG,
-                                        "Creating workspace %s for pid %d because it disappeared",
-                                        pw->workspace, pid);
-                        struct sway_output *output = pw->output;
-                        if (pw->output && !pw->output->enabled) {
-                                sway_log(SWAY_DEBUG,
-                                                "Workspace output %s is disabled, trying another one",
-                                                pw->output->wlr_output->name);
-                                output = NULL;
-                        }
-                        ws = workspace_create(output, pw->workspace);
-                }
-                pid_workspace_destroy(pw);
-        }
-        return ws;
-}
-static void pw_handle_output_destroy(struct wl_listener *listener, void *data) {
-        struct pid_workspace *pw = wl_container_of(listener, pw, output_destroy);
-        pw->output = NULL;
-        wl_list_remove(&pw->output_destroy.link);
-        wl_list_init(&pw->output_destroy.link);
-}
-void root_record_workspace_pid(pid_t pid) {
-        sway_log(SWAY_DEBUG, "Recording workspace for process %d", pid);
-        if (!pid_workspaces.prev && !pid_workspaces.next) {
-                wl_list_init(&pid_workspaces);
-        }
-        struct sway_seat *seat = input_manager_current_seat();
-        struct sway_workspace *ws = seat_get_focused_workspace(seat);
-        if (!ws) {
-                sway_log(SWAY_DEBUG, "Bailing out, no workspace");
-                return;
-        }
-        struct sway_output *output = ws->output;
-        if (!output) {
-                sway_log(SWAY_DEBUG, "Bailing out, no output");
-                return;
-        }
-        struct timespec now;
-        clock_gettime(CLOCK_MONOTONIC, &now);
-        // Remove expired entries
-        static const int timeout = 60;
-        struct pid_workspace *old, *_old;
-        wl_list_for_each_safe(old, _old, &pid_workspaces, link) {
-                if (now.tv_sec - old->time_added.tv_sec >= timeout) {
-                        pid_workspace_destroy(old);
-                }
-        }
-        struct pid_workspace *pw = calloc(1, sizeof(struct pid_workspace));
-        pw->workspace = strdup(ws->name);
-        pw->output = output;
-        pw->pid = pid;
-        memcpy(&pw->time_added, &now, sizeof(struct timespec));
-        pw->output_destroy.notify = pw_handle_output_destroy;
-        wl_signal_add(&output->wlr_output->events.destroy, &pw->output_destroy);
-        wl_list_insert(&pid_workspaces, &pw->link);
-}
-void root_remove_workspace_pid(pid_t pid) {
-        if (!pid_workspaces.prev || !pid_workspaces.next) {
-                return;
-        }
-        struct pid_workspace *pw, *tmp;
-        wl_list_for_each_safe(pw, tmp, &pid_workspaces, link) {
-                if (pid == pw->pid) {
-                        pid_workspace_destroy(pw);
-                        return;
-                }
-        }
-}
 void root_for_each_workspace(void (*f)(struct sway_workspace *ws, void *data),
                void *data) {
        for (int i = 0; i < root->outputs->length; ++i) {
@@ -374,8 +267,8 @@ void root_for_each_container(void (*f)(struct sway_container *con, void *data),
        }
        // Saved workspaces
-        for (int i = 0; i < root->noop_output->workspaces->length; ++i) {
+        for (int i = 0; i < root->fallback_output->workspaces->length; ++i) {
-                struct sway_workspace *ws = root->noop_output->workspaces->items[i];
+                struct sway_workspace *ws = root->fallback_output->workspaces->items[i];
                workspace_for_each_container(ws, f, data);
        }
 }
@@ -427,8 +320,8 @@ struct sway_container *root_find_container(
        }
        // Saved workspaces
-        for (int i = 0; i < root->noop_output->workspaces->length; ++i) {
+        for (int i = 0; i < root->fallback_output->workspaces->length; ++i) {
-                struct sway_workspace *ws = root->noop_output->workspaces->items[i];
+                struct sway_workspace *ws = root->fallback_output->workspaces->items[i];
                if ((result = workspace_find_container(ws, test, data))) {
                        return result;
                }
@@ -443,17 +336,3 @@ void root_get_box(struct sway_root *root, struct wlr_box *box) {
        box->width = root->width;
        box->height = root->height;
 }
-void root_rename_pid_workspaces(const char *old_name, const char *new_name) {
-        if (!pid_workspaces.prev && !pid_workspaces.next) {
-                wl_list_init(&pid_workspaces);
-        }
-        struct pid_workspace *pw = NULL;
-        wl_list_for_each(pw, &pid_workspaces, link) {
-                if (strcmp(pw->workspace, old_name) == 0) {
-                        free(pw->workspace);
-                        pw->workspace = strdup(new_name);
-                }
-        }
-}
diff --git a/sway/tree/view.c b/sway/tree/view.c
index fcdd06f7..1c1c8ee8 100644
--- a/sway/tree/view.c
+++ b/sway/tree/view.c
@@ -1,28 +1,32 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdlib.h>
 #include <strings.h>
 #include <wayland-server-core.h>
+#include <wlr/config.h>
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_buffer.h>
+#include <wlr/types/wlr_ext_foreign_toplevel_list_v1.h>
+#include <wlr/types/wlr_foreign_toplevel_management_v1.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_server_decoration.h>
+#include <wlr/types/wlr_subcompositor.h>
 #include <wlr/types/wlr_xdg_decoration_v1.h>
-#include "config.h"
+#if WLR_HAS_XWAYLAND
-#if HAVE_XWAYLAND
 #include <wlr/xwayland.h>
 #endif
 #include "list.h"
 #include "log.h"
 #include "sway/criteria.h"
 #include "sway/commands.h"
-#include "sway/desktop.h"
 #include "sway/desktop/transaction.h"
 #include "sway/desktop/idle_inhibit_v1.h"
+#include "sway/desktop/launcher.h"
 #include "sway/input/cursor.h"
 #include "sway/ipc-server.h"
 #include "sway/output.h"
 #include "sway/input/seat.h"
+#include "sway/scene_descriptor.h"
 #include "sway/server.h"
+#include "sway/sway_text_node.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/container.h"
 #include "sway/tree/view.h"
@@ -32,15 +36,29 @@
 #include "pango.h"
 #include "stringop.h"
-void view_init(struct sway_view *view, enum sway_view_type type,
+bool view_init(struct sway_view *view, enum sway_view_type type,
                const struct sway_view_impl *impl) {
+        bool failed = false;
+        view->scene_tree = alloc_scene_tree(root->staging, &failed);
+        view->content_tree = alloc_scene_tree(view->scene_tree, &failed);
+        if (!failed && !scene_descriptor_assign(&view->scene_tree->node,
+                        SWAY_SCENE_DESC_VIEW, view)) {
+                failed = true;
+        }
+        if (failed) {
+                wlr_scene_node_destroy(&view->scene_tree->node);
+                return false;
+        }
        view->type = type;
        view->impl = impl;
        view->executed_criteria = create_list();
-        wl_list_init(&view->saved_buffers);
        view->allow_request_urgent = true;
        view->shortcuts_inhibit = SHORTCUTS_INHIBIT_DEFAULT;
        wl_signal_init(&view->events.unmap);
+        return true;
 }
 void view_destroy(struct sway_view *view) {
@@ -57,11 +75,10 @@ void view_destroy(struct sway_view *view) {
                return;
        }
        wl_list_remove(&view->events.unmap.listener_list);
-        if (!wl_list_empty(&view->saved_buffers)) {
-                view_remove_saved_buffer(view);
-        }
        list_free(view->executed_criteria);
+        view_assign_ctx(view, NULL);
+        wlr_scene_node_destroy(&view->scene_tree->node);
        free(view->title_format);
        if (view->impl->destroy) {
@@ -109,7 +126,7 @@ const char *view_get_instance(struct sway_view *view) {
        }
        return NULL;
 }
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
 uint32_t view_get_x11_window_id(struct sway_view *view) {
        if (view->impl->get_int_prop) {
                return view->impl->get_int_prop(view, VIEW_PROP_X11_WINDOW_ID);
@@ -142,7 +159,7 @@ const char *view_get_shell(struct sway_view *view) {
        switch(view->type) {
        case SWAY_VIEW_XDG_SHELL:
                return "xdg_shell";
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        case SWAY_VIEW_XWAYLAND:
                return "xwayland";
 #endif
@@ -362,17 +379,17 @@ void view_set_activated(struct sway_view *view, bool activated) {
        }
 }
-void view_request_activate(struct sway_view *view) {
+void view_request_activate(struct sway_view *view, struct sway_seat *seat) {
        struct sway_workspace *ws = view->container->pending.workspace;
-        if (!ws) { // hidden scratchpad container
+        if (!seat) {
-                return;
+                seat = input_manager_current_seat();
        }
-        struct sway_seat *seat = input_manager_current_seat();
        switch (config->focus_on_window_activation) {
        case FOWA_SMART:
-                if (workspace_is_visible(ws)) {
+                if (ws && workspace_is_visible(ws)) {
                        seat_set_focus_container(seat, view->container);
+                        container_raise_floating(view->container);
                } else {
                        view_set_urgent(view, true);
                }
@@ -381,11 +398,23 @@ void view_request_activate(struct sway_view *view) {
                view_set_urgent(view, true);
                break;
        case FOWA_FOCUS:
-                seat_set_focus_container(seat, view->container);
+                if (container_is_scratchpad_hidden_or_child(view->container)) {
+                        root_scratchpad_show(view->container);
+                } else {
+                        seat_set_focus_container(seat, view->container);
+                        container_raise_floating(view->container);
+                }
                break;
        case FOWA_NONE:
                break;
        }
+        transaction_commit_dirty();
+}
+void view_request_urgent(struct sway_view *view) {
+        if (config->focus_on_window_activation != FOWA_NONE) {
+                view_set_urgent(view, true);
+        }
 }
 void view_set_csd_from_server(struct sway_view *view, bool enabled) {
@@ -432,52 +461,6 @@ void view_close_popups(struct sway_view *view) {
        }
 }
-void view_damage_from(struct sway_view *view) {
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                output_damage_from_view(output, view);
-        }
-}
-void view_for_each_surface(struct sway_view *view,
-                wlr_surface_iterator_func_t iterator, void *user_data) {
-        if (!view->surface) {
-                return;
-        }
-        if (view->impl->for_each_surface) {
-                view->impl->for_each_surface(view, iterator, user_data);
-        } else {
-                wlr_surface_for_each_surface(view->surface, iterator, user_data);
-        }
-}
-void view_for_each_popup_surface(struct sway_view *view,
-                wlr_surface_iterator_func_t iterator, void *user_data) {
-        if (!view->surface) {
-                return;
-        }
-        if (view->impl->for_each_popup_surface) {
-                view->impl->for_each_popup_surface(view, iterator, user_data);
-        }
-}
-static void view_subsurface_create(struct sway_view *view,
-        struct wlr_subsurface *subsurface);
-static void view_init_subsurfaces(struct sway_view *view,
-        struct wlr_surface *surface);
-static void view_child_init_subsurfaces(struct sway_view_child *view_child,
-        struct wlr_surface *surface);
-static void view_handle_surface_new_subsurface(struct wl_listener *listener,
-                void *data) {
-        struct sway_view *view =
-                wl_container_of(listener, view, surface_new_subsurface);
-        struct wlr_subsurface *subsurface = data;
-        view_subsurface_create(view, subsurface);
-}
 static bool view_has_executed_criteria(struct sway_view *view,
                struct criteria *criteria) {
        for (int i = 0; i < view->executed_criteria->length; ++i) {
@@ -516,10 +499,10 @@ void view_execute_criteria(struct sway_view *view) {
 static void view_populate_pid(struct sway_view *view) {
        pid_t pid;
        switch (view->type) {
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
        case SWAY_VIEW_XWAYLAND:;
                struct wlr_xwayland_surface *surf =
-                        wlr_xwayland_surface_from_wlr_surface(view->surface);
+                        wlr_xwayland_surface_try_from_wlr_surface(view->surface);
                pid = surf->pid;
                break;
 #endif
@@ -532,6 +515,20 @@ static void view_populate_pid(struct sway_view *view) {
        view->pid = pid;
 }
+void view_assign_ctx(struct sway_view *view, struct launcher_ctx *ctx) {
+        if (view->ctx) {
+                // This ctx has been replaced
+                launcher_ctx_destroy(view->ctx);
+                view->ctx = NULL;
+        }
+        if (ctx == NULL) {
+                return;
+        }
+        launcher_ctx_consume(ctx);
+        view->ctx = ctx;
+}
 static struct sway_workspace *select_workspace(struct sway_view *view) {
        struct sway_seat *seat = input_manager_current_seat();
@@ -567,13 +564,14 @@ static struct sway_workspace *select_workspace(struct sway_view *view) {
        }
        list_free(criterias);
        if (ws) {
-                root_remove_workspace_pid(view->pid);
+                view_assign_ctx(view, NULL);
                return ws;
        }
        // Check if there's a PID mapping
-        ws = root_workspace_for_pid(view->pid);
+        ws = view->ctx ? launcher_ctx_get_workspace(view->ctx) : NULL;
        if (ws) {
+                view_assign_ctx(view, NULL);
                return ws;
        }
@@ -591,6 +589,14 @@ static struct sway_workspace *select_workspace(struct sway_view *view) {
        return NULL;
 }
+static void update_ext_foreign_toplevel(struct sway_view *view) {
+        struct wlr_ext_foreign_toplevel_handle_v1_state toplevel_state = {
+                .app_id = view_get_app_id(view),
+                .title = view_get_title(view),
+        };
+        wlr_ext_foreign_toplevel_handle_v1_update_state(view->ext_foreign_toplevel, &toplevel_state);
+}
 static bool should_focus(struct sway_view *view) {
        struct sway_seat *seat = input_manager_current_seat();
        struct sway_container *prev_con = seat_get_focused_container(seat);
@@ -716,6 +722,13 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
        view_populate_pid(view);
        view->container = container_create(view);
+        if (view->ctx == NULL) {
+                struct launcher_ctx *ctx = launcher_ctx_find_pid(view->pid);
+                if (ctx != NULL) {
+                        view_assign_ctx(view, ctx);
+                }
+        }
        // If there is a request to be opened fullscreen on a specific output, try
        // to honor that request. Otherwise, fallback to assigns, pid mappings,
        // focused workspace, etc
@@ -729,10 +742,36 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
        }
        struct sway_seat *seat = input_manager_current_seat();
-        struct sway_node *node = ws ? seat_get_focus_inactive(seat, &ws->node)
+        struct sway_node *node =
-                : seat_get_focus_inactive(seat, &root->node);
+                seat_get_focus_inactive(seat, ws ? &ws->node : &root->node);
-        struct sway_container *target_sibling = node->type == N_CONTAINER ?
+        struct sway_container *target_sibling = NULL;
-                node->sway_container : NULL;
+        if (node && node->type == N_CONTAINER) {
+                if (container_is_floating(node->sway_container)) {
+                        // If we're about to launch the view into the floating container, then
+                        // launch it as a tiled view instead.
+                        if (ws) {
+                                target_sibling = seat_get_focus_inactive_tiling(seat, ws);
+                                if (target_sibling) {
+                                        struct sway_container *con =
+                                                seat_get_focus_inactive_view(seat, &target_sibling->node);
+                                        if (con)  {
+                                                target_sibling = con;
+                                        }
+                                }
+                        } else {
+                                ws = seat_get_last_known_workspace(seat);
+                        }
+                } else {
+                        target_sibling = node->sway_container;
+                }
+        }
+        struct wlr_ext_foreign_toplevel_handle_v1_state foreign_toplevel_state = {
+                .app_id = view_get_app_id(view),
+                .title = view_get_title(view),
+        };
+        view->ext_foreign_toplevel =
+                wlr_ext_foreign_toplevel_handle_v1_create(server.foreign_toplevel_list, &foreign_toplevel_state);
        view->foreign_toplevel =
                wlr_foreign_toplevel_handle_v1_create(server.foreign_toplevel_manager);
@@ -749,13 +788,6 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
        wl_signal_add(&view->foreign_toplevel->events.destroy,
                        &view->foreign_destroy);
-        // If we're about to launch the view into the floating container, then
-        // launch it as a tiled view in the root of the workspace instead.
-        if (target_sibling && container_is_floating(target_sibling)) {
-                target_sibling = NULL;
-                ws = seat_get_last_known_workspace(seat);
-        }
        struct sway_container *container = view->container;
        if (target_sibling) {
                container_add_sibling(target_sibling, container, 1);
@@ -764,11 +796,6 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
        }
        ipc_event_window(view->container, "new");
-        view_init_subsurfaces(view, wlr_surface);
-        wl_signal_add(&wlr_surface->events.new_subsurface,
-                        &view->surface_new_subsurface);
-        view->surface_new_subsurface.notify = view_handle_surface_new_subsurface;
        if (decoration) {
                view_update_csd_from_client(view, decoration);
        }
@@ -811,10 +838,9 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
        bool set_focus = should_focus(view);
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
-        if (wlr_surface_is_xwayland_surface(wlr_surface)) {
+        struct wlr_xwayland_surface *xsurface;
-                struct wlr_xwayland_surface *xsurface =
+        if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(wlr_surface))) {
-                                wlr_xwayland_surface_from_wlr_surface(wlr_surface);
                set_focus &= wlr_xwayland_icccm_input_model(xsurface) !=
                                WLR_ICCCM_INPUT_MODEL_NONE;
        }
@@ -824,6 +850,10 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
                input_manager_set_focus(&view->container->node);
        }
+        if (view->ext_foreign_toplevel) {
+                update_ext_foreign_toplevel(view);
+        }
        const char *app_id;
        const char *class;
        if ((app_id = view_get_app_id(view)) != NULL) {
@@ -834,15 +864,20 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
 }
 void view_unmap(struct sway_view *view) {
-        wl_signal_emit(&view->events.unmap, view);
+        wl_signal_emit_mutable(&view->events.unmap, view);
-        wl_list_remove(&view->surface_new_subsurface.link);
+        view->executed_criteria->length = 0;
        if (view->urgent_timer) {
                wl_event_source_remove(view->urgent_timer);
                view->urgent_timer = NULL;
        }
+        if (view->ext_foreign_toplevel) {
+                wlr_ext_foreign_toplevel_handle_v1_destroy(view->ext_foreign_toplevel);
+                view->ext_foreign_toplevel = NULL;
+        }
        if (view->foreign_toplevel) {
                wlr_foreign_toplevel_handle_v1_destroy(view->foreign_toplevel);
                view->foreign_toplevel = NULL;
@@ -889,293 +924,54 @@ void view_update_size(struct sway_view *view) {
        container_set_geometry_from_content(con);
 }
-void view_center_surface(struct sway_view *view) {
+void view_center_and_clip_surface(struct sway_view *view) {
        struct sway_container *con = view->container;
-        // We always center the current coordinates rather than the next, as the
-        // geometry immediately affects the currently active rendering.
-        con->surface_x = fmax(con->current.content_x, con->current.content_x +
-                        (con->current.content_width - view->geometry.width) / 2);
-        con->surface_y = fmax(con->current.content_y, con->current.content_y +
-                        (con->current.content_height - view->geometry.height) / 2);
-}
-static const struct sway_view_child_impl subsurface_impl;
+        bool clip_to_geometry = true;
-static void subsurface_get_root_coords(struct sway_view_child *child,
+        if (container_is_floating(con)) {
-                int *root_sx, int *root_sy) {
+                // We always center the current coordinates rather than the next, as the
-        struct wlr_surface *surface = child->surface;
+                // geometry immediately affects the currently active rendering.
-        *root_sx = -child->view->geometry.x;
+                int x = (int) fmax(0, (con->current.content_width - view->geometry.width) / 2);
-        *root_sy = -child->view->geometry.y;
+                int y = (int) fmax(0, (con->current.content_height - view->geometry.height) / 2);
+                clip_to_geometry = !view->using_csd;
-        if (child->parent && child->parent->impl &&
+                wlr_scene_node_set_position(&view->content_tree->node, x, y);
-                        child->parent->impl->get_root_coords) {
-                int sx, sy;
-                child->parent->impl->get_root_coords(child->parent, &sx, &sy);
-                *root_sx += sx;
-                *root_sy += sy;
        } else {
-                while (surface && wlr_surface_is_subsurface(surface)) {
+                wlr_scene_node_set_position(&view->content_tree->node, 0, 0);
-                        struct wlr_subsurface *subsurface =
+        }
-                                wlr_subsurface_from_wlr_surface(surface);
-                        if (subsurface == NULL) {
+        // only make sure to clip the content if there is content to clip
-                                break;
+        if (!wl_list_empty(&con->view->content_tree->children)) {
-                        }
+                struct wlr_box clip = {0};
-                        *root_sx += subsurface->current.x;
+                if (clip_to_geometry) {
-                        *root_sy += subsurface->current.y;
+                        clip = (struct wlr_box){
-                        surface = subsurface->parent;
+                                .x = con->view->geometry.x,
+                                .y = con->view->geometry.y,
+                                .width = con->current.content_width,
+                                .height = con->current.content_height,
+                        };
                }
-        }
+                wlr_scene_subsurface_tree_set_clip(&con->view->content_tree->node, &clip);
-}
-static void subsurface_destroy(struct sway_view_child *child) {
-        if (!sway_assert(child->impl == &subsurface_impl,
-                        "Expected a subsurface")) {
-                return;
-        }
-        struct sway_subsurface *subsurface = (struct sway_subsurface *)child;
-        wl_list_remove(&subsurface->destroy.link);
-        free(subsurface);
-}
-static const struct sway_view_child_impl subsurface_impl = {
-        .get_root_coords = subsurface_get_root_coords,
-        .destroy = subsurface_destroy,
-};
-static void subsurface_handle_destroy(struct wl_listener *listener,
-                void *data) {
-        struct sway_subsurface *subsurface =
-                wl_container_of(listener, subsurface, destroy);
-        struct sway_view_child *child = &subsurface->child;
-        view_child_destroy(child);
-}
-static void view_child_damage(struct sway_view_child *child, bool whole);
-static void view_subsurface_create(struct sway_view *view,
-                struct wlr_subsurface *wlr_subsurface) {
-        struct sway_subsurface *subsurface =
-                calloc(1, sizeof(struct sway_subsurface));
-        if (subsurface == NULL) {
-                sway_log(SWAY_ERROR, "Allocation failed");
-                return;
-        }
-        view_child_init(&subsurface->child, &subsurface_impl, view,
-                wlr_subsurface->surface);
-        wl_signal_add(&wlr_subsurface->events.destroy, &subsurface->destroy);
-        subsurface->destroy.notify = subsurface_handle_destroy;
-        subsurface->child.mapped = true;
-        view_child_damage(&subsurface->child, true);
-}
-static void view_child_subsurface_create(struct sway_view_child *child,
-                struct wlr_subsurface *wlr_subsurface) {
-        struct sway_subsurface *subsurface =
-                calloc(1, sizeof(struct sway_subsurface));
-        if (subsurface == NULL) {
-                sway_log(SWAY_ERROR, "Allocation failed");
-                return;
-        }
-        subsurface->child.parent = child;
-        wl_list_insert(&child->children, &subsurface->child.link);
-        view_child_init(&subsurface->child, &subsurface_impl, child->view,
-                wlr_subsurface->surface);
-        wl_signal_add(&wlr_subsurface->events.destroy, &subsurface->destroy);
-        subsurface->destroy.notify = subsurface_handle_destroy;
-        subsurface->child.mapped = true;
-        view_child_damage(&subsurface->child, true);
-}
-static bool view_child_is_mapped(struct sway_view_child *child) {
-        while (child) {
-                if (!child->mapped) {
-                        return false;
-                }
-                child = child->parent;
-        }
-        return true;
-}
-static void view_child_damage(struct sway_view_child *child, bool whole) {
-        if (!child || !view_child_is_mapped(child) || !child->view || !child->view->container) {
-                return;
-        }
-        int sx, sy;
-        child->impl->get_root_coords(child, &sx, &sy);
-        desktop_damage_surface(child->surface,
-                        child->view->container->pending.content_x + sx,
-                        child->view->container->pending.content_y + sy, whole);
-}
-static void view_child_handle_surface_commit(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_commit);
-        view_child_damage(child, false);
-}
-static void view_child_handle_surface_new_subsurface(
-                struct wl_listener *listener, void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_new_subsurface);
-        struct wlr_subsurface *subsurface = data;
-        view_child_subsurface_create(child, subsurface);
-}
-static void view_child_handle_surface_destroy(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_destroy);
-        view_child_destroy(child);
-}
-static void view_init_subsurfaces(struct sway_view *view,
-                struct wlr_surface *surface) {
-        struct wlr_subsurface *subsurface;
-        wl_list_for_each(subsurface, &surface->subsurfaces_below, parent_link) {
-                view_subsurface_create(view, subsurface);
-        }
-        wl_list_for_each(subsurface, &surface->subsurfaces_above, parent_link) {
-                view_subsurface_create(view, subsurface);
-        }
-}
-static void view_child_init_subsurfaces(struct sway_view_child *view_child,
-                struct wlr_surface *surface) {
-        struct wlr_subsurface *subsurface;
-        wl_list_for_each(subsurface, &surface->subsurfaces_below, parent_link) {
-                view_child_subsurface_create(view_child, subsurface);
-        }
-        wl_list_for_each(subsurface, &surface->subsurfaces_above, parent_link) {
-                view_child_subsurface_create(view_child, subsurface);
-        }
-}
-static void view_child_handle_surface_map(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_map);
-        child->mapped = true;
-        view_child_damage(child, true);
-}
-static void view_child_handle_surface_unmap(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_unmap);
-        view_child_damage(child, true);
-        child->mapped = false;
-}
-static void view_child_handle_view_unmap(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, view_unmap);
-        view_child_damage(child, true);
-        child->mapped = false;
-}
-void view_child_init(struct sway_view_child *child,
-                const struct sway_view_child_impl *impl, struct sway_view *view,
-                struct wlr_surface *surface) {
-        child->impl = impl;
-        child->view = view;
-        child->surface = surface;
-        wl_list_init(&child->children);
-        wl_signal_add(&surface->events.commit, &child->surface_commit);
-        child->surface_commit.notify = view_child_handle_surface_commit;
-        wl_signal_add(&surface->events.new_subsurface,
-                &child->surface_new_subsurface);
-        child->surface_new_subsurface.notify =
-                view_child_handle_surface_new_subsurface;
-        wl_signal_add(&surface->events.destroy, &child->surface_destroy);
-        child->surface_destroy.notify = view_child_handle_surface_destroy;
-        // Not all child views have a map/unmap event
-        child->surface_map.notify = view_child_handle_surface_map;
-        wl_list_init(&child->surface_map.link);
-        child->surface_unmap.notify = view_child_handle_surface_unmap;
-        wl_list_init(&child->surface_unmap.link);
-        wl_signal_add(&view->events.unmap, &child->view_unmap);
-        child->view_unmap.notify = view_child_handle_view_unmap;
-        struct sway_workspace *workspace = child->view->container->pending.workspace;
-        if (workspace) {
-                wlr_surface_send_enter(child->surface, workspace->output->wlr_output);
-        }
-        view_child_init_subsurfaces(child, surface);
-}
-void view_child_destroy(struct sway_view_child *child) {
-        if (view_child_is_mapped(child) && child->view->container != NULL) {
-                view_child_damage(child, true);
-        }
-        if (child->parent != NULL) {
-                wl_list_remove(&child->link);
-                child->parent = NULL;
-        }
-        struct sway_view_child *subchild, *tmpchild;
-        wl_list_for_each_safe(subchild, tmpchild, &child->children, link) {
-                wl_list_remove(&subchild->link);
-                subchild->parent = NULL;
-                // The subchild lost its parent link, so it cannot see that the parent
-                // is unmapped. Unmap it directly.
-                subchild->mapped = false;
-        }
-        wl_list_remove(&child->surface_commit.link);
-        wl_list_remove(&child->surface_destroy.link);
-        wl_list_remove(&child->surface_map.link);
-        wl_list_remove(&child->surface_unmap.link);
-        wl_list_remove(&child->view_unmap.link);
-        wl_list_remove(&child->surface_new_subsurface.link);
-        if (child->impl && child->impl->destroy) {
-                child->impl->destroy(child);
-        } else {
-                free(child);
        }
 }
 struct sway_view *view_from_wlr_surface(struct wlr_surface *wlr_surface) {
-        if (wlr_surface_is_xdg_surface(wlr_surface)) {
+        struct wlr_xdg_surface *xdg_surface;
-                struct wlr_xdg_surface *xdg_surface =
+        if ((xdg_surface = wlr_xdg_surface_try_from_wlr_surface(wlr_surface))) {
-                        wlr_xdg_surface_from_wlr_surface(wlr_surface);
-                if (xdg_surface == NULL) {
-                        return NULL;
-                }
                return view_from_wlr_xdg_surface(xdg_surface);
        }
-#if HAVE_XWAYLAND
+#if WLR_HAS_XWAYLAND
-        if (wlr_surface_is_xwayland_surface(wlr_surface)) {
+        struct wlr_xwayland_surface *xsurface;
-                struct wlr_xwayland_surface *xsurface =
+        if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(wlr_surface))) {
-                        wlr_xwayland_surface_from_wlr_surface(wlr_surface);
-                if (xsurface == NULL) {
-                        return NULL;
-                }
                return view_from_wlr_xwayland_surface(xsurface);
        }
 #endif
-        if (wlr_surface_is_subsurface(wlr_surface)) {
+        struct wlr_subsurface *subsurface;
-                struct wlr_subsurface *subsurface =
+        if ((subsurface = wlr_subsurface_try_from_wlr_surface(wlr_surface))) {
-                        wlr_subsurface_from_wlr_surface(wlr_surface);
-                if (subsurface == NULL) {
-                        return NULL;
-                }
                return view_from_wlr_surface(subsurface->parent);
        }
-        if (wlr_surface_is_layer_surface(wlr_surface)) {
+        if (wlr_layer_surface_v1_try_from_wlr_surface(wlr_surface) != NULL) {
                return NULL;
        }
@@ -1256,6 +1052,18 @@ static size_t parse_title_format(struct sway_view *view, char *buffer) {
        return len;
 }
+void view_update_app_id(struct sway_view *view) {
+        const char *app_id = view_get_app_id(view);
+        if (view->foreign_toplevel && app_id) {
+                wlr_foreign_toplevel_handle_v1_set_app_id(view->foreign_toplevel, app_id);
+        }
+        if (view->ext_foreign_toplevel) {
+                update_ext_foreign_toplevel(view);
+        }
+}
 void view_update_title(struct sway_view *view, bool force) {
        const char *title = view_get_title(view);
@@ -1271,31 +1079,41 @@ void view_update_title(struct sway_view *view, bool force) {
        free(view->container->title);
        free(view->container->formatted_title);
-        if (title) {
-                size_t len = parse_title_format(view, NULL);
+        size_t len = parse_title_format(view, NULL);
+        if (len) {
                char *buffer = calloc(len + 1, sizeof(char));
                if (!sway_assert(buffer, "Unable to allocate title string")) {
                        return;
                }
-                parse_title_format(view, buffer);
-                view->container->title = strdup(title);
+                parse_title_format(view, buffer);
                view->container->formatted_title = buffer;
        } else {
-                view->container->title = NULL;
                view->container->formatted_title = NULL;
        }
-        container_calculate_title_height(view->container);
-        config_update_font_height(false);
+        view->container->title = title ? strdup(title) : NULL;
        // Update title after the global font height is updated
-        container_update_title_textures(view->container);
+        if (view->container->title_bar.title_text && len) {
+                sway_text_node_set_text(view->container->title_bar.title_text,
+                        view->container->formatted_title);
+                container_arrange_title_bar(view->container);
+        } else {
+                container_update_title_bar(view->container);
+        }
        ipc_event_window(view->container, "title");
        if (view->foreign_toplevel && title) {
                wlr_foreign_toplevel_handle_v1_set_title(view->foreign_toplevel, title);
        }
+        if (view->ext_foreign_toplevel) {
+                update_ext_foreign_toplevel(view);
+        }
 }
 bool view_is_visible(struct sway_view *view) {
@@ -1356,6 +1174,7 @@ void view_set_urgent(struct sway_view *view, bool enable) {
                        return;
                }
                clock_gettime(CLOCK_MONOTONIC, &view->urgent);
+                container_update_itself_and_parents(view->container);
        } else {
                view->urgent = (struct timespec){ 0 };
                if (view->urgent_timer) {
@@ -1363,7 +1182,6 @@ void view_set_urgent(struct sway_view *view, bool enable) {
                        view->urgent_timer = NULL;
                }
        }
-        container_damage_whole(view->container);
        ipc_event_window(view->container, "urgent");
@@ -1377,40 +1195,54 @@ bool view_is_urgent(struct sway_view *view) {
 }
 void view_remove_saved_buffer(struct sway_view *view) {
-        if (!sway_assert(!wl_list_empty(&view->saved_buffers), "Expected a saved buffer")) {
+        if (!sway_assert(view->saved_surface_tree, "Expected a saved buffer")) {
                return;
        }
-        struct sway_saved_buffer *saved_buf, *tmp;
-        wl_list_for_each_safe(saved_buf, tmp, &view->saved_buffers, link) {
+        wlr_scene_node_destroy(&view->saved_surface_tree->node);
-                wlr_buffer_unlock(&saved_buf->buffer->base);
+        view->saved_surface_tree = NULL;
-                wl_list_remove(&saved_buf->link);
+        wlr_scene_node_set_enabled(&view->content_tree->node, true);
-                free(saved_buf);
-        }
 }
-static void view_save_buffer_iterator(struct wlr_surface *surface,
+static void view_save_buffer_iterator(struct wlr_scene_buffer *buffer,
                int sx, int sy, void *data) {
-        struct sway_view *view = data;
+        struct wlr_scene_tree *tree = data;
-        if (surface && wlr_surface_has_buffer(surface)) {
+        struct wlr_scene_buffer *sbuf = wlr_scene_buffer_create(tree, NULL);
-                wlr_buffer_lock(&surface->buffer->base);
+        if (!sbuf) {
-                struct sway_saved_buffer *saved_buffer = calloc(1, sizeof(struct sway_saved_buffer));
+                sway_log(SWAY_ERROR, "Could not allocate a scene buffer when saving a surface");
-                saved_buffer->buffer = surface->buffer;
+                return;
-                saved_buffer->width = surface->current.width;
-                saved_buffer->height = surface->current.height;
-                saved_buffer->x = view->container->surface_x + sx;
-                saved_buffer->y = view->container->surface_y + sy;
-                saved_buffer->transform = surface->current.transform;
-                wlr_surface_get_buffer_source_box(surface, &saved_buffer->source_box);
-                wl_list_insert(&view->saved_buffers, &saved_buffer->link);
        }
+        wlr_scene_buffer_set_dest_size(sbuf,
+                buffer->dst_width, buffer->dst_height);
+        wlr_scene_buffer_set_opaque_region(sbuf, &buffer->opaque_region);
+        wlr_scene_buffer_set_source_box(sbuf, &buffer->src_box);
+        wlr_scene_node_set_position(&sbuf->node, sx, sy);
+        wlr_scene_buffer_set_transform(sbuf, buffer->transform);
+        wlr_scene_buffer_set_buffer(sbuf, buffer->buffer);
 }
 void view_save_buffer(struct sway_view *view) {
-        if (!sway_assert(wl_list_empty(&view->saved_buffers), "Didn't expect saved buffer")) {
+        if (!sway_assert(!view->saved_surface_tree, "Didn't expect saved buffer")) {
                view_remove_saved_buffer(view);
        }
-        view_for_each_surface(view, view_save_buffer_iterator, view);
+        view->saved_surface_tree = wlr_scene_tree_create(view->scene_tree);
+        if (!view->saved_surface_tree) {
+                sway_log(SWAY_ERROR, "Could not allocate a scene tree node when saving a surface");
+                return;
+        }
+        // Enable and disable the saved surface tree like so to atomitaclly update
+        // the tree. This will prevent over damaging or other weirdness.
+        wlr_scene_node_set_enabled(&view->saved_surface_tree->node, false);
+        wlr_scene_node_for_each_buffer(&view->content_tree->node,
+                view_save_buffer_iterator, view->saved_surface_tree);
+        wlr_scene_node_set_enabled(&view->content_tree->node, false);
+        wlr_scene_node_set_enabled(&view->saved_surface_tree->node, true);
 }
 bool view_is_transient_for(struct sway_view *child,
@@ -1418,3 +1250,19 @@ bool view_is_transient_for(struct sway_view *child,
        return child->impl->is_transient_for &&
                child->impl->is_transient_for(child, ancestor);
 }
+static void send_frame_done_iterator(struct wlr_scene_buffer *scene_buffer,
+                int x, int y, void *data) {
+        struct timespec *when = data;
+        wl_signal_emit_mutable(&scene_buffer->events.frame_done, when);
+}
+void view_send_frame_done(struct sway_view *view) {
+        struct timespec when;
+        clock_gettime(CLOCK_MONOTONIC, &when);
+        struct wlr_scene_node *node;
+        wl_list_for_each(node, &view->content_tree->children, link) {
+                wlr_scene_node_for_each_buffer(node, send_frame_done_iterator, &when);
+        }
+}
diff --git a/sway/tree/workspace.c b/sway/tree/workspace.c
index 8dd7789d..a68dc927 100644
--- a/sway/tree/workspace.c
+++ b/sway/tree/workspace.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809
 #include <ctype.h>
 #include <limits.h>
 #include <stdbool.h>
@@ -50,12 +49,14 @@ struct sway_output *workspace_get_initial_output(const char *name) {
        } else if (focus && focus->type == N_CONTAINER) {
                return focus->sway_container->pending.workspace->output;
        }
-        // Fallback to the first output or noop output for headless
+        // Fallback to the first output or the headless output
-        return root->outputs->length ? root->outputs->items[0] : root->noop_output;
+        return root->outputs->length ? root->outputs->items[0] : root->fallback_output;
 }
 struct sway_workspace *workspace_create(struct sway_output *output,
                const char *name) {
+        sway_assert(name, "NULL name given to workspace_create");
        if (output == NULL) {
                output = workspace_get_initial_output(name);
        }
@@ -69,7 +70,19 @@ struct sway_workspace *workspace_create(struct sway_output *output,
                return NULL;
        }
        node_init(&ws->node, N_WORKSPACE, ws);
-        ws->name = name ? strdup(name) : NULL;
+        bool failed = false;
+        ws->layers.tiling = alloc_scene_tree(root->staging, &failed);
+        ws->layers.fullscreen = alloc_scene_tree(root->staging, &failed);
+        if (failed) {
+                wlr_scene_node_destroy(&ws->layers.tiling->node);
+                wlr_scene_node_destroy(&ws->layers.fullscreen->node);
+                free(ws);
+                return NULL;
+        }
+        ws->name = strdup(name);
        ws->prev_split_layout = L_NONE;
        ws->layout = output_get_default_layout(output);
        ws->floating = create_list();
@@ -114,7 +127,7 @@ struct sway_workspace *workspace_create(struct sway_output *output,
        output_sort_workspaces(output);
        ipc_event_workspace(NULL, ws, "init");
-        wl_signal_emit(&root->events.new_node, &ws->node);
+        wl_signal_emit_mutable(&root->events.new_node, &ws->node);
        return ws;
 }
@@ -129,6 +142,11 @@ void workspace_destroy(struct sway_workspace *workspace) {
                return;
        }
+        scene_node_disown_children(workspace->layers.tiling);
+        scene_node_disown_children(workspace->layers.fullscreen);
+        wlr_scene_node_destroy(&workspace->layers.tiling->node);
+        wlr_scene_node_destroy(&workspace->layers.fullscreen->node);
        free(workspace->name);
        free(workspace->representation);
        list_free_items_and_destroy(workspace->output_priority);
@@ -142,7 +160,7 @@ void workspace_destroy(struct sway_workspace *workspace) {
 void workspace_begin_destroy(struct sway_workspace *workspace) {
        sway_log(SWAY_DEBUG, "Destroying workspace '%s'", workspace->name);
        ipc_event_workspace(NULL, workspace, "empty"); // intentional
-        wl_signal_emit(&workspace->node.events.destroy, &workspace->node);
+        wl_signal_emit_mutable(&workspace->node.events.destroy, &workspace->node);
        if (workspace->output) {
                workspace_detach(workspace);
@@ -174,22 +192,16 @@ void workspace_consider_destroy(struct sway_workspace *ws) {
 static bool workspace_valid_on_output(const char *output_name,
                const char *ws_name) {
        struct workspace_config *wsc = workspace_find_config(ws_name);
-        char identifier[128];
        struct sway_output *output = output_by_name_or_id(output_name);
        if (!output) {
                return false;
        }
-        output_name = output->wlr_output->name;
-        output_get_identifier(identifier, sizeof(identifier), output);
        if (!wsc) {
                return true;
        }
        for (int i = 0; i < wsc->outputs->length; i++) {
-                if (strcmp(wsc->outputs->items[i], "*") == 0 ||
+                if (output_match_name_or_id(output, wsc->outputs->items[i])) {
-                                strcmp(wsc->outputs->items[i], output_name) == 0 ||
-                                strcmp(wsc->outputs->items[i], identifier) == 0) {
                        return true;
                }
        }
@@ -284,13 +296,10 @@ char *workspace_next_name(const char *output_name) {
        // assignments primarily, falling back to bindings and numbers.
        struct sway_mode *mode = config->current_mode;
-        char identifier[128];
        struct sway_output *output = output_by_name_or_id(output_name);
        if (!output) {
                return NULL;
        }
-        output_name = output->wlr_output->name;
-        output_get_identifier(identifier, sizeof(identifier), output);
        int order = INT_MAX;
        char *target = NULL;
@@ -310,9 +319,7 @@ char *workspace_next_name(const char *output_name) {
                }
                bool found = false;
                for (int j = 0; j < wsc->outputs->length; ++j) {
-                        if (strcmp(wsc->outputs->items[j], "*") == 0 ||
+                        if (output_match_name_or_id(output, wsc->outputs->items[j])) {
-                                        strcmp(wsc->outputs->items[j], output_name) == 0 ||
-                                        strcmp(wsc->outputs->items[j], identifier) == 0) {
                                found = true;
                                free(target);
                                target = strdup(wsc->workspace);
@@ -652,15 +659,9 @@ void workspace_output_add_priority(struct sway_workspace *workspace,
 struct sway_output *workspace_output_get_highest_available(
                struct sway_workspace *ws, struct sway_output *exclude) {
-        char exclude_id[128] = {'\0'};
-        if (exclude) {
-                output_get_identifier(exclude_id, sizeof(exclude_id), exclude);
-        }
        for (int i = 0; i < ws->output_priority->length; i++) {
-                char *name = ws->output_priority->items[i];
+                const char *name = ws->output_priority->items[i];
-                if (exclude && (strcmp(name, exclude->wlr_output->name) == 0
+                if (exclude && output_match_name_or_id(exclude, name)) {
-                                        || strcmp(name, exclude_id) == 0)) {
                        continue;
                }
@@ -684,7 +685,6 @@ void workspace_detect_urgent(struct sway_workspace *workspace) {
        if (workspace->urgent != new_urgent) {
                workspace->urgent = new_urgent;
                ipc_event_workspace(NULL, workspace, "urgent");
-                output_damage_whole(workspace->output);
        }
 }
@@ -844,24 +844,36 @@ struct sway_container *workspace_insert_tiling(struct sway_workspace *workspace,
        return con;
 }
+bool workspace_has_single_visible_container(struct sway_workspace *ws) {
+        struct sway_seat *seat = input_manager_get_default_seat();
+        struct sway_container *focus =
+                seat_get_focus_inactive_tiling(seat, ws);
+        if (focus && !focus->view) {
+                focus = seat_get_focus_inactive_view(seat, &focus->node);
+        }
+        return (focus && focus->view && view_ancestor_is_only_visible(focus->view));
+}
 void workspace_add_gaps(struct sway_workspace *ws) {
-        if (config->smart_gaps) {
+        if (config->smart_gaps == SMART_GAPS_ON
-                struct sway_seat *seat = input_manager_get_default_seat();
+                        && workspace_has_single_visible_container(ws)) {
-                struct sway_container *focus =
+                ws->current_gaps.top = 0;
-                        seat_get_focus_inactive_tiling(seat, ws);
+                ws->current_gaps.right = 0;
-                if (focus && !focus->view) {
+                ws->current_gaps.bottom = 0;
-                        focus = seat_get_focus_inactive_view(seat, &focus->node);
+                ws->current_gaps.left = 0;
-                }
+                return;
-                if (focus && focus->view && view_ancestor_is_only_visible(focus->view)) {
+        }
-                        ws->current_gaps.top = 0;
-                        ws->current_gaps.right = 0;
+        if (config->smart_gaps == SMART_GAPS_INVERSE_OUTER
-                        ws->current_gaps.bottom = 0;
+                        && !workspace_has_single_visible_container(ws)) {
-                        ws->current_gaps.left = 0;
+                ws->current_gaps.top = 0;
-                        return;
+                ws->current_gaps.right = 0;
-                }
+                ws->current_gaps.bottom = 0;
+                ws->current_gaps.left = 0;
+        } else {
+                ws->current_gaps = ws->gaps_outer;
        }
-        ws->current_gaps = ws->gaps_outer;
        // Add inner gaps and make sure we don't turn out negative
        ws->current_gaps.top = fmax(0, ws->current_gaps.top + ws->gaps_inner);
        ws->current_gaps.right = fmax(0, ws->current_gaps.right + ws->gaps_inner);
diff --git a/sway/xdg_activation_v1.c b/sway/xdg_activation_v1.c
index 6c70c785..b7c80dd4 100644
--- a/sway/xdg_activation_v1.c
+++ b/sway/xdg_activation_v1.c
@@ -1,20 +1,65 @@
 #include <wlr/types/wlr_xdg_activation_v1.h>
+#include <wlr/types/wlr_xdg_shell.h>
+#include "sway/desktop/launcher.h"
 #include "sway/tree/view.h"
+#include "sway/tree/workspace.h"
 void xdg_activation_v1_handle_request_activate(struct wl_listener *listener,
                void *data) {
        const struct wlr_xdg_activation_v1_request_activate_event *event = data;
-        if (!wlr_surface_is_xdg_surface(event->surface)) {
+        struct wlr_xdg_surface *xdg_surface =
+                wlr_xdg_surface_try_from_wlr_surface(event->surface);
+        if (xdg_surface == NULL) {
                return;
        }
-        struct wlr_xdg_surface *xdg_surface =
-                wlr_xdg_surface_from_wlr_surface(event->surface);
        struct sway_view *view = xdg_surface->data;
-        if (!xdg_surface->mapped || view == NULL) {
+        if (view == NULL) {
+                return;
+        }
+        struct launcher_ctx *ctx = event->token->data;
+        if (ctx == NULL) {
+                return;
+        }
+        if (!xdg_surface->surface->mapped) {
+                // This is a startup notification. If we are tracking it, the data
+                // field is a launcher_ctx.
+                if (ctx->activated) {
+                        // This ctx has already been activated and cannot be used again
+                        // for a startup notification. It will be destroyed
+                        return;
+                } else {
+                        ctx->activated = true;
+                        view_assign_ctx(view, ctx);
+                }
                return;
        }
-        view_request_activate(view);
+        // This is an activation request. If this context is internal we have ctx->seat.
+        struct sway_seat *seat = ctx->seat;
+        if (!seat) {
+                // Otherwise, use the seat indicated by the launcher client in set_serial
+                seat = ctx->token->seat ? ctx->token->seat->data : NULL;
+        }
+        if (seat && ctx->had_focused_surface) {
+                view_request_activate(view, seat);
+        } else {
+                // The token is valid, but cannot be used to activate a window
+                view_request_urgent(view);
+        }
+}
+void xdg_activation_v1_handle_new_token(struct wl_listener *listener, void *data) {
+        struct wlr_xdg_activation_token_v1 *token = data;
+        struct sway_seat *seat = token->seat ? token->seat->data :
+                input_manager_current_seat();
+        struct sway_workspace *ws = seat_get_focused_workspace(seat);
+        if (ws) {
+                launcher_ctx_create(token, &ws->node);
+                return;
+        }
 }
diff --git a/sway/xdg_decoration.c b/sway/xdg_decoration.c
index e7c3ea73..fa8c6279 100644
--- a/sway/xdg_decoration.c
+++ b/sway/xdg_decoration.c
@@ -10,7 +10,7 @@ static void xdg_decoration_handle_destroy(struct wl_listener *listener,
                void *data) {
        struct sway_xdg_decoration *deco =
                wl_container_of(listener, deco, destroy);
-        if(deco->view) {
+        if (deco->view) {
                deco->view->xdg_decoration = NULL;
        }
        wl_list_remove(&deco->destroy.link);
@@ -23,13 +23,12 @@ static void xdg_decoration_handle_request_mode(struct wl_listener *listener,
                void *data) {
        struct sway_xdg_decoration *deco =
                wl_container_of(listener, deco, request_mode);
-        wlr_xdg_toplevel_decoration_v1_set_mode(deco->wlr_xdg_decoration,
+        set_xdg_decoration_mode(deco);
-                        WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
 }
 void handle_xdg_decoration(struct wl_listener *listener, void *data) {
        struct wlr_xdg_toplevel_decoration_v1 *wlr_deco = data;
-        struct sway_xdg_shell_view *xdg_shell_view = wlr_deco->surface->data;
+        struct sway_xdg_shell_view *xdg_shell_view = wlr_deco->toplevel->base->data;
        struct sway_xdg_decoration *deco = calloc(1, sizeof(*deco));
        if (deco == NULL) {
@@ -48,16 +47,46 @@ void handle_xdg_decoration(struct wl_listener *listener, void *data) {
        wl_list_insert(&server.xdg_decorations, &deco->link);
-        xdg_decoration_handle_request_mode(&deco->request_mode, wlr_deco);
+        set_xdg_decoration_mode(deco);
 }
 struct sway_xdg_decoration *xdg_decoration_from_surface(
                struct wlr_surface *surface) {
        struct sway_xdg_decoration *deco;
        wl_list_for_each(deco, &server.xdg_decorations, link) {
-                if (deco->wlr_xdg_decoration->surface->surface == surface) {
+                if (deco->wlr_xdg_decoration->toplevel->base->surface == surface) {
                        return deco;
                }
        }
        return NULL;
 }
+void set_xdg_decoration_mode(struct sway_xdg_decoration *deco) {
+        struct sway_view *view = deco->view;
+        enum wlr_xdg_toplevel_decoration_v1_mode mode =
+                WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE;
+        enum wlr_xdg_toplevel_decoration_v1_mode client_mode =
+                deco->wlr_xdg_decoration->requested_mode;
+        bool floating;
+        if (view->container) {
+                floating = container_is_floating(view->container);
+                bool csd = false;
+                csd = client_mode ==
+                        WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE;
+                view_update_csd_from_client(view, csd);
+                arrange_container(view->container);
+                transaction_commit_dirty();
+        } else {
+                floating = view->impl->wants_floating &&
+                        view->impl->wants_floating(view);
+        }
+        if (floating && client_mode) {
+                mode = client_mode;
+        }
+        if (view->wlr_xdg_toplevel->base->initialized) {
+                wlr_xdg_toplevel_decoration_v1_set_mode(deco->wlr_xdg_decoration, mode);
+        }
+}