diff --git a/metadata/crosshair.xml b/metadata/crosshair.xml
index 25c67f3..804bc7d 100644
--- a/metadata/crosshair.xml
+++ b/metadata/crosshair.xml
@@ -4,7 +4,7 @@
 		<_short>Crosshair</_short>
 		<_long>Render fullscreen mouse crosshair</_long>
 		<category>Utility</category>
-		<option name="line_width" type="int">
+		<option name="line_width" type="double">
 			<_short>Line Width</_short>
 			<_long>Line width of crosshair</_long>
 			<default>2</default>
diff --git a/src/annotate.cpp b/src/annotate.cpp
index 044cfcb..3b052fd 100644
--- a/src/annotate.cpp
+++ b/src/annotate.cpp
@@ -80,26 +80,23 @@ class simple_node_render_instance_t : public render_instance_t
     node_t *self;
     damage_callback push_to_parent;
     std::shared_ptr<anno_ws_overlay> overlay, shape_overlay;
-    int *x, *y, *w, *h;
+    wf::geometry_t *geometry;
 
   public:
     simple_node_render_instance_t(node_t *self, damage_callback push_dmg,
-        int *x, int *y, int *w, int *h, std::shared_ptr<anno_ws_overlay> overlay,
+        wf::geometry_t *geometry, std::shared_ptr<anno_ws_overlay> overlay,
         std::shared_ptr<anno_ws_overlay> shape_overlay)
     {
-        this->x    = x;
-        this->y    = y;
-        this->w    = w;
-        this->h    = h;
-        this->self = self;
-        this->overlay = overlay;
+        this->geometry = geometry;
+        this->self     = self;
+        this->overlay  = overlay;
         this->shape_overlay  = shape_overlay;
         this->push_to_parent = push_dmg;
         self->connect(&on_node_damaged);
     }
 
     void schedule_instructions(std::vector<render_instruction_t>& instructions,
-        const wf::render_target_t& target, wf::region_t& damage) override
+        const wf::render_target_t& target, wf::regionf_t& damage) override
     {
         // We want to render ourselves only, the node does not have children
         instructions.push_back(render_instruction_t{
@@ -111,15 +108,15 @@ class simple_node_render_instance_t : public render_instance_t
 
     void render(const wf::scene::render_instruction_t& data) override
     {
-        auto ol    = this->overlay;
-        wlr_box og = {*x, *y, *w, *h};
+        auto ol = this->overlay;
+        wf::geometry_t og = *geometry;
 
         data.pass->custom_gles_subpass([&]
         {
             wf::gles::bind_render_buffer(data.target);
             for (auto& box : data.damage)
             {
-                wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
+                wf::gles::render_target_logic_scissor(data.target, box);
                 if (ol->cr)
                 {
                     OpenGL::render_texture(wf::gles_texture_t{ol->texture->tex}, data.target, og,
@@ -139,16 +136,16 @@ class simple_node_render_instance_t : public render_instance_t
 
 class simple_node_t : public node_t
 {
-    int x, y, w, h;
+    wf::geometry_t geometry;
 
   public:
     std::shared_ptr<anno_ws_overlay> overlay, shape_overlay;
     simple_node_t(int x, int y, int w, int h) : node_t(false)
     {
-        this->x = x;
-        this->y = y;
-        this->w = w;
-        this->h = h;
+        this->geometry.x     = x;
+        this->geometry.y     = y;
+        this->geometry.width = w;
+        this->geometry.height = h;
         overlay = std::make_shared<anno_ws_overlay>();
         shape_overlay = std::make_shared<anno_ws_overlay>();
     }
@@ -161,10 +158,10 @@ class simple_node_t : public node_t
         // this simple nodes does not need any transformations, so the push_damage
         // callback is just passed along.
         instances.push_back(std::make_unique<simple_node_render_instance_t>(
-            this, push_damage, &x, &y, &w, &h, overlay, shape_overlay));
+            this, push_damage, &geometry, overlay, shape_overlay));
     }
 
-    void do_push_damage(wf::region_t updated_region)
+    void do_push_damage(wf::regionf_t updated_region)
     {
         node_damage_signal ev;
         ev.region = updated_region;
@@ -174,19 +171,19 @@ class simple_node_t : public node_t
     wf::geometry_t get_bounding_box() override
     {
         // Specify whatever geometry your node has
-        return {x, y, w, h};
+        return geometry;
     }
 
     void set_position(int x, int y)
     {
-        this->x = x;
-        this->y = y;
+        this->geometry.x = x;
+        this->geometry.y = y;
     }
 
     void set_size(int w, int h)
     {
-        this->w = w;
-        this->h = h;
+        this->geometry.width  = w;
+        this->geometry.height = h;
     }
 };
 
@@ -201,7 +198,7 @@ std::shared_ptr<simple_node_t> add_simple_node(wf::output_t *output, int x, int
 class wayfire_annotate_screen : public wf::per_output_plugin_instance_t, public wf::pointer_interaction_t
 {
     uint32_t button;
-    wlr_box last_bbox;
+    wf::geometry_t last_bbox;
     annotate_draw_method draw_method;
     wf::pointf_t grab_point, last_cursor;
     std::vector<std::vector<std::shared_ptr<simple_node_t>>> overlays;
@@ -519,15 +516,15 @@ class wayfire_annotate_screen : public wf::per_output_plugin_instance_t, public
         cairo_line_to(cr, to.x, to.y);
         cairo_stroke(cr);
 
-        wlr_box bbox;
+        wf::geometry_t bbox;
         int padding = line_width + 1;
         bbox.x     = std::min(from.x, to.x) - padding;
         bbox.y     = std::min(from.y, to.y) - padding;
-        bbox.width = abs(from.x - to.x) + padding * 2;
-        bbox.height = abs(from.y - to.y) + padding * 2;
-        get_node_overlay()->do_push_damage(wf::region_t(bbox));
+        bbox.width = std::abs(from.x - to.x) + padding * 2;
+        bbox.height = std::abs(from.y - to.y) + padding * 2;
+        get_node_overlay()->do_push_damage(wf::regionf_t(bbox));
         cairo_surface_upload_to_texture_with_damage(ol->cairo_surface, *ol->texture,
-            bbox);
+            wf::to_integer_box(bbox));
     }
 
     bool should_damage_last()
@@ -563,14 +560,14 @@ class wayfire_annotate_screen : public wf::per_output_plugin_instance_t, public
         cairo_line_to(cr, to.x, to.y);
         cairo_stroke(cr);
 
-        wlr_box bbox;
+        wf::geometry_t bbox;
         int padding = line_width + 1;
         bbox.x     = std::min(from.x, to.x) - padding;
         bbox.y     = std::min(from.y, to.y) - padding;
-        bbox.width = abs(from.x - to.x) + padding * 2;
-        bbox.height = abs(from.y - to.y) + padding * 2;
+        bbox.width = std::abs(from.x - to.x) + padding * 2;
+        bbox.height = std::abs(from.y - to.y) + padding * 2;
         output->render->damage(bbox);
-        wf::region_t damage_region{bbox};
+        wf::regionf_t damage_region{bbox};
         if (damage_last_bbox)
         {
             output->render->damage(last_bbox);
@@ -579,14 +576,14 @@ class wayfire_annotate_screen : public wf::per_output_plugin_instance_t, public
 
         damage_region &= output->get_relative_geometry();
         auto damage_extents = damage_region.get_extents();
-        wlr_box damage_box  =
+        auto damage_box     = wf::to_integer_box(wf::geometry_t
         {damage_extents.x1, damage_extents.y1, damage_extents.x2 - damage_extents.x1,
-            damage_extents.y2 - damage_extents.y1};
+            damage_extents.y2 - damage_extents.y1});
         cairo_surface_upload_to_texture_with_damage(ol->cairo_surface, *ol->texture,
             damage_box);
 
-        get_node_overlay()->do_push_damage(wf::region_t(last_bbox));
-        get_node_overlay()->do_push_damage(wf::region_t(bbox));
+        get_node_overlay()->do_push_damage(wf::regionf_t(last_bbox));
+        get_node_overlay()->do_push_damage(wf::regionf_t(bbox));
         last_bbox = bbox;
     }
 
@@ -632,14 +629,14 @@ class wayfire_annotate_screen : public wf::per_output_plugin_instance_t, public
         cairo_rectangle(cr, x, y, w, h);
         cairo_stroke(cr);
 
-        wlr_box bbox;
+        wf::geometry_t bbox;
         int padding = line_width + 1;
         bbox.x     = x - padding;
         bbox.y     = y - padding;
         bbox.width = w + padding * 2;
         bbox.height = h + padding * 2;
         output->render->damage(bbox);
-        wf::region_t damage_region{bbox};
+        wf::regionf_t damage_region{bbox};
         if (damage_last_bbox)
         {
             output->render->damage(last_bbox);
@@ -648,14 +645,14 @@ class wayfire_annotate_screen : public wf::per_output_plugin_instance_t, public
 
         damage_region &= output->get_relative_geometry();
         auto damage_extents = damage_region.get_extents();
-        wlr_box damage_box  =
+        auto damage_box     = wf::to_integer_box(wf::geometry_t
         {damage_extents.x1, damage_extents.y1, damage_extents.x2 - damage_extents.x1,
-            damage_extents.y2 - damage_extents.y1};
+            damage_extents.y2 - damage_extents.y1});
         cairo_surface_upload_to_texture_with_damage(ol->cairo_surface, *ol->texture,
             damage_box);
 
-        get_node_overlay()->do_push_damage(wf::region_t(last_bbox));
-        get_node_overlay()->do_push_damage(wf::region_t(bbox));
+        get_node_overlay()->do_push_damage(wf::regionf_t(last_bbox));
+        get_node_overlay()->do_push_damage(wf::regionf_t(bbox));
         last_bbox = bbox;
     }
 
@@ -695,14 +692,14 @@ class wayfire_annotate_screen : public wf::per_output_plugin_instance_t, public
         cairo_arc(cr, from.x, from.y, radius, 0, 2 * M_PI);
         cairo_stroke(cr);
 
-        wlr_box bbox;
+        wf::geometry_t bbox;
         int padding = line_width + 1;
         bbox.x     = (from.x - radius) - padding;
         bbox.y     = (from.y - radius) - padding;
         bbox.width = (radius * 2) + padding * 2;
         bbox.height = (radius * 2) + padding * 2;
         output->render->damage(bbox);
-        wf::region_t damage_region{bbox};
+        wf::regionf_t damage_region{bbox};
         if (damage_last_bbox)
         {
             output->render->damage(last_bbox);
@@ -711,14 +708,14 @@ class wayfire_annotate_screen : public wf::per_output_plugin_instance_t, public
 
         damage_region &= output->get_relative_geometry();
         auto damage_extents = damage_region.get_extents();
-        wlr_box damage_box  =
+        auto damage_box     = wf::to_integer_box(wf::geometry_t
         {damage_extents.x1, damage_extents.y1, damage_extents.x2 - damage_extents.x1,
-            damage_extents.y2 - damage_extents.y1};
+            damage_extents.y2 - damage_extents.y1});
         cairo_surface_upload_to_texture_with_damage(ol->cairo_surface, *ol->texture,
             damage_box);
 
-        get_node_overlay()->do_push_damage(wf::region_t(last_bbox));
-        get_node_overlay()->do_push_damage(wf::region_t(bbox));
+        get_node_overlay()->do_push_damage(wf::regionf_t(last_bbox));
+        get_node_overlay()->do_push_damage(wf::regionf_t(bbox));
         last_bbox = bbox;
     }
 
diff --git a/src/crosshair.cpp b/src/crosshair.cpp
index 6417c5a..a9054a3 100644
--- a/src/crosshair.cpp
+++ b/src/crosshair.cpp
@@ -31,7 +31,7 @@
 
 class wayfire_crosshair : public wf::per_output_plugin_instance_t
 {
-    wf::option_wrapper_t<int> line_width{"crosshair/line_width"};
+    wf::option_wrapper_t<double> line_width{"crosshair/line_width"};
     wf::option_wrapper_t<wf::color_t> line_color{"crosshair/line_color"};
     wf::geometry_t geometry[2];
 
@@ -56,9 +56,9 @@ class wayfire_crosshair : public wf::per_output_plugin_instance_t
         output->render->damage(geometry[1]);
 
         geometry[0] =
-            wf::geometry_t{int(oc.x - half_width), 0, line_width, og.height};
+            wf::geometry_t{oc.x - half_width, 0, line_width, og.height};
         geometry[1] =
-            wf::geometry_t{0, int(oc.y - half_width), og.width, line_width};
+            wf::geometry_t{0, oc.y - half_width, og.width, line_width};
 
         output->render->damage(geometry[0]);
         output->render->damage(geometry[1]);
@@ -68,17 +68,17 @@ class wayfire_crosshair : public wf::per_output_plugin_instance_t
     {
         auto target_fb = output->render->get_target_framebuffer();
         auto gc = wf::get_core().get_cursor_position();
-        wf::point_t coords{(int)gc.x, (int)gc.y};
+        wf::pointf_t coords{gc.x, gc.y};
 
         if (!(output->get_layout_geometry() & coords))
         {
             return;
         }
 
-        wf::region_t region;
+        wf::regionf_t region;
         region |= geometry[0];
         region |= geometry[1];
-        region &= output->render->get_swap_damage();
+        region &= target_fb.geometry_region_from_framebuffer_region(output->render->get_swap_damage());
 
         auto alpha = wf::color_t(line_color).a;
         wf::color_t color = wf::color_t{
diff --git a/src/extra-animations/blinds.hpp b/src/extra-animations/blinds.hpp
index 9adf359..35edc28 100644
--- a/src/extra-animations/blinds.hpp
+++ b/src/extra-animations/blinds.hpp
@@ -122,7 +122,7 @@ class blinds_transformer : public wf::scene::view_2d_transformer_t
 
         void schedule_instructions(
             std::vector<render_instruction_t>& instructions,
-            const wf::render_target_t& target, wf::region_t& damage) override
+            const wf::render_target_t& target, wf::regionf_t& damage) override
         {
             instructions.push_back(render_instruction_t{
                         .instance = this,
@@ -131,9 +131,9 @@ class blinds_transformer : public wf::scene::view_2d_transformer_t
                     });
         }
 
-        void transform_damage_region(wf::region_t& damage) override
+        void transform_damage_region(wf::regionf_t& damage) override
         {
-            damage |= wf::region_t{self->animation_geometry};
+            damage |= self->animation_geometry;
         }
 
         void render(const wf::scene::render_instruction_t& data) override
@@ -157,17 +157,17 @@ class blinds_transformer : public wf::scene::view_2d_transformer_t
                     auto y     = src_box.height - i;
                     auto inv_h = 1.0 / src_box.height;
                     uv.push_back(1.0);
-                    uv.push_back(std::max(0, y - line_height) * inv_h);
+                    uv.push_back(std::max(0.0, y - line_height) * inv_h);
                     uv.push_back(0.0);
-                    uv.push_back(std::max(0, y - line_height) * inv_h);
+                    uv.push_back(std::max(0.0, y - line_height) * inv_h);
                     uv.push_back(0.0);
                     uv.push_back(y * inv_h);
                     uv.push_back(1.0);
                     uv.push_back(y * inv_h);
                     auto x1 = src_box.width / 2.0;
                     auto x2 = -(src_box.width / 2.0);
-                    auto y1 = -(std::min(src_box.height - i, line_height) / 2.0);
-                    auto y2 = std::min(src_box.height - i, line_height) / 2.0;
+                    auto y1 = -(std::min(src_box.height - i, (double)line_height) / 2.0);
+                    auto y2 = std::min(src_box.height - i, (double)line_height) / 2.0;
                     glm::vec4 v, r;
                     glm::mat4 m(1.0);
                     m =
@@ -202,13 +202,14 @@ class blinds_transformer : public wf::scene::view_2d_transformer_t
 
                     glm::mat4 p = glm::perspective(float(M_PI / 64.0), 1.0f, 0.1f, 100.0f);
                     glm::mat4 l = glm::lookAt(
-                        glm::vec3(0., 0., 1.0 / std::tan(float(M_PI / 64.0) / 2)),
+                        glm::vec3(0., 0., -1.0 / std::tan(float(M_PI / 64.0) / 2)),
                         glm::vec3(0., 0., 0.),
-                        glm::vec3(0., 1., 0.));
+                        glm::vec3(0., -1., 0.));
 
                     auto transform = p * l;
                     wf::auxilliary_buffer_t slice_buffer;
-                    slice_buffer.allocate({src_box.width + line_height * 2, static_cast<int32_t>(y2 - y1)});
+                    slice_buffer.allocate({static_cast<int32_t>(std::ceil(src_box.width + line_height * 2)),
+                        static_cast<int32_t>(std::ceil(y2 - y1))});
                     wf::gles::bind_render_buffer(slice_buffer.get_renderbuffer());
                     OpenGL::clear(wf::color_t{0.0, 0.0, 0.0, 0.0}, GL_COLOR_BUFFER_BIT);
                     self->program.use(wf::TEXTURE_TYPE_RGBA);
@@ -221,16 +222,17 @@ class blinds_transformer : public wf::scene::view_2d_transformer_t
                     wf::gles_texture_t slice_tex{slice_buffer.get_texture()};
 
                     wf::gles::bind_render_buffer(data.target);
-                    for (auto box : data.damage)
-                    {
-                        wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
-                        OpenGL::render_transformed_texture(slice_tex,
-                            gl_geometry{float(src_box.x - line_height),
-                                float(src_box.y + i),
-                                float((src_box.x - line_height) + src_box.width + line_height * 2.0),
-                                float((src_box.y + i) + (y2 - y1))}, {},
-                            wf::gles::render_target_orthographic_projection(data.target), glm::vec4(1.0), 0);
-                    }
+                    /* XXX: Scissoring wrong boxes here makes only top part of effect work */
+                    // for (auto box : data.damage)
+                    // {
+                    // wf::gles::render_target_logic_scissor(data.target, box);
+                    OpenGL::render_transformed_texture(slice_tex,
+                        gl_geometry{float(src_box.x - line_height),
+                            float(src_box.y + i),
+                            float((src_box.x - line_height) + src_box.width + line_height * 2.0),
+                            float((src_box.y + i) + (y2 - y1))}, {},
+                        wf::gles::render_target_orthographic_projection(data.target), glm::vec4(1.0), 0);
+                    // }
 
                     slice_buffer.free();
                 }
@@ -260,11 +262,6 @@ class blinds_transformer : public wf::scene::view_2d_transformer_t
         });
     }
 
-    wf::geometry_t get_bounding_box() override
-    {
-        return this->animation_geometry;
-    }
-
     wf::effect_hook_t pre_hook = [=] ()
     {
         output->render->damage(animation_geometry);
diff --git a/src/extra-animations/burn.hpp b/src/extra-animations/burn.hpp
index 7eadcbe..5fd8aaf 100644
--- a/src/extra-animations/burn.hpp
+++ b/src/extra-animations/burn.hpp
@@ -215,7 +215,7 @@ class burn_transformer : public wf::scene::view_2d_transformer_t
 
         void schedule_instructions(
             std::vector<render_instruction_t>& instructions,
-            const wf::render_target_t& target, wf::region_t& damage) override
+            const wf::render_target_t& target, wf::regionf_t& damage) override
         {
             instructions.push_back(render_instruction_t{
                         .instance = this,
@@ -224,7 +224,7 @@ class burn_transformer : public wf::scene::view_2d_transformer_t
                     });
         }
 
-        void transform_damage_region(wf::region_t& damage) override
+        void transform_damage_region(wf::regionf_t& damage) override
         {
             damage |= self->get_bounding_box();
         }
@@ -255,7 +255,7 @@ class burn_transformer : public wf::scene::view_2d_transformer_t
 
             data.pass->custom_gles_subpass([&]
             {
-                self->buffer.allocate({pbb.width, pbb.height});
+                self->buffer.allocate({int(pbb.width), int(pbb.height)});
                 wf::gles::bind_render_buffer(self->buffer.get_renderbuffer());
                 wf::gles_texture_t final_tex{self->buffer.get_texture()};
                 OpenGL::clear(wf::color_t{0.0, 0.0, 0.0, 0.0}, GL_COLOR_BUFFER_BIT);
@@ -307,7 +307,7 @@ class burn_transformer : public wf::scene::view_2d_transformer_t
                 wf::gles::bind_render_buffer(data.target);
                 for (auto box : data.damage)
                 {
-                    wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
+                    wf::gles::render_target_logic_scissor(data.target, box);
                     OpenGL::render_transformed_texture(final_tex, pbb,
                         wf::gles::render_target_orthographic_projection(data.target),
                         glm::vec4(1.0, 1.0, 1.0, std::clamp((progress - 0.07) * 10.0, 0.0, 1.0)), 0);
@@ -348,11 +348,6 @@ class burn_transformer : public wf::scene::view_2d_transformer_t
         return box;
     }
 
-    wf::geometry_t get_bounding_box() override
-    {
-        return get_padded_bounding_box();
-    }
-
     wf::effect_hook_t pre_hook = [=] ()
     {
         output->render->damage(this->get_bounding_box());
diff --git a/src/extra-animations/carpet.hpp b/src/extra-animations/carpet.hpp
index 8c4336c..1dde28d 100644
--- a/src/extra-animations/carpet.hpp
+++ b/src/extra-animations/carpet.hpp
@@ -384,7 +384,7 @@ class carpet_transformer : public wf::scene::view_2d_transformer_t
 
         void schedule_instructions(
             std::vector<render_instruction_t>& instructions,
-            const wf::render_target_t& target, wf::region_t& damage) override
+            const wf::render_target_t& target, wf::regionf_t& damage) override
         {
             instructions.push_back(render_instruction_t{
                         .instance = this,
@@ -393,7 +393,7 @@ class carpet_transformer : public wf::scene::view_2d_transformer_t
                     });
         }
 
-        void transform_damage_region(wf::region_t& damage) override
+        void transform_damage_region(wf::regionf_t& damage) override
         {
             damage |= self->get_bounding_box();
         }
@@ -424,7 +424,7 @@ class carpet_transformer : public wf::scene::view_2d_transformer_t
 
             data.pass->custom_gles_subpass([&]
             {
-                self->buffer.allocate({pbb.width, pbb.height});
+                self->buffer.allocate({int(pbb.width), int(pbb.height)});
                 wf::gles::bind_render_buffer(self->buffer.get_renderbuffer());
                 wf::gles_texture_t final_tex{self->buffer.get_texture()};
                 OpenGL::clear(wf::color_t{0.0, 0.0, 0.0, 0.0}, GL_COLOR_BUFFER_BIT);
@@ -440,7 +440,7 @@ class carpet_transformer : public wf::scene::view_2d_transformer_t
                 wf::gles::bind_render_buffer(data.target);
                 for (auto box : data.damage)
                 {
-                    wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
+                    wf::gles::render_target_logic_scissor(data.target, box);
                     OpenGL::render_transformed_texture(final_tex, pbb,
                         wf::gles::render_target_orthographic_projection(data.target),
                         glm::vec4(1.0, 1.0, 1.0, 1.0), 0);
@@ -481,11 +481,6 @@ class carpet_transformer : public wf::scene::view_2d_transformer_t
         return box;
     }
 
-    wf::geometry_t get_bounding_box() override
-    {
-        return get_padded_bounding_box();
-    }
-
     wf::effect_hook_t pre_hook = [=] ()
     {
         output->render->damage(this->get_bounding_box());
diff --git a/src/extra-animations/dodge.hpp b/src/extra-animations/dodge.hpp
index 48c5e13..ecc2574 100644
--- a/src/extra-animations/dodge.hpp
+++ b/src/extra-animations/dodge.hpp
@@ -362,8 +362,8 @@ class wayfire_dodge
 
     wf::pointf_t compute_direction(wf::geometry_t from_bb, wf::geometry_t to_bb)
     {
-        auto from_center = wf::point_t{from_bb.x + from_bb.width / 2, from_bb.y + from_bb.height / 2};
-        auto to_center   = wf::point_t{to_bb.x + to_bb.width / 2, to_bb.y + to_bb.height / 2};
+        auto from_center = wf::pointf_t{from_bb.x + from_bb.width / 2, from_bb.y + from_bb.height / 2};
+        auto to_center   = wf::pointf_t{to_bb.x + to_bb.width / 2, to_bb.y + to_bb.height / 2};
         auto x = double(from_center.x - to_center.x);
         auto y = double(from_center.y - to_center.y);
         auto m = magnitude(x, y);
diff --git a/src/extra-animations/helix.hpp b/src/extra-animations/helix.hpp
index 913b0eb..949f6c1 100644
--- a/src/extra-animations/helix.hpp
+++ b/src/extra-animations/helix.hpp
@@ -123,7 +123,7 @@ class helix_transformer : public wf::scene::view_2d_transformer_t
 
         void schedule_instructions(
             std::vector<render_instruction_t>& instructions,
-            const wf::render_target_t& target, wf::region_t& damage) override
+            const wf::render_target_t& target, wf::regionf_t& damage) override
         {
             instructions.push_back(render_instruction_t{
                         .instance = this,
@@ -132,9 +132,9 @@ class helix_transformer : public wf::scene::view_2d_transformer_t
                     });
         }
 
-        void transform_damage_region(wf::region_t& damage) override
+        void transform_damage_region(wf::regionf_t& damage) override
         {
-            damage |= wf::region_t{self->animation_geometry};
+            damage |= self->animation_geometry;
         }
 
         void render(const wf::scene::render_instruction_t& data) override
@@ -159,9 +159,9 @@ class helix_transformer : public wf::scene::view_2d_transformer_t
                 auto y     = src_box.height - i;
                 auto inv_h = 1.0 / src_box.height;
                 uv.push_back(0.0);
-                uv.push_back(std::max(0, y - line_height) * inv_h);
+                uv.push_back(std::max(0.0, y - line_height) * inv_h);
                 uv.push_back(1.0);
-                uv.push_back(std::max(0, y - line_height) * inv_h);
+                uv.push_back(std::max(0.0, y - line_height) * inv_h);
                 uv.push_back(0.0);
                 uv.push_back(y * inv_h);
                 uv.push_back(1.0);
@@ -169,7 +169,7 @@ class helix_transformer : public wf::scene::view_2d_transformer_t
                 uv.push_back(0.0);
                 uv.push_back(y * inv_h);
                 uv.push_back(1.0);
-                uv.push_back(std::max(0, y - line_height) * inv_h);
+                uv.push_back(std::max(0.0, y - line_height) * inv_h);
                 glm::vec4 v, r;
                 glm::mat4 m(1.0);
                 m = glm::rotate(m, float(M_PI), glm::vec3(1.0, 0.0, 0.0));
@@ -231,7 +231,7 @@ class helix_transformer : public wf::scene::view_2d_transformer_t
                 wf::gles::bind_render_buffer(data.target);
                 for (auto box : data.damage)
                 {
-                    wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
+                    wf::gles::render_target_logic_scissor(data.target, box);
                     self->program.use(wf::TEXTURE_TYPE_RGBA);
                     self->program.uniformMatrix4f("matrix", transform);
                     self->program.attrib_pointer("position", 3, 0, vertices.data());
@@ -261,11 +261,6 @@ class helix_transformer : public wf::scene::view_2d_transformer_t
         });
     }
 
-    wf::geometry_t get_bounding_box() override
-    {
-        return this->animation_geometry;
-    }
-
     wf::effect_hook_t pre_hook = [=] ()
     {
         output->render->damage(animation_geometry);
diff --git a/src/extra-animations/melt.hpp b/src/extra-animations/melt.hpp
index f9f1966..b5d0982 100644
--- a/src/extra-animations/melt.hpp
+++ b/src/extra-animations/melt.hpp
@@ -140,7 +140,7 @@ class melt_transformer : public wf::scene::view_2d_transformer_t
 
         void schedule_instructions(
             std::vector<render_instruction_t>& instructions,
-            const wf::render_target_t& target, wf::region_t& damage) override
+            const wf::render_target_t& target, wf::regionf_t& damage) override
         {
             instructions.push_back(render_instruction_t{
                         .instance = this,
@@ -149,7 +149,7 @@ class melt_transformer : public wf::scene::view_2d_transformer_t
                     });
         }
 
-        void transform_damage_region(wf::region_t& damage) override
+        void transform_damage_region(wf::regionf_t& damage) override
         {
             damage |= self->get_padded_bounding_box();
         }
@@ -180,7 +180,7 @@ class melt_transformer : public wf::scene::view_2d_transformer_t
 
             data.pass->custom_gles_subpass([&]
             {
-                self->buffer.allocate({pbb.width, pbb.height});
+                self->buffer.allocate({int(pbb.width), int(pbb.height)});
                 wf::gles::bind_render_buffer(self->buffer.get_renderbuffer());
                 wf::gles_texture_t final_tex{self->buffer.get_texture()};
                 OpenGL::clear(wf::color_t{0.0, 0.0, 0.0, 0.0}, GL_COLOR_BUFFER_BIT);
@@ -196,7 +196,7 @@ class melt_transformer : public wf::scene::view_2d_transformer_t
                 wf::gles::bind_render_buffer(data.target);
                 for (auto box : data.damage)
                 {
-                    wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
+                    wf::gles::render_target_logic_scissor(data.target, box);
                     OpenGL::render_transformed_texture(final_tex, pbb,
                         wf::gles::render_target_orthographic_projection(data.target),
                         glm::vec4(1.0, 1.0, 1.0, 1.0 / (1.0 + pow(2.718, -(progress * 15.0 - 3.0)))), 0);
@@ -240,11 +240,6 @@ class melt_transformer : public wf::scene::view_2d_transformer_t
         return box;
     }
 
-    wf::geometry_t get_bounding_box() override
-    {
-        return get_padded_bounding_box();
-    }
-
     wf::effect_hook_t pre_hook = [=] ()
     {
         output->render->damage(this->get_padded_bounding_box());
diff --git a/src/extra-animations/shatter.hpp b/src/extra-animations/shatter.hpp
index d7be81f..108a2e8 100644
--- a/src/extra-animations/shatter.hpp
+++ b/src/extra-animations/shatter.hpp
@@ -130,7 +130,7 @@ class shatter_transformer : public wf::scene::view_2d_transformer_t
 
         void schedule_instructions(
             std::vector<render_instruction_t>& instructions,
-            const wf::render_target_t& target, wf::region_t& damage) override
+            const wf::render_target_t& target, wf::regionf_t& damage) override
         {
             instructions.push_back(render_instruction_t{
                         .instance = this,
@@ -139,9 +139,9 @@ class shatter_transformer : public wf::scene::view_2d_transformer_t
                     });
         }
 
-        void transform_damage_region(wf::region_t& damage) override
+        void transform_damage_region(wf::regionf_t& damage) override
         {
-            damage |= wf::region_t{self->animation_geometry};
+            damage |= self->animation_geometry;
         }
 
         void render(const wf::scene::render_instruction_t& data) override
@@ -320,11 +320,6 @@ class shatter_transformer : public wf::scene::view_2d_transformer_t
         construct_voronoi(points.begin(), points.end(), &vd);
     }
 
-    wf::geometry_t get_bounding_box() override
-    {
-        return this->animation_geometry;
-    }
-
     wf::effect_hook_t pre_hook = [=] ()
     {
         output->render->damage(animation_geometry);
diff --git a/src/extra-animations/vortex.hpp b/src/extra-animations/vortex.hpp
index 883e784..b450e4f 100644
--- a/src/extra-animations/vortex.hpp
+++ b/src/extra-animations/vortex.hpp
@@ -148,7 +148,7 @@ class vortex_transformer : public wf::scene::view_2d_transformer_t
 
         void schedule_instructions(
             std::vector<render_instruction_t>& instructions,
-            const wf::render_target_t& target, wf::region_t& damage) override
+            const wf::render_target_t& target, wf::regionf_t& damage) override
         {
             instructions.push_back(render_instruction_t{
                         .instance = this,
@@ -157,9 +157,9 @@ class vortex_transformer : public wf::scene::view_2d_transformer_t
                     });
         }
 
-        void transform_damage_region(wf::region_t& damage) override
+        void transform_damage_region(wf::regionf_t& damage) override
         {
-            damage |= wf::region_t{self->animation_geometry};
+            damage |= self->animation_geometry;
         }
 
         void render(const wf::scene::render_instruction_t& data) override
@@ -176,13 +176,13 @@ class vortex_transformer : public wf::scene::view_2d_transformer_t
             };
 
             const float vertex_data_pos[] = {
-                1.0f * src_box.x,
-                1.0f * src_box.y + src_box.height,
-                1.0f * src_box.x + src_box.width,
-                1.0f * src_box.y + src_box.height,
-                1.0f * src_box.x + src_box.width,
-                1.0f * src_box.y,
-                1.0f * src_box.x, 1.0f * src_box.y,
+                (float)src_box.x,
+                (float)src_box.y + (float)src_box.height,
+                (float)src_box.x + (float)src_box.width,
+                (float)src_box.y + (float)src_box.height,
+                (float)src_box.x + (float)src_box.width,
+                (float)src_box.y,
+                (float)src_box.x, (float)src_box.y,
             };
 
             data.pass->custom_gles_subpass([&]
@@ -218,11 +218,6 @@ class vortex_transformer : public wf::scene::view_2d_transformer_t
         });
     }
 
-    wf::geometry_t get_bounding_box() override
-    {
-        return this->animation_geometry;
-    }
-
     wf::effect_hook_t pre_hook = [=] ()
     {
         output->render->damage(animation_geometry);
diff --git a/src/fisheye.cpp b/src/fisheye.cpp
index c3d2ac3..b3da65a 100644
--- a/src/fisheye.cpp
+++ b/src/fisheye.cpp
@@ -171,12 +171,12 @@ class wayfire_fisheye : public wf::per_output_plugin_instance_t
     wf::post_hook_t render_hook = [=] (wf::auxilliary_buffer_t& source,
                                        const wf::render_buffer_t& dest)
     {
-        auto oc     = output->get_cursor_position();
-        wlr_box box = {(int)oc.x, (int)oc.y, 1, 1};
-        box = output->render->get_target_framebuffer().
+        auto oc = output->get_cursor_position();
+        wf::geometry_t box = {oc.x, oc.y, 1, 1};
+        auto fb_box = output->render->get_target_framebuffer().
             framebuffer_box_from_geometry_box(box);
-        oc.x = box.x;
-        oc.y = box.y;
+        oc.x = fb_box.x;
+        oc.y = fb_box.y;
 
         static const float vertexData[] = {
             -1.0f, -1.0f,
diff --git a/src/follow-focus.cpp b/src/follow-focus.cpp
index b32acc7..e67cc73 100644
--- a/src/follow-focus.cpp
+++ b/src/follow-focus.cpp
@@ -43,7 +43,7 @@ class wayfire_follow_focus : public wf::per_output_plugin_instance_t
   private:
     wayfire_view focus_view = nullptr;
     wf::wl_timer<false> change_output_focus, change_view_focus;
-    wf::point_t last_output_coords, last_view_coords;
+    wf::pointf_t last_output_coords, last_view_coords;
 
     wf::option_wrapper_t<bool> should_change_view{"follow-focus/change_view"};
     wf::option_wrapper_t<bool> should_change_output{"follow-focus/change_output"};
@@ -67,7 +67,7 @@ class wayfire_follow_focus : public wf::per_output_plugin_instance_t
     void change_output()
     {
         auto cpf = wf::get_core().get_cursor_position();
-        wf::point_t coords{static_cast<int>(cpf.x), static_cast<int>(cpf.y)};
+        wf::pointf_t coords{cpf.x, cpf.y};
 
         if (output->get_layout_geometry() & coords && (output == focus_output))
         {
@@ -90,7 +90,7 @@ class wayfire_follow_focus : public wf::per_output_plugin_instance_t
         }
 
         auto cpf = wf::get_core().get_cursor_position();
-        wf::point_t coords{static_cast<int>(cpf.x), static_cast<int>(cpf.y)};
+        wf::pointf_t coords{cpf.x, cpf.y};
 
         if (output->get_layout_geometry() & coords && (output != focus_output))
         {
@@ -98,7 +98,7 @@ class wayfire_follow_focus : public wf::per_output_plugin_instance_t
             focus_output = output;
         }
 
-        if (abs(coords - last_output_coords) < threshold)
+        if (wf::abs(coords - last_output_coords) < threshold)
         {
             return;
         }
@@ -142,14 +142,14 @@ class wayfire_follow_focus : public wf::per_output_plugin_instance_t
         }
 
         auto cpf = wf::get_core().get_cursor_position();
-        wf::point_t coords{static_cast<int>(cpf.x), static_cast<int>(cpf.y)};
+        wf::pointf_t coords{cpf.x, cpf.y};
         if (view != focus_view)
         {
             last_view_coords = coords;
             focus_view = view;
         }
 
-        if (abs(coords - last_view_coords) < threshold)
+        if (wf::abs(coords - last_view_coords) < threshold)
         {
             return;
         }
diff --git a/src/force-fullscreen.cpp b/src/force-fullscreen.cpp
index f86e609..ed22f83 100644
--- a/src/force-fullscreen.cpp
+++ b/src/force-fullscreen.cpp
@@ -55,21 +55,18 @@ class simple_node_render_instance_t : public render_instance_t
     node_t *self;
     wayfire_toplevel_view view;
     damage_callback push_to_parent;
-    int *x, *y, *w, *h;
-    wlr_box *transparent_box;
+    wf::geometry_t *geometry;
+    wf::geometry_t *transparent_box;
     wf::option_wrapper_t<bool> transparent_behind_views{
         "force-fullscreen/transparent_behind_views"};
 
   public:
     simple_node_render_instance_t(node_t *self, damage_callback push_damage,
-        wayfire_toplevel_view view, int *x, int *y, int *w, int *h, wlr_box *transparent_box)
+        wayfire_toplevel_view view, wf::geometry_t *geometry, wf::geometry_t *transparent_box)
     {
-        this->x    = x;
-        this->y    = y;
-        this->w    = w;
-        this->h    = h;
-        this->self = self;
-        this->view = view;
+        this->geometry = geometry;
+        this->self     = self;
+        this->view     = view;
         this->transparent_box = transparent_box;
         this->push_to_parent  = push_damage;
         self->connect(&on_node_damaged);
@@ -77,7 +74,7 @@ class simple_node_render_instance_t : public render_instance_t
 
     void schedule_instructions(
         std::vector<render_instruction_t>& instructions,
-        const wf::render_target_t& target, wf::region_t& damage) override
+        const wf::render_target_t& target, wf::regionf_t& damage) override
     {
         // We want to render ourselves only, the node does not have children
         instructions.push_back(render_instruction_t{
@@ -96,7 +93,7 @@ class simple_node_render_instance_t : public render_instance_t
             return;
         }
 
-        wf::region_t scissor_region{data.damage};
+        wf::regionf_t scissor_region{data.damage};
         if (transparent_behind_views)
         {
             auto bbox = *transparent_box;
@@ -104,7 +101,7 @@ class simple_node_render_instance_t : public render_instance_t
             bbox.y     += 1;
             bbox.width -= 2;
             bbox.height    -= 2;
-            scissor_region ^= wf::region_t{bbox};
+            scissor_region ^= wf::regionf_t{bbox};
         }
 
         data.pass->clear(scissor_region, {0, 0, 0, 1});
@@ -114,18 +111,18 @@ class simple_node_render_instance_t : public render_instance_t
 class black_border_node_t : public node_t
 {
     wayfire_toplevel_view view;
-    wlr_box transparent_box;
+    wf::geometry_t transparent_box;
 
   public:
-    int x, y, w, h;
+    wf::geometry_t geometry;
 
     black_border_node_t(wayfire_toplevel_view view, int x, int y, int w,
-        int h, wlr_box transparent_box) : node_t(false)
+        int h, wf::geometry_t transparent_box) : node_t(false)
     {
-        this->x    = x;
-        this->y    = y;
-        this->w    = w;
-        this->h    = h;
+        this->geometry.x     = x;
+        this->geometry.y     = y;
+        this->geometry.width = w;
+        this->geometry.height = h;
         this->view = view;
         this->transparent_box = transparent_box;
     }
@@ -138,13 +135,13 @@ class black_border_node_t : public node_t
         // this simple nodes does not need any transformations, so the push_damage
         // callback is just passed along.
         instances.push_back(std::make_unique<simple_node_render_instance_t>(
-            this, push_damage, view, &x, &y, &w, &h, &transparent_box));
+            this, push_damage, view, &geometry, &transparent_box));
     }
 
     wf::geometry_t get_bounding_box() override
     {
         // Specify whatever geometry your node has
-        return {x, y, w, h};
+        return geometry;
     }
 };
 
@@ -156,7 +153,7 @@ class fullscreen_background
     std::shared_ptr<wf::scene::view_2d_transformer_t> transformer;
     std::shared_ptr<black_border_node_t> black_border_node;
     bool black_border = false;
-    wlr_box transformed_view_box;
+    wf::geometry_t transformed_view_box;
 
     fullscreen_background(wayfire_toplevel_view view)
     {}
@@ -216,11 +213,11 @@ class wayfire_force_fullscreen : public wf::per_output_plugin_instance_t
                 int x = offset.x * og.width;
                 int y = offset.y * og.height;
                 b.second->transformed_view_box.x = x + w;
-                b.second->black_border_node->x   = x;
-                b.second->black_border_node->y   = y;
-                b.second->black_border_node->w   = og.width;
-                b.second->black_border_node->h   = og.height;
-                b.second->transformed_view_box.y = b.second->black_border_node->y =
+                b.second->black_border_node->geometry.x     = x;
+                b.second->black_border_node->geometry.y     = y;
+                b.second->black_border_node->geometry.width = og.width;
+                b.second->black_border_node->geometry.height = og.height;
+                b.second->transformed_view_box.y = b.second->black_border_node->geometry.y =
                     y;
             }
 
@@ -228,7 +225,7 @@ class wayfire_force_fullscreen : public wf::per_output_plugin_instance_t
         }
     };
 
-    void ensure_subsurface(wayfire_toplevel_view view, wlr_box transformed_view_box)
+    void ensure_subsurface(wayfire_toplevel_view view, wf::geometry_t transformed_view_box)
     {
         auto pair = backgrounds.find(view);
 
@@ -289,7 +286,7 @@ class wayfire_force_fullscreen : public wf::per_output_plugin_instance_t
             scale_x = scale_y = std::min(scale_x, scale_y);
         }
 
-        wlr_box box;
+        wf::geometry_t box;
         box.width  = std::floor(vg.width * scale_x);
         box.height = std::floor(vg.height * scale_y);
         box.x = std::ceil((og.width - box.width) / 2.0);
@@ -332,7 +329,7 @@ class wayfire_force_fullscreen : public wf::per_output_plugin_instance_t
             return false;
         }
 
-        wlr_box saved_geometry = view->get_geometry();
+        wf::geometry_t saved_geometry = view->get_geometry();
 
         auto background = backgrounds.find(view);
         bool fullscreen = background == backgrounds.end() ? true : false;
@@ -340,7 +337,7 @@ class wayfire_force_fullscreen : public wf::per_output_plugin_instance_t
         view->toplevel()->pending().fullscreen = fullscreen;
         wf::get_core().tx_manager->schedule_object(view->toplevel());
 
-        wlr_box undecorated_geometry = view->get_geometry();
+        wf::geometry_t undecorated_geometry = view->get_geometry();
 
         if (!fullscreen)
         {
@@ -505,7 +502,7 @@ class wayfire_force_fullscreen : public wf::per_output_plugin_instance_t
         for (auto& b : backgrounds)
         {
             auto view = wf::get_active_view_for_output(output);
-            wlr_box box;
+            wf::geometry_t box;
 
             box    = b.second->transformed_view_box;
             box.x += og.x;
@@ -519,7 +516,8 @@ class wayfire_force_fullscreen : public wf::per_output_plugin_instance_t
             if ((b.first == view) &&
                 !(box & wf::pointf_t{cursor.x, cursor.y}))
             {
-                wlr_box_closest_point(&box, cursor.x, cursor.y,
+                auto ibox = wf::to_integer_box(box);
+                wlr_box_closest_point(&ibox, cursor.x, cursor.y,
                     &cursor.x, &cursor.y);
                 ev->event->delta_x = ev->event->unaccel_dx =
                     cursor.x - last_cursor.x;
diff --git a/src/keycolor.cpp b/src/keycolor.cpp
index 033557a..277c4a0 100644
--- a/src/keycolor.cpp
+++ b/src/keycolor.cpp
@@ -130,7 +130,7 @@ class simple_node_render_instance_t : public wf::scene::transformer_render_insta
 
     void schedule_instructions(
         std::vector<render_instruction_t>& instructions,
-        const wf::render_target_t& target, wf::region_t& damage) override
+        const wf::render_target_t& target, wf::regionf_t& damage) override
     {
         // We want to render ourselves only, the node does not have children
         instructions.push_back(render_instruction_t{
@@ -196,7 +196,7 @@ class simple_node_render_instance_t : public wf::scene::transformer_render_insta
 
             for (const auto& box : data.damage)
             {
-                wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
+                wf::gles::render_target_logic_scissor(data.target, box);
                 GL_CALL(glDrawArrays(GL_TRIANGLE_FAN, 0, 4));
             }
 
diff --git a/src/mag.cpp b/src/mag.cpp
index ba7e711..fa7fb42 100644
--- a/src/mag.cpp
+++ b/src/mag.cpp
@@ -297,7 +297,7 @@ class wayfire_magnifier : public wf::per_output_plugin_instance_t
     {
         auto og = output->get_relative_geometry();
         float aspect = (float)og.width / og.height;
-        wf::geometry_t start_geometry = {100, 100, (int)(default_height * aspect), default_height};
+        wf::geometry_t start_geometry = {100, 100, default_height *aspect, (double)default_height};
         return start_geometry;
     }
 
@@ -345,7 +345,7 @@ class wayfire_magnifier : public wf::per_output_plugin_instance_t
             glm::translate(glm::mat4(1.0), glm::vec3(0.5, 0.5, 0.0)) *
             glm::scale(glm::mat4(1.0), glm::vec3{0.5, -0.5, 1.0}) * ortho;
 
-        glm::vec4 cursor = glm::vec4(cursor_position.x, cursor_position.y, 0.0, 1.0);
+        glm::vec4 cursor = glm::vec4((int)cursor_position.x, (int)cursor_position.y, 0.0, 1.0);
         cursor = cursor_transform * cursor;
 
         float x = cursor.x;
@@ -400,10 +400,10 @@ class wayfire_magnifier : public wf::per_output_plugin_instance_t
             zoom_box.y2  = 1.0;
         }
 
-        zoom_box.x1 *= width - 1;
-        zoom_box.x2 *= width - 1;
-        zoom_box.y1 *= height - 1;
-        zoom_box.y2 *= height - 1;
+        zoom_box.x1 *= width;
+        zoom_box.x2 *= width;
+        zoom_box.y1 *= height;
+        zoom_box.y2 *= height;
 
         /* Copy zoom_box part of the output to our own texture to be
          * read by the mag_view_t. */
diff --git a/src/obs.cpp b/src/obs.cpp
index 4d2498f..4499329 100644
--- a/src/obs.cpp
+++ b/src/obs.cpp
@@ -138,7 +138,7 @@ class wf_obs : public wf::scene::view_2d_transformer_t
         }
 
         void schedule_instructions(std::vector<render_instruction_t>& instructions,
-            const wf::render_target_t& target, wf::region_t& damage) override
+            const wf::render_target_t& target, wf::regionf_t& damage) override
         {
             // We want to render ourselves only, the node does not have children
             instructions.push_back(render_instruction_t{
@@ -190,7 +190,7 @@ class wf_obs : public wf::scene::view_2d_transformer_t
 
                 for (const auto& box : data.damage)
                 {
-                    wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
+                    wf::gles::render_target_logic_scissor(data.target, box);
                     OpenGL::render_transformed_texture(final_tex, view_box,
                         wf::gles::render_target_orthographic_projection(data.target),
                         glm::vec4(1.0), 0);
diff --git a/src/showrepaint.cpp b/src/showrepaint.cpp
index caa70ad..6619122 100644
--- a/src/showrepaint.cpp
+++ b/src/showrepaint.cpp
@@ -119,13 +119,13 @@ class wayfire_showrepaint : public wf::per_output_plugin_instance_t
     wf::effect_hook_t overlay_hook = [=] ()
     {
         auto target_fb = output->render->get_target_framebuffer();
-        wf::region_t swap_damage = target_fb.geometry_region_from_framebuffer_region(
+        wf::regionf_t swap_damage = target_fb.geometry_region_from_framebuffer_region(
             output->render->get_swap_damage());
 
-        wf::region_t scheduled_damage = output->render->get_scheduled_damage();
-        wf::region_t output_region{target_fb.geometry};
-        wf::region_t inverted_damage;
-        wf::region_t damage;
+        wf::regionf_t scheduled_damage = output->render->get_scheduled_damage();
+        wf::regionf_t output_region{target_fb.geometry};
+        wf::regionf_t inverted_damage;
+        wf::regionf_t damage;
 
         /* Show scheduled client damage. Scheduled damage is the client damage
          * in union with last frame client damage. If this region is empty, we
@@ -188,8 +188,8 @@ class wayfire_showrepaint : public wf::per_output_plugin_instance_t
          */
         auto target_fb = output->render->get_target_framebuffer();
         last_buffer.allocate(target_fb.get_size());
-        wlr_box full = wf::construct_box({0, 0}, target_fb.get_size());
-        last_buffer.get_renderbuffer().blit(target_fb, wf::geometry_to_fbox(full), full);
+        wf::geometry_t full = wf::construct_box({0, 0}, target_fb.get_size());
+        last_buffer.get_renderbuffer().blit(target_fb, full, full);
     };
 
     void fini() override
diff --git a/src/window-zoom.cpp b/src/window-zoom.cpp
index 56eee24..afd2186 100644
--- a/src/window-zoom.cpp
+++ b/src/window-zoom.cpp
@@ -60,14 +60,14 @@ class simple_node_render_instance_t : public transformer_render_instance_t<trans
     node_t *self;
     wayfire_toplevel_view view;
     float *scale_x, *scale_y;
-    wlr_box *transformed_view_geometry;
+    wf::geometry_t *transformed_view_geometry;
     damage_callback push_damage;
     wf::option_wrapper_t<bool> nearest_filtering{"winzoom/nearest_filtering"};
 
   public:
     simple_node_render_instance_t(transformer_base_node_t *self, damage_callback push_damage,
         wayfire_toplevel_view view, float *scale_x, float *scale_y,
-        wlr_box *transformed_view_geometry) :
+        wf::geometry_t *transformed_view_geometry) :
         transformer_render_instance_t<transformer_base_node_t>(self, push_damage,
             view->get_output())
     {
@@ -89,7 +89,7 @@ class simple_node_render_instance_t : public transformer_render_instance_t<trans
 
     void schedule_instructions(
         std::vector<render_instruction_t>& instructions,
-        const wf::render_target_t& target, wf::region_t& damage) override
+        const wf::render_target_t& target, wf::regionf_t& damage) override
     {
         // We want to render ourselves only, the node does not have children
         instructions.push_back(render_instruction_t{
@@ -99,16 +99,16 @@ class simple_node_render_instance_t : public transformer_render_instance_t<trans
                     });
     }
 
-    void transform_damage_region(wf::region_t& damage) override
+    void transform_damage_region(wf::regionf_t& damage) override
     {
         damage |= view->get_transformed_node()->get_children_bounding_box();
     }
 
-    wlr_box get_scaled_geometry()
+    wf::geometry_t get_scaled_geometry()
     {
         auto vg = view->get_geometry();
         auto midpoint = get_center(vg);
-        auto result   = wf::pointf_t{float(vg.x), float(vg.y)} - midpoint;
+        auto result   = wf::pointf_t{vg.x, vg.y} - midpoint;
         result.x *= *scale_x;
         result.y *= *scale_y;
         result   += midpoint;
@@ -131,7 +131,7 @@ class simple_node_render_instance_t : public transformer_render_instance_t<trans
 class winzoom_t : public view_2d_transformer_t
 {
     wayfire_toplevel_view view;
-    wlr_box transformed_view_geometry;
+    wf::geometry_t transformed_view_geometry;
 
   public:
     winzoom_t(wayfire_toplevel_view view) : view_2d_transformer_t(view)
diff --git a/src/workspace-names.cpp b/src/workspace-names.cpp
index 7522ebd..6243e34 100644
--- a/src/workspace-names.cpp
+++ b/src/workspace-names.cpp
@@ -91,7 +91,7 @@ class simple_node_render_instance_t : public render_instance_t
 
     void schedule_instructions(
         std::vector<render_instruction_t>& instructions,
-        const wf::render_target_t& target, wf::region_t& damage) override
+        const wf::render_target_t& target, wf::regionf_t& damage) override
     {
         // We want to render ourselves only, the node does not have children
         instructions.push_back(render_instruction_t{
@@ -113,7 +113,7 @@ class simple_node_render_instance_t : public render_instance_t
                 wf::gles::bind_render_buffer(data.target);
                 for (auto& box : data.damage)
                 {
-                    wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
+                    wf::gles::render_target_logic_scissor(data.target, box);
                     OpenGL::render_texture(wf::gles_texture_t{workspace->texture->get_texture()},
                         data.target, g, glm::vec4(1, 1, 1, *alpha_fade), 0);
                 }
@@ -157,7 +157,7 @@ class simple_node_t : public node_t
             this, push_damage, &offset, &alpha_fade, workspace));
     }
 
-    void do_push_damage(wf::region_t updated_region)
+    void do_push_damage(wf::regionf_t updated_region)
     {
         node_damage_signal ev;
         ev.region = updated_region;
@@ -250,8 +250,8 @@ class wayfire_workspace_names_output : public wf::per_output_plugin_instance_t
         {
             for (int y = 0; y < wsize.height; y++)
             {
-                workspaces[x][y] = add_simple_node(output, {x *og.width,
-                    y * og.height}, {x, y});
+                workspaces[x][y] = add_simple_node(output, {int(x * og.width),
+                    int(y * og.height)}, {x, y});
             }
         }
     }
@@ -573,7 +573,7 @@ class wayfire_workspace_names_output : public wf::per_output_plugin_instance_t
         {
             for (int y = 0; y < wsize.height; y++)
             {
-                workspaces[x][y]->set_offset({(x - nvp.x) * og.width, (y - nvp.y) * og.height});
+                workspaces[x][y]->set_offset({int((x - nvp.x) * og.width), int((y - nvp.y) * og.height)});
             }
         }