7 files changed, 1102 insertions, 1278 deletions

diff --git a/sway/tree/arrange.c b/sway/tree/arrange.c
index 9c1a11e5..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)) {
-                                container_floating_move_to_center(floater);
+                        floating_fix_coordinates(floater, &prev_box, &workspace_box);
+                        // Set transformation for scratchpad windows.
+                        if (floater->scratchpad) {
+                                struct wlr_box output_box;
+                                output_get_box(output, &output_box);
+                                floater->transform = output_box;
                         }
                 }
         }
diff --git a/sway/tree/container.c b/sway/tree/container.c
index 09766ce5..80ef34fe 100644
--- a/sway/tree/container.c
+++ b/sway/tree/container.c
@@ -1,25 +1,20 @@
-#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 <sys/stat.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 <wlr/types/wlr_subcompositor.h>
-#include <wlr/render/drm_format_set.h>
 #include "linux-dmabuf-unstable-v1-protocol.h"
-#include "cairo_util.h"
-#include "pango.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"
@@ -30,6 +25,53 @@
 #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) {
@@ -37,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;
-        c->alpha = 1.0f;
+
+        // Container tree structure
+        // - 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")) {
@@ -65,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);
-        wlr_texture_destroy(con->title_focused_tab_title);
         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);
-        wlr_texture_destroy(con->marks_focused_tab_title);
 
         if (con->view && con->view->container == con) {
                 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);
 }
 
@@ -104,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);
 
@@ -174,265 +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_toplevel->base,
-                                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) {
-        while (!wlr_surface_is_xdg_surface(surface)) {
-                if (!wlr_surface_is_subsurface(surface)) {
-                        return false;
-                }
-                struct wlr_subsurface *subsurface =
-                        wlr_subsurface_from_wlr_surface(surface);
-                surface = subsurface->parent;
-        }
-        struct wlr_xdg_surface *xdg_surface =
-                wlr_xdg_surface_from_wlr_surface(surface);
-        return xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP;
-}
-
-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) {
@@ -478,127 +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 render_titlebar_text_texture(struct sway_output *output,
-                struct sway_container *con, struct wlr_texture **texture,
-                struct border_colors *class, bool pango_markup, char *text) {
-        double scale = output->wlr_output->scale;
-        int width = 0;
-        int height = config->font_height * scale;
-        int baseline;
-
-        // 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, &baseline, scale,
-                        config->pango_markup, "%s", text);
-        cairo_surface_destroy(dummy_surface);
-        cairo_destroy(c);
-
-        if (width == 0 || height == 0) {
-                return;
-        }
-
-        if (height > config->font_height * scale) {
-                height = config->font_height * scale;
-        }
-
-        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));
-                return;
-        }
-
-        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, config->font_baseline * scale - baseline);
-
-        render_text(cairo, config->font, scale, pango_markup, "%s", text);
-
-        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 = output->wlr_output->renderer;
-        *texture = wlr_texture_from_pixels(
-                        renderer, DRM_FORMAT_ARGB8888, stride, width, height, data);
-        cairo_surface_destroy(surface);
-        g_object_unref(pango);
-        cairo_destroy(cairo);
-}
-
-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;
-        }
-
-        render_titlebar_text_texture(output, con, texture, class,
-                config->pango_markup, con->formatted_title);
-}
-
-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);
-        update_title_texture(container, &container->title_focused_tab_title,
-                        &config->border_colors.focused_tab_title);
-        container_damage_whole(container);
-}
-
 /**
  * Calculate and return the length of the tree representation.
  * An example tree representation is: V[Terminal, Firefox]
@@ -664,7 +710,13 @@ void container_update_representation(struct sway_container *con) {
                 }
                 container_build_representation(con->pending.layout, con->pending.children,
                                 con->formatted_title);
-                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);
@@ -716,6 +768,21 @@ void floating_calculate_constraints(int *min_width, int *max_width,
 
 }
 
+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,
@@ -787,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));
-        workspace_get_box(con->pending.workspace, box);
+        struct wlr_box box;
+        workspace_get_box(con->pending.workspace, &box);
 
-        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 width = fmax(min_width, fmin(box.width * 0.5, max_width));
+        double height = fmax(min_height, fmin(box.height * 0.75, max_height));
         if (!con->view) {
                 con->pending.width = width;
                 con->pending.height = height;
@@ -800,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);
 }
 
 
@@ -937,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;
@@ -1031,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);
         }
@@ -1062,16 +1123,6 @@ void container_end_mouse_operation(struct sway_container *container) {
         }
 }
 
-static bool devid_from_fd(int fd, dev_t *devid) {
-        struct stat stat;
-        if (fstat(fd, &stat) != 0) {
-                sway_log_errno(SWAY_ERROR, "fstat failed");
-                return false;
-        }
-        *devid = stat.st_rdev;
-        return true;
-}
-
 static void set_fullscreen(struct sway_container *con, bool enable) {
         if (!con->view) {
                 return;
@@ -1083,75 +1134,6 @@ static void set_fullscreen(struct sway_container *con, bool enable) {
                                 con->view->foreign_toplevel, enable);
                 }
         }
-
-        if (!server.linux_dmabuf_v1 || !con->view->surface) {
-                return;
-        }
-        if (!enable) {
-                wlr_linux_dmabuf_v1_set_surface_feedback(server.linux_dmabuf_v1,
-                        con->view->surface, NULL);
-                return;
-        }
-
-        if (!con->pending.workspace || !con->pending.workspace->output) {
-                return;
-        }
-
-        struct sway_output *output = con->pending.workspace->output;
-        struct wlr_output *wlr_output = output->wlr_output;
-
-        // TODO: add wlroots helpers for all of this stuff
-
-        const struct wlr_drm_format_set *renderer_formats =
-                wlr_renderer_get_dmabuf_texture_formats(server.renderer);
-        assert(renderer_formats);
-
-        int renderer_drm_fd = wlr_renderer_get_drm_fd(server.renderer);
-        int backend_drm_fd = wlr_backend_get_drm_fd(wlr_output->backend);
-        if (renderer_drm_fd < 0 || backend_drm_fd < 0) {
-                return;
-        }
-
-        dev_t render_dev, scanout_dev;
-        if (!devid_from_fd(renderer_drm_fd, &render_dev) ||
-                        !devid_from_fd(backend_drm_fd, &scanout_dev)) {
-                return;
-        }
-
-        const struct wlr_drm_format_set *output_formats =
-                wlr_output_get_primary_formats(output->wlr_output,
-                WLR_BUFFER_CAP_DMABUF);
-        if (!output_formats) {
-                return;
-        }
-
-        struct wlr_drm_format_set scanout_formats = {0};
-        if (!wlr_drm_format_set_intersect(&scanout_formats,
-                        output_formats, renderer_formats)) {
-                return;
-        }
-
-        struct wlr_linux_dmabuf_feedback_v1_tranche tranches[] = {
-                {
-                        .target_device = scanout_dev,
-                        .flags = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT,
-                        .formats = &scanout_formats,
-                },
-                {
-                        .target_device = render_dev,
-                        .formats = renderer_formats,
-                },
-        };
-
-        const struct wlr_linux_dmabuf_feedback_v1 feedback = {
-                .main_device = render_dev,
-                .tranches = tranches,
-                .tranches_len = sizeof(tranches) / sizeof(tranches[0]),
-        };
-        wlr_linux_dmabuf_v1_set_surface_feedback(server.linux_dmabuf_v1,
-                con->view->surface, &feedback);
-
-        wlr_drm_format_set_finish(&scanout_formats);
 }
 
 static void container_fullscreen_workspace(struct sway_container *con) {
@@ -1321,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;
@@ -1397,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) {
@@ -1422,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) {
@@ -1643,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;
                 }
@@ -1674,70 +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] != '_') {
-                        snprintf(part, len + 1, "[%s]", mark);
-                        strcat(buffer, part);
-                }
-        }
-        free(part);
-
-        render_titlebar_text_texture(output, con, texture, class, false, buffer);
-
-        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);
-        update_marks_texture(con, &con->marks_focused_tab_title,
-                        &config->border_colors.focused_tab_title);
-        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);
         }
@@ -1821,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 52826c91..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"
 
@@ -87,9 +86,51 @@ 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;
@@ -102,11 +143,6 @@ struct sway_output *output_create(struct wlr_output *wlr_output) {
         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();
@@ -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.disable, 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,7 +313,7 @@ void output_begin_destroy(struct sway_output *output) {
                 return;
         }
         sway_log(SWAY_DEBUG, "Destroying output '%s'", output->wlr_output->name);
-        wl_signal_emit(&output->node.events.destroy, &output->node);
+        wl_signal_emit_mutable(&output->node.events.destroy, &output->node);
 
         output->node.destroying = true;
         node_set_dirty(&output->node);
@@ -390,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 8508e9eb..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();
-        wl_list_init(&root->all_outputs);
-#if HAVE_XWAYLAND
-        wl_list_init(&root->xwayland_unmanaged);
+        root->root_scene = root_scene;
+
+        bool failed = false;
+        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
-        double center_lx = con->pending.x + con->pending.width / 2;
-        double center_ly = con->pending.y + con->pending.height / 2;
-
-        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);
+        if (new_ws->output) {
+                struct wlr_box output_box;
+                output_get_box(new_ws->output, &output_box);
+                floating_fix_coordinates(con, &con->transform, &output_box);
         }
+        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;
-
-        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;
-}
-
-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) {
@@ -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 7d9e038d..1c1c8ee8 100644
--- a/sway/tree/view.c
+++ b/sway/tree/view.c
@@ -1,29 +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 HAVE_XWAYLAND
+#if WLR_HAS_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"
@@ -33,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) {
@@ -58,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) {
@@ -110,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);
@@ -143,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
@@ -363,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
-                return;
+        if (!seat) {
+                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);
                 }
@@ -382,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) {
@@ -433,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) {
@@ -517,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
@@ -533,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();
 
@@ -568,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;
         }
 
@@ -592,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);
@@ -717,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
@@ -754,6 +766,13 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
                 }
         }
 
+        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);
         view->foreign_activate_request.notify = handle_foreign_activate_request;
@@ -777,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);
         }
@@ -824,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_surface_is_xwayland_surface(wlr_surface)) {
-                struct wlr_xwayland_surface *xsurface =
-                                wlr_xwayland_surface_from_wlr_surface(wlr_surface);
+#if WLR_HAS_XWAYLAND
+        struct wlr_xwayland_surface *xsurface;
+        if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(wlr_surface))) {
                 set_focus &= wlr_xwayland_icccm_input_model(xsurface) !=
                                 WLR_ICCCM_INPUT_MODEL_NONE;
         }
@@ -837,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) {
@@ -847,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;
@@ -902,291 +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_view_coords(struct sway_view_child *child,
-                int *sx, int *sy) {
-        struct wlr_surface *surface = child->surface;
-        if (child->parent && child->parent->impl &&
-                        child->parent->impl->get_view_coords) {
-                child->parent->impl->get_view_coords(child->parent, sx, sy);
-        } else {
-                *sx = *sy = 0;
-        }
-        struct wlr_subsurface *subsurface =
-                wlr_subsurface_from_wlr_surface(surface);
-        *sx += subsurface->current.x;
-        *sy += subsurface->current.y;
-}
+        if (container_is_floating(con)) {
+                // We always center the current coordinates rather than the next, as the
+                // geometry immediately affects the currently active rendering.
+                int x = (int) fmax(0, (con->current.content_width - view->geometry.width) / 2);
+                int y = (int) fmax(0, (con->current.content_height - view->geometry.height) / 2);
+                clip_to_geometry = !view->using_csd;
 
-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_view_coords = subsurface_get_view_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_view_coords(child, &sx, &sy);
-        desktop_damage_surface(child->surface,
-                        child->view->container->pending.content_x -
-                                child->view->geometry.x + sx,
-                        child->view->container->pending.content_y -
-                                child->view->geometry.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->current.subsurfaces_below,
-                        current.link) {
-                view_subsurface_create(view, subsurface);
-        }
-        wl_list_for_each(subsurface, &surface->current.subsurfaces_above,
-                        current.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->current.subsurfaces_below,
-                        current.link) {
-                view_child_subsurface_create(view_child, subsurface);
-        }
-        wl_list_for_each(subsurface, &surface->current.subsurfaces_above,
-                        current.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_container *container = child->view->container;
-        if (container != NULL) {
-                struct sway_workspace *workspace = 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);
+                wlr_scene_node_set_position(&view->content_tree->node, x, y);
         } else {
-                free(child);
+                wlr_scene_node_set_position(&view->content_tree->node, 0, 0);
+        }
+
+        // only make sure to clip the content if there is content to clip
+        if (!wl_list_empty(&con->view->content_tree->children)) {
+                struct wlr_box clip = {0};
+                if (clip_to_geometry) {
+                        clip = (struct wlr_box){
+                                .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);
         }
 }
 
 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 =
-                        wlr_xdg_surface_from_wlr_surface(wlr_surface);
-                if (xdg_surface == NULL) {
-                        return NULL;
-                }
+        struct wlr_xdg_surface *xdg_surface;
+        if ((xdg_surface = wlr_xdg_surface_try_from_wlr_surface(wlr_surface))) {
                 return view_from_wlr_xdg_surface(xdg_surface);
         }
-#if HAVE_XWAYLAND
-        if (wlr_surface_is_xwayland_surface(wlr_surface)) {
-                struct wlr_xwayland_surface *xsurface =
-                        wlr_xwayland_surface_from_wlr_surface(wlr_surface);
-                if (xsurface == NULL) {
-                        return NULL;
-                }
+#if WLR_HAS_XWAYLAND
+        struct wlr_xwayland_surface *xsurface;
+        if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(wlr_surface))) {
                 return view_from_wlr_xwayland_surface(xsurface);
         }
 #endif
-        if (wlr_surface_is_subsurface(wlr_surface)) {
-                struct wlr_subsurface *subsurface =
-                        wlr_subsurface_from_wlr_surface(wlr_surface);
-                if (subsurface == NULL) {
-                        return NULL;
-                }
+        struct wlr_subsurface *subsurface;
+        if ((subsurface = wlr_subsurface_try_from_wlr_surface(wlr_surface))) {
                 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;
         }
 
@@ -1267,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);
 
@@ -1282,29 +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;
         }
 
+        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) {
@@ -1365,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) {
@@ -1372,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");
 
@@ -1386,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_buffer_unlock(&saved_buf->buffer->base);
-                wl_list_remove(&saved_buf->link);
-                free(saved_buf);
-        }
+
+        wlr_scene_node_destroy(&view->saved_surface_tree->node);
+        view->saved_surface_tree = NULL;
+        wlr_scene_node_set_enabled(&view->content_tree->node, true);
 }
 
-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;
-
-        if (surface && wlr_surface_has_buffer(surface)) {
-                wlr_buffer_lock(&surface->buffer->base);
-                struct sway_saved_buffer *saved_buffer = calloc(1, sizeof(struct sway_saved_buffer));
-                saved_buffer->buffer = surface->buffer;
-                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.prev, &saved_buffer->link);
+        struct wlr_scene_tree *tree = data;
+
+        struct wlr_scene_buffer *sbuf = wlr_scene_buffer_create(tree, NULL);
+        if (!sbuf) {
+                sway_log(SWAY_ERROR, "Could not allocate a scene buffer when saving a surface");
+                return;
         }
+
+        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,
@@ -1427,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 c84320bd..52e48ad5 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>
@@ -11,6 +10,7 @@
 #include "sway/input/seat.h"
 #include "sway/ipc-server.h"
 #include "sway/output.h"
+#include "sway/server.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/container.h"
 #include "sway/tree/node.h"
@@ -56,6 +56,8 @@ struct sway_output *workspace_get_initial_output(const char *name) {
 
 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 +71,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 +128,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 +143,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 +161,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 +193,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 ||
-                                strcmp(wsc->outputs->items[i], output_name) == 0 ||
-                                strcmp(wsc->outputs->items[i], identifier) == 0) {
+                if (output_match_name_or_id(output, wsc->outputs->items[i])) {
                         return true;
                 }
         }
@@ -284,13 +297,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 +320,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 ||
-                                        strcmp(wsc->outputs->items[j], output_name) == 0 ||
-                                        strcmp(wsc->outputs->items[j], identifier) == 0) {
+                        if (output_match_name_or_id(output, wsc->outputs->items[j])) {
                                 found = true;
                                 free(target);
                                 target = strdup(wsc->workspace);
@@ -652,15 +660,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];
-                if (exclude && (strcmp(name, exclude->wlr_output->name) == 0
-                                        || strcmp(name, exclude_id) == 0)) {
+                const char *name = ws->output_priority->items[i];
+                if (exclude && output_match_name_or_id(exclude, name)) {
                         continue;
                 }
 
@@ -684,7 +686,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);
         }
 }