diff --git a/Cargo.lock b/Cargo.lock
index 9def7274ede4734aed953c69cdc43e3e4551d0a3..1af88f7e584cb62d20c4232e14cb019e143863e8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -766,9 +766,9 @@ dependencies = [
 
 [[package]]
 name = "gsk4"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53b3b9e8090acb325d08cde84b30fc29b963a75fbac93160e9c5a30d2b335742"
+checksum = "cc25855255120f294d874acd6eaf4fbed7ce1cdc550e2d8415ea57fafbe816d5"
 dependencies = [
  "cairo-rs",
  "gdk4",
@@ -781,9 +781,9 @@ dependencies = [
 
 [[package]]
 name = "gsk4-sys"
-version = "0.7.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0770d1ede7189092748c4ef5b6921264eb945fd2318a58e8f59dc273000810f8"
+checksum = "e1ecf3a63bf1223d68f80f72cc896c4d8c80482fbce1c9a12c66d3de7290ee46"
 dependencies = [
  "cairo-sys-rs",
  "gdk4-sys",
@@ -797,9 +797,9 @@ dependencies = [
 
 [[package]]
 name = "gtk4"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0973f9b9ade10fc22403810b7283d47b533033715f2aaa36288cd3bf90d63efc"
+checksum = "a3b095b26f2a2df70be1805d3590eeb9d7a05ecb5be9649b82defc72dc56228c"
 dependencies = [
  "cairo-rs",
  "field-offset",
@@ -832,9 +832,9 @@ dependencies = [
 
 [[package]]
 name = "gtk4-sys"
-version = "0.7.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19fde71ef2e78ac8fb18073c345b5f29609048d4045a345613645aa1163243c1"
+checksum = "7b0bdde87c50317b4f355bcbb4a9c2c414ece1b7c824fb4ad4ba8f3bdb2c6603"
 dependencies = [
  "cairo-sys-rs",
  "gdk-pixbuf-sys",
diff --git a/Cargo.toml b/Cargo.toml
index 665857946b67e4f470774b8477e9e171379dcdb1..1b824a5bec64b742de6ada1a2b10fa57749b0056 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,7 @@ ashpd = { version = "0.6.2", default-features = false, features = [
     "tokio",
 ] }
 gettext-rs = { version = "0.7", features = ["gettext-system"] }
-gtk = { version = "0.7", package = "gtk4", features = ["gnome_45"] }
+gtk = { version = "0.7.2", package = "gtk4", features = ["v4_14"] }
 indexmap = "2.0"
 pcap-file = "2.0.0"
 tokio = { version = "1.0", default-features = false, features = [
diff --git a/data/resources/ui/diagram_view.ui b/data/resources/ui/diagram_view.ui
index b22adff271570372b50686a57fa08cd5113dd2d0..9167b3a12797654840d29a342f831a72dfb84e33 100644
--- a/data/resources/ui/diagram_view.ui
+++ b/data/resources/ui/diagram_view.ui
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
   <template class="BustleDiagramView">
+    <property name="overflow">hidden</property>
     <child>
       <object class="GtkListView" id="list_view">
         <property name="factory">
diff --git a/src/diagram/header.rs b/src/diagram/header.rs
index 379159c6980d7f318a458e840cf3b6f8873ef776..0d72d0ad87f4909c5b9dfd7d84cd6c0d1049f5e9 100644
--- a/src/diagram/header.rs
+++ b/src/diagram/header.rs
@@ -133,7 +133,7 @@ mod imp {
             for layout in obj.layouts().iter::<glib::Object>() {
                 let layout = layout.unwrap().downcast::<pango::Layout>().unwrap();
                 snapshot.save();
-                snapshot.translate(&Point::new(cursor_x as f32, TEXT_PADDING as f32));
+                snapshot.translate(&Point::new(cursor_x, TEXT_PADDING as f32));
                 snapshot.append_layout(&layout, &color);
                 snapshot.restore();
                 cursor_x += column_width;
@@ -247,7 +247,7 @@ impl Header {
             .expect("default layout was not set");
 
         let layout = default_layout.copy();
-        layout.set_width(pango::units_from_double(self.view().column_width()));
+        layout.set_width(pango::units_from_double(self.view().column_width() as f64));
         layout.set_markup(&text);
         layout
     }
diff --git a/src/diagram/view.rs b/src/diagram/view.rs
index b41a27a38c301fc455aec2d6bf5c11acd43c0362..2d8995b427a81ffe835fb4c7b61c392df97b62e7 100644
--- a/src/diagram/view.rs
+++ b/src/diagram/view.rs
@@ -1,8 +1,9 @@
 use anyhow::{Context, Result};
 use gtk::{
-    cairo, gdk,
+    gdk,
     glib::{self, clone},
     graphene::{Point, Rect},
+    gsk, pango,
     prelude::*,
     subclass::prelude::*,
 };
@@ -17,8 +18,8 @@ use crate::{
     RUNTIME,
 };
 
-const COLUMN_LINE_WIDTH: f64 = 1.0;
-const ARROW_LINE_WIDTH: f64 = 2.0;
+const COLUMN_LINE_WIDTH: f32 = 1.0;
+const ARROW_LINE_WIDTH: f32 = 2.0;
 
 /// Determines on what side the arc will curve
 enum ArcSide {
@@ -71,7 +72,9 @@ mod imp {
 
         pub(super) rows: RefCell<HashSet<Row>>,
         pub(super) row_width_request: Cell<i32>,
-        pub(super) distance_between_rows_center: Cell<Option<f64>>,
+        pub(super) distance_between_rows_center: Cell<Option<f32>>,
+
+        pub(super) response_time_layout: OnceCell<pango::Layout>,
 
         pub(super) text_scale_factor: Cell<f64>,
         pub(super) settings_portal_watch_handle: RefCell<Option<JoinHandle<()>>>,
@@ -104,6 +107,9 @@ mod imp {
             let obj = self.obj();
             obj.set_direction(gtk::TextDirection::Ltr);
 
+            let layout = obj.create_pango_layout(None);
+            self.response_time_layout.set(layout).unwrap();
+
             let (tx, rx) = glib::MainContext::channel(glib::Priority::default());
             rx.attach(
                 None,
@@ -145,15 +151,7 @@ mod imp {
                 return;
             };
 
-            let cr = snapshot.append_cairo(&Rect::new(
-                0.0,
-                0.0,
-                obj.width() as f32,
-                obj.height() as f32,
-            ));
-            cr.set_line_cap(cairo::LineCap::Round);
-
-            if let Err(err) = obj.draw_columns(&cr) {
+            if let Err(err) = obj.draw_columns(snapshot) {
                 tracing::warn!("Can't draw columns: {:?}", err);
             }
 
@@ -173,14 +171,14 @@ mod imp {
                         &Point::new(row.width() as f32 / 2.0, row.height() as f32 / 2.0),
                     )
                     .unwrap()
-                    .y() as f64;
+                    .y();
 
                 match message.message_type() {
                     MessageType::Invalid => {
                         tracing::debug!(%message, "Invalid message type, not drawing");
                     }
                     MessageType::MethodCall => {
-                        if let Err(err) = obj.draw_method_call(&cr, &message, row_center_y) {
+                        if let Err(err) = obj.draw_method_call(snapshot, &message, row_center_y) {
                             tracing::warn!(%message, "Can't draw method call: {:?}", err);
                         }
                     }
@@ -190,14 +188,18 @@ mod imp {
                             continue;
                         };
 
-                        if let Err(err) =
-                            obj.draw_method_return(&cr, &call_message, &message, row, row_center_y)
-                        {
+                        if let Err(err) = obj.draw_method_return(
+                            snapshot,
+                            &call_message,
+                            &message,
+                            row,
+                            row_center_y,
+                        ) {
                             tracing::warn!(%call_message, %message, "Can't draw method return: {:?}", err);
                         }
                     }
                     MessageType::Signal => {
-                        if let Err(err) = obj.draw_signal(&cr, &message, row_center_y) {
+                        if let Err(err) = obj.draw_signal(snapshot, &message, row_center_y) {
                             tracing::warn!(%message, "Can't draw signal: {:?}", err);
                         }
                     }
@@ -342,24 +344,24 @@ impl View {
             .set_selected(gtk::INVALID_LIST_POSITION);
     }
 
-    pub fn column_width(&self) -> f64 {
-        const COLUMN_WIDTH: f64 = 90.0;
+    pub fn column_width(&self) -> f32 {
+        const COLUMN_WIDTH: f32 = 90.0;
 
-        COLUMN_WIDTH * self.imp().text_scale_factor.get()
+        COLUMN_WIDTH * self.imp().text_scale_factor.get() as f32
     }
 
     /// Returns the x coordinate where columns start drawing, factoring the
     /// horizontal adjustment value
-    pub fn first_column_x(&self) -> f64 {
-        self.first_column_initial_x() - self.hadjustment().map_or(0.0, |hadj| hadj.value())
+    pub fn first_column_x(&self) -> f32 {
+        self.first_column_initial_x() - self.hadjustment().map_or(0.0, |hadj| hadj.value() as f32)
     }
 
     /// Returns the x coordinate where columns start drawing
-    fn first_column_initial_x(&self) -> f64 {
+    fn first_column_initial_x(&self) -> f32 {
         // This must be synced with DiagramRow label char widths
-        const FIRST_COLUMN_INITIAL_X: f64 = 600.0;
+        const FIRST_COLUMN_INITIAL_X: f32 = 600.0;
 
-        FIRST_COLUMN_INITIAL_X * self.imp().text_scale_factor.get()
+        FIRST_COLUMN_INITIAL_X * self.imp().text_scale_factor.get() as f32
     }
 
     fn header(&self) -> Header {
@@ -372,7 +374,7 @@ impl View {
     }
 
     /// Returns the x coordinate where the given name must be placed
-    fn x_for_name(&self, name: &BusName) -> Result<f64> {
+    fn x_for_name(&self, name: &BusName) -> Result<f32> {
         let model = self.model().context("No model found")?;
         let bus_names = model.filtered_bus_names();
 
@@ -405,7 +407,7 @@ impl View {
 
         let bus_name_index = bus_name_index.context("Name not found in bus names")?;
 
-        Ok(self.first_column_x() + self.column_width() * bus_name_index as f64)
+        Ok(self.first_column_x() + self.column_width() * bus_name_index as f32)
     }
 
     /// Computes the distance from row center to an adjacent row's center,
@@ -414,7 +416,7 @@ impl View {
     /// Returns None if there is no visible adjacent row
     ///
     /// This must be invalidated when the text scale factor changes
-    fn distance_between_rows_center(&self, row: &Row, row_center_y: f64) -> Option<f64> {
+    fn distance_between_rows_center(&self, row: &Row, row_center_y: f32) -> Option<f32> {
         // FIXME Don't have any better idea to compute distance between rows centers
 
         let imp = self.imp();
@@ -473,12 +475,24 @@ impl View {
                 ),
             )
             .unwrap()
-            .y() as f64;
+            .y();
         let ret = Some((adjacent_row_center_y - row_center_y).abs());
         imp.distance_between_rows_center.set(ret);
         ret
     }
 
+    fn bounds(&self) -> Rect {
+        Rect::new(0.0, 0.0, self.width() as f32, self.height() as f32)
+    }
+
+    // FIXME upstream some builder
+    fn arrow_stroke(&self) -> gsk::Stroke {
+        let stroke = gsk::Stroke::new(ARROW_LINE_WIDTH);
+        stroke.set_line_join(gsk::LineJoin::Round);
+        stroke.set_line_cap(gsk::LineCap::Round);
+        stroke
+    }
+
     fn error_arrow_color(&self) -> gdk::RGBA {
         match adw::StyleManager::default().color_scheme() {
             adw::ColorScheme::Default
@@ -511,7 +525,7 @@ impl View {
         }
     }
 
-    fn draw_columns(&self, cr: &cairo::Context) -> Result<()> {
+    fn draw_columns(&self, snapshot: &gtk::Snapshot) -> Result<()> {
         let color = self.color();
         let height = self.height();
 
@@ -521,32 +535,40 @@ impl View {
         let model = self.model().context("No model found")?;
         let bus_names = model.filtered_bus_names();
 
-        cr.set_line_width(COLUMN_LINE_WIDTH);
-        // TODO replace with `color.with_alpha(color.alpha() * 0.5)`
-        cr.set_source_color(&gdk::RGBA::new(
-            color.red(),
-            color.green(),
-            color.blue(),
-            color.alpha() * 0.3,
-        ));
+        let path_builder = gsk::PathBuilder::new();
 
         let mut cursor_x = first_column_x;
         for _ in bus_names.iter() {
             let x = cursor_x.round();
-            cr.move_to(x, 0.0);
-            cr.line_to(x, height as f64);
-            cr.stroke().unwrap();
+            path_builder.move_to(x, 0.0);
+            path_builder.line_to(x, height as f32);
             cursor_x += column_width;
         }
 
+        snapshot.push_stroke(
+            &path_builder.to_path(),
+            &gsk::Stroke::new(COLUMN_LINE_WIDTH),
+        );
+        // TODO replace with `color.with_alpha(color.alpha() * 0.5)`
+        snapshot.append_color(
+            &gdk::RGBA::new(
+                color.red(),
+                color.green(),
+                color.blue(),
+                color.alpha() * 0.3,
+            ),
+            &self.bounds(),
+        );
+        snapshot.pop();
+
         Ok(())
     }
 
     fn draw_method_call(
         &self,
-        cr: &cairo::Context,
+        snapshot: &gtk::Snapshot,
         message: &Message,
-        row_center_y: f64,
+        row_center_y: f32,
     ) -> Result<()> {
         let sender = message.sender().context("Call message has no sender")?;
         let destination = message
@@ -558,26 +580,28 @@ impl View {
         // FIXME This only fails somehow while recording and browsing randomly
         let end_x = self.x_for_name(&destination)?;
 
-        cr.set_line_width(ARROW_LINE_WIDTH);
-        cr.set_source_color(&self.color());
-        cr.draw_arrow(
-            (start_x, row_center_y),
-            (end_x, row_center_y),
+        let path_builder = gsk::PathBuilder::new();
+        path_builder.add_arrow(
+            &Point::new(start_x, row_center_y),
+            &Point::new(end_x, row_center_y),
             ArrowTipType::TopHalf,
         );
+        snapshot.push_stroke(&path_builder.to_path(), &self.arrow_stroke());
+        snapshot.append_color(&self.color(), &self.bounds());
+        snapshot.pop();
 
         Ok(())
     }
 
     fn draw_method_return(
         &self,
-        cr: &cairo::Context,
+        snapshot: &gtk::Snapshot,
         call_message: &Message,
         return_message: &Message,
         return_row: &Row,
-        return_row_center_y: f64,
+        return_row_center_y: f32,
     ) -> Result<()> {
-        const RESPONSE_TIME_OFFSET_X: f64 = 24.0;
+        const RESPONSE_TIME_LAYOUT_OFFSET_X: f32 = 20.0;
 
         let model = self.model().context("No model found")?;
 
@@ -619,19 +643,20 @@ impl View {
         let start_x = self.x_for_name(&BusName::from(return_message_sender))?;
         let end_x = self.x_for_name(&BusName::from(call_message_sender))?;
 
-        cr.set_line_width(ARROW_LINE_WIDTH);
-
-        if return_message.message_type() == MessageType::Error {
-            cr.set_source_color(&self.error_arrow_color());
-        } else {
-            cr.set_source_color(&self.color());
-        }
-
-        cr.draw_arrow(
-            (start_x, return_row_center_y),
-            (end_x, return_row_center_y),
+        let arrow_path_builder = gsk::PathBuilder::new();
+        arrow_path_builder.add_arrow(
+            &Point::new(start_x, return_row_center_y),
+            &Point::new(end_x, return_row_center_y),
             ArrowTipType::BottomHalf,
         );
+        let arrow_color = if return_message.message_type() == MessageType::Error {
+            self.error_arrow_color()
+        } else {
+            self.color()
+        };
+        snapshot.push_stroke(&arrow_path_builder.to_path(), &self.arrow_stroke());
+        snapshot.append_color(&arrow_color, &self.bounds());
+        snapshot.pop();
 
         let call_row_center_y = {
             let return_message_index = return_row.list_position();
@@ -648,69 +673,86 @@ impl View {
             let other_row_offset_y = self
                 .distance_between_rows_center(return_row, return_row_center_y)
                 .unwrap()
-                * (return_message_index as f64 - call_message_index as f64);
+                * (return_message_index as f32 - call_message_index as f32);
             return_row_center_y - other_row_offset_y
         };
 
         // TODO draw this arc as long as the rows in the middle of call and return
         // row is visible
-        cr.set_source_color(&self.method_arc_color());
-        cr.set_dash(&[3.0, 3.0], 0.0);
-        cr.draw_method_arc(
-            (start_x, return_row_center_y),
-            (start_x, call_row_center_y),
+        let arc_path_builder = gsk::PathBuilder::new();
+        arc_path_builder.add_arc(
+            &Point::new(start_x, return_row_center_y),
+            &Point::new(start_x, call_row_center_y),
             if (end_x - start_x).is_sign_positive() {
                 ArcSide::Left
             } else {
                 ArcSide::Right
             },
         );
-
-        cr.set_source_color(&self.color());
-        cr.set_dash(&[], 0.0);
-        let response_time_text = format!(
-            "{} ms",
+        let arc_stroke = gsk::Stroke::new(ARROW_LINE_WIDTH);
+        arc_stroke.set_dash(&[3.0, 3.0]);
+        snapshot.push_stroke(&arc_path_builder.to_path(), &arc_stroke);
+        snapshot.append_color(&self.method_arc_color(), &self.bounds());
+        snapshot.pop();
+
+        let response_time_layout = self
+            .imp()
+            .response_time_layout
+            .get()
+            .expect("response time layout must be set on construcetd");
+        response_time_layout.set_markup(&format!(
+            r#"<span size="x-small">{} ms</span>"#,
             (return_message.timestamp() - call_message.timestamp())
                 .as_millis_f64()
                 .round()
-        );
+        ));
+        let (ink_extents, _) = response_time_layout.pixel_extents();
+
+        snapshot.save();
         if (end_x - start_x).is_sign_positive() {
-            let response_time_text_extents = cr.text_extents(&response_time_text).unwrap();
-            cr.move_to(
-                start_x - RESPONSE_TIME_OFFSET_X - response_time_text_extents.width(),
-                return_row_center_y,
-            );
+            snapshot.translate(&Point::new(
+                start_x - RESPONSE_TIME_LAYOUT_OFFSET_X - ink_extents.width() as f32,
+                return_row_center_y - ink_extents.height() as f32,
+            ));
         } else {
-            cr.move_to(start_x + RESPONSE_TIME_OFFSET_X, return_row_center_y);
+            snapshot.translate(&Point::new(
+                start_x + RESPONSE_TIME_LAYOUT_OFFSET_X,
+                return_row_center_y - ink_extents.height() as f32,
+            ));
         }
-        cr.show_text(&response_time_text).unwrap();
+        snapshot.append_layout(response_time_layout, &self.color());
+        snapshot.restore();
 
         Ok(())
     }
 
-    fn draw_signal(&self, cr: &cairo::Context, message: &Message, row_center_y: f64) -> Result<()> {
-        const CIRCLE_RADIUS: f64 = 5.0;
-        const ARROW_END_OFFSET: f64 = 20.0;
+    fn draw_signal(
+        &self,
+        snapshot: &gtk::Snapshot,
+        message: &Message,
+        row_center_y: f32,
+    ) -> Result<()> {
+        const CIRCLE_RADIUS: f32 = 5.0;
+        const ARROW_END_OFFSET: f32 = 20.0;
 
         let sender = message.sender().context("Signal message has no sender")?;
         let start_x = self.x_for_name(&BusName::from(sender))?;
 
-        cr.set_line_width(ARROW_LINE_WIDTH);
-        cr.set_source_color(&self.color());
+        let path_builder = gsk::PathBuilder::new();
 
-        cr.draw_circle((start_x, row_center_y), CIRCLE_RADIUS);
+        path_builder.add_circle(&Point::new(start_x, row_center_y), CIRCLE_RADIUS);
 
         if let Some(destination) = message.destination() {
             // This is a targeted signal
 
             let end_x = self.x_for_name(&destination)?;
 
-            cr.draw_arrow(
-                (
+            path_builder.add_arrow(
+                &Point::new(
                     start_x + negate_if((end_x - start_x).is_sign_negative(), CIRCLE_RADIUS),
                     row_center_y,
                 ),
-                (end_x, row_center_y),
+                &Point::new(end_x, row_center_y),
                 ArrowTipType::Full,
             );
         } else {
@@ -723,18 +765,18 @@ impl View {
             // FIXME Is this correct that the arrows extend on all columns/names?
 
             // Left arrow
-            cr.draw_arrow(
-                (start_x - CIRCLE_RADIUS, row_center_y),
-                (first_column_x - ARROW_END_OFFSET, row_center_y),
+            path_builder.add_arrow(
+                &Point::new(start_x - CIRCLE_RADIUS, row_center_y),
+                &Point::new(first_column_x - ARROW_END_OFFSET, row_center_y),
                 ArrowTipType::Full,
             );
 
             // Right arrow
-            cr.draw_arrow(
-                (start_x + CIRCLE_RADIUS, row_center_y),
-                (
+            path_builder.add_arrow(
+                &Point::new(start_x + CIRCLE_RADIUS, row_center_y),
+                &Point::new(
                     first_column_x
-                        + column_width * (bus_names.n_items() - 1) as f64
+                        + column_width * (bus_names.n_items() - 1) as f32
                         + ARROW_END_OFFSET,
                     row_center_y,
                 ),
@@ -742,6 +784,10 @@ impl View {
             );
         }
 
+        snapshot.push_stroke(&path_builder.to_path(), &self.arrow_stroke());
+        snapshot.append_color(&self.color(), &self.bounds());
+        snapshot.pop();
+
         Ok(())
     }
 
@@ -771,7 +817,7 @@ impl View {
             -1
         } else {
             let column_width = self.column_width();
-            (self.first_column_initial_x() + column_width * n_bus_names as f64 - column_width / 2.0)
+            (self.first_column_initial_x() + column_width * n_bus_names as f32 - column_width / 2.0)
                 .round() as i32
         };
         imp.row_width_request.set(new_value);
@@ -844,7 +890,7 @@ impl View {
     }
 }
 
-fn negate_if(negate: bool, num: f64) -> f64 {
+fn negate_if(negate: bool, num: f32) -> f32 {
     if negate {
         -num
     } else {
@@ -852,10 +898,6 @@ fn negate_if(negate: bool, num: f64) -> f64 {
     }
 }
 
-fn midpoint(a: (f64, f64), b: (f64, f64)) -> (f64, f64) {
-    ((a.0 + b.0) / 2.0, (a.1 + b.1) / 2.0)
-}
-
 /// Runs a settings watch on the text scaling factor setting and sends the new
 /// value
 ///
@@ -896,34 +938,25 @@ async fn run_settings_portal_watch(tx: glib::Sender<f64>) -> Result<()> {
     Ok(())
 }
 
-trait CairoContextExt {
-    /// Helper method to avoid having to qualify
-    /// `GdkCairoContextExt::set_source_rgba` due to a conflict with
-    /// `Context::set_source_rgba`
-    fn set_source_color(&self, color: &gdk::RGBA);
-    fn draw_arrow(&self, start: (f64, f64), end: (f64, f64), tip_type: ArrowTipType);
-    fn draw_circle(&self, center: (f64, f64), radius: f64);
-    fn draw_method_arc(&self, start: (f64, f64), end: (f64, f64), arc_side: ArcSide);
+trait PathBuilderExt {
+    fn add_arrow(&self, start: &Point, end: &Point, tip_type: ArrowTipType);
+    fn add_arc(&self, start: &Point, end: &Point, arc_side: ArcSide);
 }
 
-impl CairoContextExt for cairo::Context {
-    fn set_source_color(&self, color: &gdk::RGBA) {
-        GdkCairoContextExt::set_source_rgba(self, color);
-    }
-
-    fn draw_arrow(&self, start: (f64, f64), end: (f64, f64), tip_type: ArrowTipType) {
-        const TIP_OFFSET_X: f64 = 10.0;
-        const TIP_OFFSET_Y: f64 = 5.0;
+impl PathBuilderExt for gsk::PathBuilder {
+    fn add_arrow(&self, start: &Point, end: &Point, tip_type: ArrowTipType) {
+        const TIP_OFFSET_X: f32 = 10.0;
+        const TIP_OFFSET_Y: f32 = 5.0;
 
-        self.move_to(start.0, start.1);
-        self.line_to(end.0, end.1);
+        self.move_to(start.x(), start.y());
+        self.line_to(end.x(), end.y());
 
-        let tip_offset_x = negate_if((end.0 - start.0).is_sign_positive(), TIP_OFFSET_X);
+        let tip_offset_x = negate_if((end.x() - start.x()).is_sign_positive(), TIP_OFFSET_X);
 
         match tip_type {
             ArrowTipType::Full => {
                 self.rel_move_to(tip_offset_x, -TIP_OFFSET_Y);
-                self.line_to(end.0, end.1);
+                self.line_to(end.x(), end.y());
                 self.rel_line_to(tip_offset_x, TIP_OFFSET_Y);
             }
             ArrowTipType::TopHalf => {
@@ -933,30 +966,20 @@ impl CairoContextExt for cairo::Context {
                 self.rel_line_to(tip_offset_x, TIP_OFFSET_Y);
             }
         }
-
-        self.stroke().unwrap();
-    }
-
-    fn draw_circle(&self, center: (f64, f64), radius: f64) {
-        self.move_to(center.0 + radius, center.1);
-        self.arc(center.0, center.1, radius, 0.0, std::f64::consts::TAU);
-        self.stroke().unwrap();
     }
 
-    fn draw_method_arc(&self, start: (f64, f64), end: (f64, f64), arc_side: ArcSide) {
-        const MID_OFFSET_X: f64 = 50.0;
+    fn add_arc(&self, start: &Point, end: &Point, arc_side: ArcSide) {
+        const MID_OFFSET_X: f32 = 50.0;
 
-        let (mid_x, mid_y) = midpoint(start, end);
+        let mid_x = (start.x() + end.x()) / 2.0;
+        let mid_y = (start.y() + end.y()) / 2.0;
 
-        self.move_to(start.0, start.1);
-        self.curve_to(
-            start.0,
-            start.1,
+        self.move_to(start.x(), start.y());
+        self.quad_to(
             mid_x + negate_if(matches!(arc_side, ArcSide::Left), MID_OFFSET_X),
             mid_y,
-            end.0,
-            end.1,
+            end.x(),
+            end.y(),
         );
-        self.stroke().unwrap();
     }
 }