From c154553aad9398621986e55de9019d63bb30adf9 Mon Sep 17 00:00:00 2001
From: Fred Sundvik <fsundvik@gmail.com>
Date: Fri, 12 Apr 2024 23:28:51 +0300
Subject: [PATCH] Use typesafe grid and pixel units

---
 src/bridge/mod.rs                          |  10 +-
 src/dimensions.rs                          |  19 ---
 src/main.rs                                |   1 +
 src/renderer/animation_utils.rs            |  68 ++++----
 src/renderer/cursor_renderer/cursor_vfx.rs |  96 +++++------
 src/renderer/cursor_renderer/mod.rs        | 115 ++++++--------
 src/renderer/fonts/caching_shaper.rs       |  34 ++--
 src/renderer/grid_renderer.rs              | 107 +++++--------
 src/renderer/mod.rs                        |  43 +++--
 src/renderer/rendered_window.rs            | 164 +++++++++----------
 src/settings/mod.rs                        |   4 +-
 src/settings/window_size.rs                |  25 ++-
 src/units.rs                               | 109 +++++++++++++
 src/window/mod.rs                          |  13 +-
 src/window/mouse_manager.rs                | 176 ++++++++-------------
 src/window/window_wrapper.rs               | 139 ++++++++--------
 16 files changed, 555 insertions(+), 568 deletions(-)
 create mode 100644 src/units.rs

diff --git a/src/bridge/mod.rs b/src/bridge/mod.rs
index 894f991d9f..1038e36a69 100644
--- a/src/bridge/mod.rs
+++ b/src/bridge/mod.rs
@@ -17,8 +17,8 @@ use tokio::runtime::{Builder, Runtime};
 use winit::event_loop::EventLoopProxy;
 
 use crate::{
-    cmd_line::CmdLineSettings, dimensions::Dimensions, editor::start_editor, running_tracker::*,
-    settings::*, window::UserEvent,
+    cmd_line::CmdLineSettings, editor::start_editor, running_tracker::*, settings::*,
+    units::GridSize, window::UserEvent,
 };
 pub use handler::NeovimHandler;
 use session::{NeovimInstance, NeovimSession};
@@ -169,7 +169,7 @@ pub async fn show_error_message(
     nvim.echo(prepared_lines, true, vec![]).await
 }
 
-async fn launch(handler: NeovimHandler, grid_size: Option<Dimensions>) -> Result<NeovimSession> {
+async fn launch(handler: NeovimHandler, grid_size: Option<GridSize<u32>>) -> Result<NeovimSession> {
     let neovim_instance = neovim_instance()?;
 
     let session = NeovimSession::new(neovim_instance, handler)
@@ -215,7 +215,7 @@ async fn launch(handler: NeovimHandler, grid_size: Option<Dimensions>) -> Result
 
     // Triggers loading the user config
 
-    let grid_size = grid_size.map_or(DEFAULT_GRID_SIZE, |v| v.clamped_grid_size());
+    let grid_size = grid_size.map_or(DEFAULT_GRID_SIZE, |v| clamped_grid_size(&v));
     let res = session
         .neovim
         .ui_attach(grid_size.width as i64, grid_size.height as i64, &options)
@@ -251,7 +251,7 @@ impl NeovimRuntime {
     pub fn launch(
         &mut self,
         event_loop_proxy: EventLoopProxy<UserEvent>,
-        grid_size: Option<Dimensions>,
+        grid_size: Option<GridSize<u32>>,
     ) -> Result<()> {
         let handler = start_editor(event_loop_proxy);
         let runtime = self.runtime.as_ref().unwrap();
diff --git a/src/dimensions.rs b/src/dimensions.rs
index 8a236cab72..8509e6d926 100644
--- a/src/dimensions.rs
+++ b/src/dimensions.rs
@@ -7,8 +7,6 @@ use std::{
 use serde::{Deserialize, Serialize};
 use winit::dpi::PhysicalSize;
 
-use crate::settings;
-
 // Maybe this should be independent from serialization?
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]
 pub struct Dimensions {
@@ -16,23 +14,6 @@ pub struct Dimensions {
     pub height: u64,
 }
 
-impl Dimensions {
-    pub fn clamped_grid_size(&self) -> Self {
-        let min = settings::MIN_GRID_SIZE;
-        let max = settings::MAX_GRID_SIZE;
-        Dimensions {
-            width: self.width.clamp(min.width, max.width),
-            height: self.height.clamp(min.height, max.height),
-        }
-    }
-}
-
-impl Default for Dimensions {
-    fn default() -> Self {
-        settings::DEFAULT_GRID_SIZE
-    }
-}
-
 impl FromStr for Dimensions {
     type Err = String;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
diff --git a/src/main.rs b/src/main.rs
index 38cce3211e..8aaf5dedc7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -25,6 +25,7 @@ mod profiling;
 mod renderer;
 mod running_tracker;
 mod settings;
+mod units;
 mod utils;
 mod window;
 
diff --git a/src/renderer/animation_utils.rs b/src/renderer/animation_utils.rs
index 7c633ccc6f..8f1edfcf7c 100644
--- a/src/renderer/animation_utils.rs
+++ b/src/renderer/animation_utils.rs
@@ -1,4 +1,4 @@
-use skia_safe::Point;
+use crate::units::PixelPos;
 
 #[allow(dead_code)]
 pub fn ease_linear(t: f32) -> f32 {
@@ -73,11 +73,16 @@ pub fn ease(ease_func: fn(f32) -> f32, start: f32, end: f32, t: f32) -> f32 {
     lerp(start, end, ease_func(t))
 }
 
-pub fn ease_point(ease_func: fn(f32) -> f32, start: Point, end: Point, t: f32) -> Point {
-    Point {
-        x: ease(ease_func, start.x, end.x, t),
-        y: ease(ease_func, start.y, end.y, t),
-    }
+pub fn ease_point(
+    ease_func: fn(f32) -> f32,
+    start: PixelPos<f32>,
+    end: PixelPos<f32>,
+    t: f32,
+) -> PixelPos<f32> {
+    PixelPos::new(
+        ease(ease_func, start.x, end.x, t),
+        ease(ease_func, start.y, end.y, t),
+    )
 }
 
 pub struct CriticallyDampedSpringAnimation {
@@ -205,79 +210,70 @@ mod test {
 
     #[test]
     fn test_ease_point_linear() {
-        let start = Point { x: 0.0, y: 0.0 };
-        let end = Point { x: 1.0, y: 1.0 };
+        let start = PixelPos::new(0.0, 0.0);
+        let end = PixelPos::new(1.0, 1.0);
         assert_eq!(ease_point(ease_linear, start, end, 1.0), end);
     }
 
     #[test]
     fn test_ease_point_in_quad() {
-        let start = Point { x: 0.0, y: 0.0 };
-        let end = Point { x: 1.0, y: 1.0 };
+        let start = PixelPos::new(0.0, 0.0);
+        let end = PixelPos::new(1.0, 1.0);
         assert_eq!(ease_point(ease_in_quad, start, end, 1.0), end);
     }
 
     #[test]
     fn test_ease_point_out_quad() {
-        let start = Point { x: 0.0, y: 0.0 };
-        let end = Point { x: 1.0, y: 1.0 };
+        let start = PixelPos::new(0.0, 0.0);
+        let end = PixelPos::new(1.0, 1.0);
         assert_eq!(ease_point(ease_out_quad, start, end, 1.0), end);
     }
 
     #[test]
     fn test_ease_point_in_out_quad() {
-        let start = Point { x: 0.0, y: 0.0 };
-        let end = Point { x: 1.0, y: 1.0 };
-        let expected = Point {
-            x: 0.68000007,
-            y: 0.68000007,
-        };
+        let start = PixelPos::new(0.0, 0.0);
+        let end = PixelPos::new(1.0, 1.0);
+        let expected = PixelPos::new(0.68000007, 0.68000007);
         assert_eq!(ease_point(ease_in_out_quad, start, end, 1.0), end);
         assert_eq!(ease_point(ease_in_out_quad, start, end, 1.4), expected);
     }
 
     #[test]
     fn test_ease_point_in_cubic() {
-        let start = Point { x: 0.0, y: 0.0 };
-        let end = Point { x: 1.0, y: 1.0 };
+        let start = PixelPos::new(0.0, 0.0);
+        let end = PixelPos::new(1.0, 1.0);
         assert_eq!(ease_point(ease_in_cubic, start, end, 1.0), end);
     }
 
     #[test]
     fn test_ease_point_out_cubic() {
-        let start = Point { x: 0.0, y: 0.0 };
-        let end = Point { x: 1.0, y: 1.0 };
+        let start = PixelPos::new(0.0, 0.0);
+        let end = PixelPos::new(1.0, 1.0);
         assert_eq!(ease_point(ease_out_cubic, start, end, 1.0), end);
     }
 
     #[test]
     fn test_ease_point_in_out_cubic() {
-        let start = Point { x: 0.0, y: 0.0 };
-        let end = Point { x: 1.0, y: 1.0 };
-        let expected = Point {
-            x: 0.0625,
-            y: 0.0625,
-        };
+        let start = PixelPos::new(0.0, 0.0);
+        let end = PixelPos::new(1.0, 1.0);
+        let expected = PixelPos::new(0.0625, 0.0625);
         assert_eq!(ease_point(ease_in_out_cubic, start, end, 1.0), end);
         assert_eq!(ease_point(ease_in_out_cubic, start, end, 0.25), expected);
     }
 
     #[test]
     fn test_ease_point_in_expo() {
-        let start = Point { x: 0.0, y: 0.0 };
-        let end = Point { x: 1.0, y: 1.0 };
+        let start = PixelPos::new(0.0, 0.0);
+        let end = PixelPos::new(1.0, 1.0);
         assert_eq!(ease_point(ease_in_expo, start, end, 1.0), end);
         assert_eq!(ease_point(ease_in_expo, start, end, 0.0), start);
     }
 
     #[test]
     fn test_ease_point_out_expo() {
-        let start = Point { x: 0.0, y: 0.0 };
-        let end = Point { x: 1.0, y: 1.0 };
-        let expected = Point {
-            x: 0.9995117,
-            y: 0.9995117,
-        };
+        let start = PixelPos::new(0.0, 0.0);
+        let end = PixelPos::new(1.0, 1.0);
+        let expected = PixelPos::new(0.9995117, 0.9995117);
         assert_eq!(ease_point(ease_out_expo, start, end, 1.0), end);
         assert_eq!(ease_point(ease_out_expo, start, end, 1.1), expected);
     }
diff --git a/src/renderer/cursor_renderer/cursor_vfx.rs b/src/renderer/cursor_renderer/cursor_vfx.rs
index e18c45f50f..fa22b5bed0 100644
--- a/src/renderer/cursor_renderer/cursor_vfx.rs
+++ b/src/renderer/cursor_renderer/cursor_vfx.rs
@@ -1,24 +1,25 @@
 use log::error;
 use nvim_rs::Value;
-use skia_safe::{paint::Style, BlendMode, Canvas, Color, Paint, Point, Rect};
+use skia_safe::{paint::Style, BlendMode, Canvas, Color, Paint, Rect};
 
 use crate::{
     editor::Cursor,
     renderer::cursor_renderer::CursorSettings,
     renderer::{animation_utils::*, grid_renderer::GridRenderer},
     settings::*,
+    units::{PixelPos, PixelSize, PixelVec},
 };
 
 pub trait CursorVfx {
     fn update(
         &mut self,
         settings: &CursorSettings,
-        current_cursor_destination: Point,
-        cursor_dimensions: Point,
+        current_cursor_destination: PixelPos<f32>,
+        cursor_dimensions: PixelSize<f32>,
         immediate_movement: bool,
         dt: f32,
     ) -> bool;
-    fn restart(&mut self, position: Point);
+    fn restart(&mut self, position: PixelPos<f32>);
     fn render(
         &self,
         settings: &CursorSettings,
@@ -95,7 +96,7 @@ pub fn new_cursor_vfx(mode: &VfxMode) -> Option<Box<dyn CursorVfx>> {
 
 pub struct PointHighlight {
     t: f32,
-    center_position: Point,
+    center_position: PixelPos<f32>,
     mode: HighlightMode,
 }
 
@@ -103,7 +104,7 @@ impl PointHighlight {
     pub fn new(mode: &HighlightMode) -> PointHighlight {
         PointHighlight {
             t: 0.0,
-            center_position: Point::new(0.0, 0.0),
+            center_position: PixelPos::new(0.0, 0.0),
             mode: mode.clone(),
         }
     }
@@ -113,8 +114,8 @@ impl CursorVfx for PointHighlight {
     fn update(
         &mut self,
         _settings: &CursorSettings,
-        _current_cursor_destination: Point,
-        _cursor_dimensions: Point,
+        _current_cursor_destination: PixelPos<f32>,
+        _cursor_dimensions: PixelSize<f32>,
         _immediate_movement: bool,
         dt: f32,
     ) -> bool {
@@ -122,7 +123,7 @@ impl CursorVfx for PointHighlight {
         self.t < 1.0
     }
 
-    fn restart(&mut self, position: Point) {
+    fn restart(&mut self, position: PixelPos<f32>) {
         self.t = 0.0;
         self.center_position = position;
     }
@@ -148,9 +149,9 @@ impl CursorVfx for PointHighlight {
 
         paint.set_color(color);
 
-        let cursor_height = grid_renderer.font_dimensions.height;
-        let size = 3 * cursor_height;
-        let radius = self.t * size as f32;
+        let cursor_height = grid_renderer.grid_scale.0.height;
+        let size = 3.0 * cursor_height;
+        let radius = self.t * size;
         let hr = radius * 0.5;
         let rect = Rect::from_xywh(
             self.center_position.x - hr,
@@ -165,12 +166,12 @@ impl CursorVfx for PointHighlight {
             }
             HighlightMode::Ripple => {
                 paint.set_style(Style::Stroke);
-                paint.set_stroke_width(cursor_height as f32 * 0.2);
+                paint.set_stroke_width(cursor_height * 0.2);
                 canvas.draw_oval(rect, &paint);
             }
             HighlightMode::Wireframe => {
                 paint.set_style(Style::Stroke);
-                paint.set_stroke_width(cursor_height as f32 * 0.2);
+                paint.set_stroke_width(cursor_height * 0.2);
                 canvas.draw_rect(rect, &paint);
             }
         }
@@ -179,15 +180,15 @@ impl CursorVfx for PointHighlight {
 
 #[derive(Clone)]
 struct ParticleData {
-    pos: Point,
-    speed: Point,
+    pos: PixelPos<f32>,
+    speed: PixelVec<f32>,
     rotation_speed: f32,
     lifetime: f32,
 }
 
 pub struct ParticleTrail {
     particles: Vec<ParticleData>,
-    previous_cursor_dest: Point,
+    previous_cursor_dest: PixelPos<f32>,
     trail_mode: TrailMode,
     rng: RngState,
 }
@@ -196,13 +197,19 @@ impl ParticleTrail {
     pub fn new(trail_mode: &TrailMode) -> ParticleTrail {
         ParticleTrail {
             particles: vec![],
-            previous_cursor_dest: Point::new(0.0, 0.0),
+            previous_cursor_dest: PixelPos::new(0.0, 0.0),
             trail_mode: trail_mode.clone(),
             rng: RngState::new(),
         }
     }
 
-    fn add_particle(&mut self, pos: Point, speed: Point, rotation_speed: f32, lifetime: f32) {
+    fn add_particle(
+        &mut self,
+        pos: PixelPos<f32>,
+        speed: PixelVec<f32>,
+        rotation_speed: f32,
+        lifetime: f32,
+    ) {
         self.particles.push(ParticleData {
             pos,
             speed,
@@ -222,8 +229,8 @@ impl CursorVfx for ParticleTrail {
     fn update(
         &mut self,
         settings: &CursorSettings,
-        current_cursor_dest: Point,
-        cursor_dimensions: Point,
+        current_cursor_dest: PixelPos<f32>,
+        cursor_dimensions: PixelSize<f32>,
         immediate_movement: bool,
         dt: f32,
     ) -> bool {
@@ -253,7 +260,7 @@ impl CursorVfx for ParticleTrail {
                 let travel_distance = travel.length();
 
                 // Increase amount of particles when cursor travels further
-                let particle_count = ((travel_distance / cursor_dimensions.y).powf(1.5)
+                let particle_count = ((travel_distance / cursor_dimensions.height).powf(1.5)
                     * settings.vfx_particle_density
                     * 0.01) as usize;
 
@@ -266,20 +273,19 @@ impl CursorVfx for ParticleTrail {
                         TrailMode::Railgun => {
                             let phase = t / std::f32::consts::PI
                                 * settings.vfx_particle_phase
-                                * (travel_distance / cursor_dimensions.y);
-                            Point::new(phase.sin(), phase.cos()) * 2.0 * settings.vfx_particle_speed
+                                * (travel_distance / cursor_dimensions.height);
+                            PixelVec::new(phase.sin(), phase.cos())
+                                * 2.0
+                                * settings.vfx_particle_speed
                         }
                         TrailMode::Torpedo => {
-                            let mut travel_dir = travel;
-                            travel_dir.normalize();
-                            let mut particle_dir =
-                                self.rng.rand_dir_normalized() - travel_dir * 1.5;
-                            particle_dir.normalize();
-                            particle_dir * settings.vfx_particle_speed
+                            let travel_dir = travel.normalize();
+                            let particle_dir = self.rng.rand_dir_normalized() - travel_dir * 1.5;
+                            particle_dir.normalize() * settings.vfx_particle_speed
                         }
                         TrailMode::PixieDust => {
                             let base_dir = self.rng.rand_dir_normalized();
-                            let dir = Point::new(base_dir.x * 0.5, 0.4 + base_dir.y.abs());
+                            let dir = PixelVec::new(base_dir.x * 0.5, 0.4 + base_dir.y.abs());
                             dir * 3.0 * settings.vfx_particle_speed
                         }
                     };
@@ -290,7 +296,7 @@ impl CursorVfx for ParticleTrail {
                         TrailMode::PixieDust | TrailMode::Torpedo => {
                             prev_p
                                 + travel * self.rng.next_f32()
-                                + Point::new(0.0, cursor_dimensions.y * 0.5)
+                                + PixelVec::new(0.0, cursor_dimensions.height * 0.5)
                         }
                     };
 
@@ -319,7 +325,7 @@ impl CursorVfx for ParticleTrail {
         !self.particles.is_empty()
     }
 
-    fn restart(&mut self, _position: Point) {}
+    fn restart(&mut self, _position: PixelPos<f32>) {}
 
     fn render(
         &self,
@@ -329,11 +335,11 @@ impl CursorVfx for ParticleTrail {
         cursor: &Cursor,
     ) {
         let mut paint = Paint::new(skia_safe::colors::WHITE, None);
-        let font_dimensions = grid_renderer.font_dimensions;
+        let font_dimensions = grid_renderer.grid_scale.0;
         match self.trail_mode {
             TrailMode::Torpedo | TrailMode::Railgun => {
                 paint.set_style(Style::Stroke);
-                paint.set_stroke_width(font_dimensions.height as f32 * 0.2);
+                paint.set_stroke_width(font_dimensions.height * 0.2);
             }
             _ => {}
         }
@@ -350,10 +356,8 @@ impl CursorVfx for ParticleTrail {
             paint.set_color(color);
 
             let radius = match self.trail_mode {
-                TrailMode::Torpedo | TrailMode::Railgun => {
-                    font_dimensions.width as f32 * 0.5 * lifetime
-                }
-                TrailMode::PixieDust => font_dimensions.width as f32 * 0.2,
+                TrailMode::Torpedo | TrailMode::Railgun => font_dimensions.width * 0.5 * lifetime,
+                TrailMode::PixieDust => font_dimensions.width * 0.2,
             };
 
             let hr = radius * 0.5;
@@ -426,23 +430,21 @@ impl RngState {
 
     // Produces a random vector with x and y in the [-1,1) range
     // Note: Vector is not normalized.
-    fn rand_dir(&mut self) -> Point {
+    fn rand_dir(&mut self) -> PixelVec<f32> {
         let x = self.next_f32();
         let y = self.next_f32();
 
-        Point::new(x * 2.0 - 1.0, y * 2.0 - 1.0)
+        PixelVec::new(x * 2.0 - 1.0, y * 2.0 - 1.0)
     }
 
-    fn rand_dir_normalized(&mut self) -> Point {
-        let mut v = self.rand_dir();
-        v.normalize();
-        v
+    fn rand_dir_normalized(&mut self) -> PixelVec<f32> {
+        self.rand_dir().normalize()
     }
 }
 
-fn rotate_vec(v: Point, rot: f32) -> Point {
+fn rotate_vec(v: PixelVec<f32>, rot: f32) -> PixelVec<f32> {
     let sin = rot.sin();
     let cos = rot.cos();
 
-    Point::new(v.x * cos - v.y * sin, v.x * sin + v.y * cos)
+    PixelVec::new(v.x * cos - v.y * sin, v.x * sin + v.y * cos)
 }
diff --git a/src/renderer/cursor_renderer/mod.rs b/src/renderer/cursor_renderer/mod.rs
index be689393ba..8f86d22d8b 100644
--- a/src/renderer/cursor_renderer/mod.rs
+++ b/src/renderer/cursor_renderer/mod.rs
@@ -3,16 +3,16 @@ mod cursor_vfx;
 
 use std::collections::HashMap;
 
-use skia_safe::{op, Canvas, Paint, Path, Point};
+use skia_safe::{op, Canvas, Paint, Path};
 use winit::event::{Event, WindowEvent};
 
 use crate::{
     bridge::EditorMode,
     editor::{Cursor, CursorShape},
     profiling::{tracy_plot, tracy_zone},
-    renderer::animation_utils::*,
-    renderer::{GridRenderer, RenderedWindow},
+    renderer::{animation_utils::*, GridRenderer, RenderedWindow},
     settings::{ParseFromValue, SETTINGS},
+    units::{to_skia_point, GridPos, GridScale, PixelPos, PixelSize, PixelVec},
     window::{ShouldRender, UserEvent},
 };
 
@@ -68,10 +68,10 @@ impl Default for CursorSettings {
 
 #[derive(Debug, Clone)]
 pub struct Corner {
-    start_position: Point,
-    current_position: Point,
-    relative_position: Point,
-    previous_destination: Point,
+    start_position: PixelPos<f32>,
+    current_position: PixelPos<f32>,
+    relative_position: GridPos<f32>,
+    previous_destination: PixelPos<f32>,
     length_multiplier: f32,
     t: f32,
 }
@@ -79,10 +79,10 @@ pub struct Corner {
 impl Corner {
     pub fn new() -> Corner {
         Corner {
-            start_position: Point::new(0.0, 0.0),
-            current_position: Point::new(0.0, 0.0),
-            relative_position: Point::new(0.0, 0.0),
-            previous_destination: Point::new(-1000.0, -1000.0),
+            start_position: PixelPos::origin(),
+            current_position: PixelPos::origin(),
+            relative_position: GridPos::<f32>::origin(),
+            previous_destination: PixelPos::new(-1000.0, -1000.0),
             length_multiplier: 1.0,
             t: 0.0,
         }
@@ -91,8 +91,8 @@ impl Corner {
     pub fn update(
         &mut self,
         settings: &CursorSettings,
-        font_dimensions: Point,
-        destination: Point,
+        cursor_dimensions: GridScale,
+        destination: PixelPos<f32>,
         dt: f32,
         immediate_movement: bool,
     ) -> bool {
@@ -116,13 +116,9 @@ impl Corner {
         }
 
         // Calculate window-space destination for corner
-        let relative_scaled_position: Point = (
-            self.relative_position.x * font_dimensions.x,
-            self.relative_position.y * font_dimensions.y,
-        )
-            .into();
+        let relative_scaled_position = self.relative_position * cursor_dimensions;
 
-        let corner_destination = destination + relative_scaled_position;
+        let corner_destination = destination + relative_scaled_position.to_vector();
 
         if immediate_movement {
             self.t = 1.0;
@@ -134,16 +130,11 @@ impl Corner {
         // with the direction of motion. Corners in front will move faster than corners in the
         // back
         let travel_direction = {
-            let mut d = destination - self.current_position;
-            d.normalize();
-            d
+            let d = destination - self.current_position;
+            d.normalize()
         };
 
-        let corner_direction = {
-            let mut d = self.relative_position;
-            d.normalize();
-            d
-        };
+        let corner_direction = self.relative_position.to_vector().normalize().cast_unit();
 
         let direction_alignment = travel_direction.dot(corner_direction);
 
@@ -175,7 +166,7 @@ impl Corner {
 pub struct CursorRenderer {
     pub corners: Vec<Corner>,
     cursor: Cursor,
-    destination: Point,
+    destination: PixelPos<f32>,
     blink_status: BlinkStatus,
     previous_cursor_shape: Option<CursorShape>,
     previous_editor_mode: EditorMode,
@@ -250,15 +241,15 @@ impl CursorRenderer {
 
     pub fn update_cursor_destination(
         &mut self,
-        (font_width, font_height): (u64, u64),
+        grid_scale: GridScale,
         windows: &HashMap<u64, RenderedWindow>,
     ) {
-        let (cursor_grid_x, cursor_grid_y) = self.cursor.grid_position;
-
+        let cursor_grid_position = GridPos::<u64>::from(self.cursor.grid_position)
+            .try_cast()
+            .unwrap();
         if let Some(window) = windows.get(&self.cursor.parent_window_id) {
-            let grid_x = cursor_grid_x as f32 + window.grid_current_position.x;
-            let mut grid_y = cursor_grid_y as f32 + window.grid_current_position.y
-                - window.scroll_animation.position;
+            let mut grid = cursor_grid_position + window.grid_current_position.to_vector();
+            grid.y -= window.scroll_animation.position;
 
             let top_border = window.viewport_margins.top as f32;
             let bottom_border = window.viewport_margins.bottom as f32;
@@ -266,19 +257,15 @@ impl CursorRenderer {
             // Prevent the cursor from targeting a position outside its current window. Since only
             // the vertical direction is effected by scrolling, we only have to clamp the vertical
             // grid position.
-            grid_y = grid_y.max(window.grid_current_position.y + top_border).min(
+            grid.y = grid.y.max(window.grid_current_position.y + top_border).min(
                 window.grid_current_position.y + window.grid_size.height as f32
                     - 1.0
                     - bottom_border,
             );
 
-            self.destination = (grid_x * font_width as f32, grid_y * font_height as f32).into();
+            self.destination = grid * grid_scale;
         } else {
-            self.destination = (
-                (cursor_grid_x * font_width) as f32,
-                (cursor_grid_y * font_height) as f32,
-            )
-                .into();
+            self.destination = cursor_grid_position * grid_scale;
         }
     }
 
@@ -339,7 +326,7 @@ impl CursorRenderer {
         for blob in blobs.iter() {
             canvas.draw_text_blob(
                 blob,
-                (self.destination.x, self.destination.y + y_adjustment as f32),
+                (self.destination.x, self.destination.y + y_adjustment),
                 &paint,
             );
         }
@@ -365,23 +352,19 @@ impl CursorRenderer {
             self.previous_vfx_mode = settings.vfx_mode.clone();
         }
 
-        let mut cursor_width = grid_renderer.font_dimensions.width;
+        let mut cursor_width = grid_renderer.grid_scale.0.width;
         if self.cursor.double_width && self.cursor.shape == CursorShape::Block {
-            cursor_width *= 2;
+            cursor_width *= 2.0;
         }
 
-        let cursor_dimensions: Point = (
-            cursor_width as f32,
-            grid_renderer.font_dimensions.height as f32,
-        )
-            .into();
+        let cursor_dimensions = PixelSize::new(cursor_width, grid_renderer.grid_scale.0.height);
 
         let in_insert_mode = matches!(current_mode, EditorMode::Insert);
 
         let changed_to_from_cmdline = !matches!(self.previous_editor_mode, EditorMode::CmdLine)
             ^ matches!(current_mode, EditorMode::CmdLine);
 
-        let center_destination = self.destination + cursor_dimensions * 0.5;
+        let center_destination = self.destination + cursor_dimensions.to_vector() * 0.5;
 
         if self.previous_cursor_shape.as_ref() != Some(&self.cursor.shape) {
             self.previous_cursor_shape = Some(self.cursor.shape.clone());
@@ -399,13 +382,13 @@ impl CursorRenderer {
 
         let mut animating = false;
 
-        if !center_destination.is_zero() {
+        if center_destination != PixelPos::origin() {
             let immediate_movement = !settings.animate_in_insert_mode && in_insert_mode
                 || !settings.animate_command_line && !changed_to_from_cmdline;
             for corner in self.corners.iter_mut() {
                 let corner_animating = corner.update(
                     &settings,
-                    cursor_dimensions,
+                    GridScale(cursor_dimensions),
                     center_destination,
                     dt,
                     immediate_movement,
@@ -445,10 +428,10 @@ impl CursorRenderer {
         // corners.
         let mut path = Path::new();
 
-        path.move_to(self.corners[0].current_position);
-        path.line_to(self.corners[1].current_position);
-        path.line_to(self.corners[2].current_position);
-        path.line_to(self.corners[3].current_position);
+        path.move_to(to_skia_point(self.corners[0].current_position));
+        path.line_to(to_skia_point(self.corners[1].current_position));
+        path.line_to(to_skia_point(self.corners[2].current_position));
+        path.line_to(to_skia_point(self.corners[3].current_position));
         path.close();
 
         canvas.draw_path(&path, paint);
@@ -457,13 +440,13 @@ impl CursorRenderer {
 
     fn draw_rectangular_outline(&self, canvas: &Canvas, paint: &Paint, outline_width: f32) -> Path {
         let mut rectangle = Path::new();
-        rectangle.move_to(self.corners[0].current_position);
-        rectangle.line_to(self.corners[1].current_position);
-        rectangle.line_to(self.corners[2].current_position);
-        rectangle.line_to(self.corners[3].current_position);
+        rectangle.move_to(to_skia_point(self.corners[0].current_position));
+        rectangle.line_to(to_skia_point(self.corners[1].current_position));
+        rectangle.line_to(to_skia_point(self.corners[2].current_position));
+        rectangle.line_to(to_skia_point(self.corners[3].current_position));
         rectangle.close();
 
-        let offsets: [Point; 4] = [
+        let offsets: [PixelVec<f32>; 4] = [
             (outline_width, outline_width).into(),
             (-outline_width, outline_width).into(),
             (-outline_width, -outline_width).into(),
@@ -471,10 +454,10 @@ impl CursorRenderer {
         ];
 
         let mut subtract = Path::new();
-        subtract.move_to(self.corners[0].current_position + offsets[0]);
-        subtract.line_to(self.corners[1].current_position + offsets[1]);
-        subtract.line_to(self.corners[2].current_position + offsets[2]);
-        subtract.line_to(self.corners[3].current_position + offsets[3]);
+        subtract.move_to(to_skia_point(self.corners[0].current_position + offsets[0]));
+        subtract.line_to(to_skia_point(self.corners[1].current_position + offsets[1]));
+        subtract.line_to(to_skia_point(self.corners[2].current_position + offsets[2]));
+        subtract.line_to(to_skia_point(self.corners[3].current_position + offsets[3]));
         subtract.close();
 
         // We have two "rectangles"; create an outline path by subtracting the smaller rectangle
@@ -485,7 +468,7 @@ impl CursorRenderer {
         path
     }
 
-    pub fn get_current_position(&self) -> Point {
+    pub fn get_destination(&self) -> PixelPos<f32> {
         self.destination
     }
 }
diff --git a/src/renderer/fonts/caching_shaper.rs b/src/renderer/fonts/caching_shaper.rs
index d3108d753b..c75305d68c 100644
--- a/src/renderer/fonts/caching_shaper.rs
+++ b/src/renderer/fonts/caching_shaper.rs
@@ -21,6 +21,7 @@ use crate::{
     error_msg,
     profiling::tracy_zone,
     renderer::fonts::{font_loader::*, font_options::*},
+    units::PixelSize,
 };
 
 #[derive(new, Clone, Hash, PartialEq, Eq, Debug)]
@@ -36,7 +37,7 @@ pub struct CachingShaper {
     shape_context: ShapeContext,
     scale_factor: f32,
     fudge_factor: f32,
-    linespace: i64,
+    linespace: f32,
     font_info: Option<(Metrics, f32)>,
 }
 
@@ -51,7 +52,7 @@ impl CachingShaper {
             shape_context: ShapeContext::new(),
             scale_factor,
             fudge_factor: 1.0,
-            linespace: 0,
+            linespace: 0.0,
             font_info: None,
         };
         shaper.reset_font_loader();
@@ -132,11 +133,11 @@ impl CachingShaper {
         }
     }
 
-    pub fn update_linespace(&mut self, linespace: i64) {
+    pub fn update_linespace(&mut self, linespace: f32) {
         debug!("Updating linespace: {}", linespace);
 
-        let font_height = self.font_base_dimensions().1;
-        let impossible_linespace = font_height as i64 + linespace <= 0;
+        let font_height = self.font_base_dimensions().height;
+        let impossible_linespace = font_height + linespace <= 0.0;
 
         if !impossible_linespace {
             debug!("Linespace updated to: {linespace}");
@@ -215,27 +216,28 @@ impl CachingShaper {
         self.info().0
     }
 
-    pub fn font_base_dimensions(&mut self) -> (u64, u64) {
+    pub fn font_base_dimensions(&mut self) -> PixelSize<f32> {
         let (metrics, glyph_advance) = self.info();
 
         let bare_font_height = (metrics.ascent + metrics.descent + metrics.leading).ceil();
-        let font_height = bare_font_height as i64 + self.linespace;
-        let font_width = (glyph_advance + self.options.width + 0.5).floor() as u64;
+        let font_height = bare_font_height + self.linespace;
+        let font_width = (glyph_advance + self.options.width + 0.5).floor();
 
         (
             font_width,
-            font_height as u64, // assuming that linespace is checked on receive for
-                                // validity
+            font_height, // assuming that linespace is checked on receive for
+                         // validity
         )
+            .into()
     }
 
-    pub fn underline_position(&mut self) -> u64 {
-        self.metrics().underline_offset as u64
+    pub fn underline_position(&mut self) -> f32 {
+        self.metrics().underline_offset
     }
 
-    pub fn y_adjustment(&mut self) -> u64 {
+    pub fn y_adjustment(&mut self) -> f32 {
         let metrics = self.metrics();
-        (metrics.ascent + metrics.leading + self.linespace as f32 / 2.).ceil() as u64
+        (metrics.ascent + metrics.leading + self.linespace / 2.).ceil()
     }
 
     fn build_clusters(
@@ -385,7 +387,7 @@ impl CachingShaper {
 
     pub fn shape(&mut self, text: String, style: CoarseStyle) -> Vec<TextBlob> {
         let current_size = self.current_size();
-        let (glyph_width, ..) = self.font_base_dimensions();
+        let glyph_width = self.font_base_dimensions().width;
 
         let mut resulting_blobs = Vec::new();
 
@@ -418,7 +420,7 @@ impl CachingShaper {
 
             shaper.shape_with(|glyph_cluster| {
                 for glyph in glyph_cluster.glyphs {
-                    let position = ((glyph.data as u64 * glyph_width) as f32, glyph.y);
+                    let position = ((glyph.data as f32 * glyph_width), glyph.y);
                     glyph_data.push((glyph.id, position));
                 }
             });
diff --git a/src/renderer/grid_renderer.rs b/src/renderer/grid_renderer.rs
index 756c88eccf..ab91eefd3f 100644
--- a/src/renderer/grid_renderer.rs
+++ b/src/renderer/grid_renderer.rs
@@ -1,17 +1,16 @@
 use std::sync::Arc;
 
 use log::trace;
-use skia_safe::{
-    colors, dash_path_effect, BlendMode, Canvas, Color, Paint, Path, Point, Rect, HSV,
-};
-use winit::dpi::PhysicalSize;
+use skia_safe::{colors, dash_path_effect, BlendMode, Canvas, Color, Paint, Path, HSV};
 
 use crate::{
-    dimensions::Dimensions,
     editor::{Colors, Style, UnderlineStyle},
     profiling::tracy_zone,
     renderer::{CachingShaper, RendererSettings},
     settings::*,
+    units::{
+        to_skia_point, to_skia_rect, GridPos, GridScale, GridSize, PixelPos, PixelRect, PixelVec,
+    },
 };
 
 use super::fonts::font_options::FontOptions;
@@ -20,7 +19,7 @@ pub struct GridRenderer {
     pub shaper: CachingShaper,
     pub default_style: Arc<Style>,
     pub em_size: f32,
-    pub font_dimensions: Dimensions,
+    pub grid_scale: GridScale,
     pub is_ready: bool,
 }
 
@@ -39,13 +38,13 @@ impl GridRenderer {
             Some(colors::GREY),
         )));
         let em_size = shaper.current_size();
-        let font_dimensions: Dimensions = shaper.font_base_dimensions().into();
+        let font_dimensions = shaper.font_base_dimensions();
 
         GridRenderer {
             shaper,
             default_style,
             em_size,
-            font_dimensions,
+            grid_scale: GridScale(font_dimensions),
             is_ready: false,
         }
     }
@@ -54,16 +53,6 @@ impl GridRenderer {
         self.shaper.font_names()
     }
 
-    /// Convert PhysicalSize to grid size.
-    pub fn convert_physical_to_grid(&self, physical: PhysicalSize<u32>) -> Dimensions {
-        Dimensions::from(physical) / self.font_dimensions
-    }
-
-    /// Convert grid size to PhysicalSize.
-    pub fn convert_grid_to_physical(&self, grid: Dimensions) -> PhysicalSize<u32> {
-        (grid * self.font_dimensions).into()
-    }
-
     pub fn handle_scale_factor_update(&mut self, scale_factor: f64) {
         self.shaper.update_scale_factor(scale_factor as f32);
         self.update_font_dimensions();
@@ -79,23 +68,22 @@ impl GridRenderer {
         self.update_font_dimensions();
     }
 
-    pub fn update_linespace(&mut self, linespace_setting: i64) {
+    pub fn update_linespace(&mut self, linespace_setting: f32) {
         self.shaper.update_linespace(linespace_setting);
         self.update_font_dimensions();
     }
 
     fn update_font_dimensions(&mut self) {
         self.em_size = self.shaper.current_size();
-        self.font_dimensions = self.shaper.font_base_dimensions().into();
+        self.grid_scale = GridScale(self.shaper.font_base_dimensions());
         self.is_ready = true;
-        trace!("Updated font dimensions: {:?}", self.font_dimensions,);
+        trace!("Updated font dimensions: {:?}", self.grid_scale.0);
     }
 
-    fn compute_text_region(&self, grid_position: (u64, u64), cell_width: u64) -> Rect {
-        let (x, y) = grid_position * self.font_dimensions;
-        let width = cell_width * self.font_dimensions.width;
-        let height = self.font_dimensions.height;
-        Rect::new(x as f32, y as f32, (x + width) as f32, (y + height) as f32)
+    fn compute_text_region(&self, grid_position: GridPos<i32>, cell_width: i32) -> PixelRect<f32> {
+        let pos = grid_position.cast() * self.grid_scale;
+        let size = GridSize::new(cell_width, 1).cast() * self.grid_scale;
+        PixelRect::from_origin_and_size(pos, size)
     }
 
     pub fn get_default_background(&self) -> Color {
@@ -110,8 +98,8 @@ impl GridRenderer {
     pub fn draw_background(
         &mut self,
         canvas: &Canvas,
-        grid_position: (u64, u64),
-        cell_width: u64,
+        grid_position: GridPos<i32>,
+        cell_width: i32,
         style: &Option<Arc<Style>>,
     ) -> BackgroundInfo {
         tracy_zone!("draw_background");
@@ -145,7 +133,7 @@ impl GridRenderer {
 
         let custom_color = paint.color4f() != self.default_style.colors.background.unwrap();
         if custom_color {
-            canvas.draw_rect(region, &paint);
+            canvas.draw_rect(to_skia_rect(&region), &paint);
         }
 
         BackgroundInfo {
@@ -160,42 +148,34 @@ impl GridRenderer {
         &mut self,
         canvas: &Canvas,
         text: &str,
-        grid_position: (u64, u64),
-        cell_width: u64,
+        grid_position: GridPos<i32>,
+        cell_width: i32,
         style: &Option<Arc<Style>>,
     ) -> bool {
         tracy_zone!("draw_foreground");
-        let (x, y) = grid_position * self.font_dimensions;
-        let width = cell_width * self.font_dimensions.width;
+        let pos = grid_position.cast() * self.grid_scale;
+        let size = GridSize::new(cell_width, 0).cast() * self.grid_scale;
+        let width = size.width;
 
         let style = style.as_ref().unwrap_or(&self.default_style);
         let mut drawn = false;
 
         // We don't want to clip text in the x position, only the y so we add a buffer of 1
         // character on either side of the region so that we clip vertically but not horizontally.
-        let (grid_x, grid_y) = grid_position;
-        let clip_position = (grid_x.saturating_sub(1), grid_y);
+        let clip_position = (grid_position.x.saturating_sub(1), grid_position.y).into();
         let region = self.compute_text_region(clip_position, cell_width + 2);
 
         if let Some(underline_style) = style.underline {
-            let line_position = self.shaper.underline_position();
-            let p1 = (
-                x as f32,
-                (y - line_position + self.font_dimensions.height) as f32,
-            );
-            let p2 = (
-                (x + width) as f32,
-                (y - line_position + self.font_dimensions.height) as f32,
-            );
+            let line_position = self.grid_scale.0.height - self.shaper.underline_position();
+            let p1 = pos + PixelVec::new(0.0, line_position);
+            let p2 = pos + PixelVec::new(width, line_position);
 
-            self.draw_underline(canvas, style, underline_style, p1.into(), p2.into());
+            self.draw_underline(canvas, style, underline_style, p1, p2);
             drawn = true;
         }
 
         canvas.save();
-        canvas.clip_rect(region, None, Some(false));
-
-        let y_adjustment = self.shaper.y_adjustment();
+        canvas.clip_rect(to_skia_rect(&region), None, Some(false));
 
         let mut paint = Paint::default();
         paint.set_anti_alias(false);
@@ -216,7 +196,10 @@ impl GridRenderer {
         let leading_space_bytes = text.len() - trimmed.len();
         let leading_spaces = text[..leading_space_bytes].chars().count();
         let trimmed = trimmed.trim_end();
-        let x_adjustment = leading_spaces as u64 * self.font_dimensions.width;
+        let adjustment = PixelVec::new(
+            leading_spaces as f32 * self.grid_scale.0.width,
+            self.shaper.y_adjustment(),
+        );
 
         if !trimmed.is_empty() {
             for blob in self
@@ -225,21 +208,17 @@ impl GridRenderer {
                 .iter()
             {
                 tracy_zone!("draw_text_blob");
-                canvas.draw_text_blob(
-                    blob,
-                    ((x + x_adjustment) as f32, (y + y_adjustment) as f32),
-                    &paint,
-                );
+                canvas.draw_text_blob(blob, to_skia_point(pos + adjustment), &paint);
                 drawn = true;
             }
         }
 
         if style.strikethrough {
-            let line_position = region.center_y();
+            let line_position = region.center().y;
             paint.set_color(style.special(&self.default_style.colors).to_color());
             canvas.draw_line(
-                (x as f32, line_position),
-                ((x + width) as f32, line_position),
+                (pos.x, line_position),
+                (pos.x + width, line_position),
                 &paint,
             );
             drawn = true;
@@ -254,8 +233,8 @@ impl GridRenderer {
         canvas: &Canvas,
         style: &Arc<Style>,
         underline_style: UnderlineStyle,
-        p1: Point,
-        p2: Point,
+        p1: PixelPos<f32>,
+        p2: PixelPos<f32>,
     ) {
         tracy_zone!("draw_underline");
         canvas.save();
@@ -275,11 +254,11 @@ impl GridRenderer {
         match underline_style {
             UnderlineStyle::Underline => {
                 underline_paint.set_path_effect(None);
-                canvas.draw_line(p1, p2, &underline_paint);
+                canvas.draw_line(to_skia_point(p1), to_skia_point(p2), &underline_paint);
             }
             UnderlineStyle::UnderDouble => {
                 underline_paint.set_path_effect(None);
-                canvas.draw_line(p1, p2, &underline_paint);
+                canvas.draw_line(to_skia_point(p1), to_skia_point(p2), &underline_paint);
                 let p1 = (p1.x, p1.y - 2.);
                 let p2 = (p2.x, p2.y - 2.);
                 canvas.draw_line(p1, p2, &underline_paint);
@@ -295,7 +274,7 @@ impl GridRenderer {
                 path.move_to(p1);
                 let mut i = p1.0;
                 let mut sin = -2. * stroke_width;
-                let increment = self.font_dimensions.width as f32 / 2.;
+                let increment = self.grid_scale.0.width / 2.;
                 while i < p2.0 {
                     sin *= -1.;
                     i += increment;
@@ -308,14 +287,14 @@ impl GridRenderer {
                     &[6.0 * stroke_width, 2.0 * stroke_width],
                     0.0,
                 ));
-                canvas.draw_line(p1, p2, &underline_paint);
+                canvas.draw_line(to_skia_point(p1), to_skia_point(p2), &underline_paint);
             }
             UnderlineStyle::UnderDot => {
                 underline_paint.set_path_effect(dash_path_effect::new(
                     &[1.0 * stroke_width, 1.0 * stroke_width],
                     0.0,
                 ));
-                canvas.draw_line(p1, p2, &underline_paint);
+                canvas.draw_line(to_skia_point(p1), to_skia_point(p2), &underline_paint);
             }
         }
 
diff --git a/src/renderer/mod.rs b/src/renderer/mod.rs
index 1917baf02c..a6034f44c1 100644
--- a/src/renderer/mod.rs
+++ b/src/renderer/mod.rs
@@ -17,7 +17,7 @@ use std::{
 };
 
 use log::error;
-use skia_safe::{Canvas, Point, Rect};
+use skia_safe::Canvas;
 use winit::{
     event::Event,
     event_loop::{EventLoop, EventLoopProxy},
@@ -26,10 +26,10 @@ use winit::{
 
 use crate::{
     bridge::EditorMode,
-    dimensions::Dimensions,
     editor::{Cursor, Style},
     profiling::{tracy_create_gpu_context, tracy_named_frame, tracy_zone},
     settings::*,
+    units::{to_skia_rect, GridPos, GridRect, GridSize, PixelPos},
     window::{ShouldRender, UserEvent},
     WindowSettings,
 };
@@ -163,7 +163,7 @@ impl Renderer {
     pub fn draw_frame(&mut self, root_canvas: &Canvas, dt: f32) {
         tracy_zone!("renderer_draw_frame");
         let default_background = self.grid_renderer.get_default_background();
-        let font_dimensions = self.grid_renderer.font_dimensions;
+        let grid_scale = self.grid_renderer.grid_scale;
 
         let transparency = { SETTINGS.get::<WindowSettings>().transparency };
         root_canvas.clear(default_background.with_a((255.0 * transparency) as u8));
@@ -171,7 +171,7 @@ impl Renderer {
         root_canvas.reset_matrix();
 
         if let Some(root_window) = self.rendered_windows.get(&1) {
-            let clip_rect = root_window.pixel_region(font_dimensions);
+            let clip_rect = to_skia_rect(&root_window.pixel_region(grid_scale));
             root_canvas.clip_rect(clip_rect, None, Some(false));
         }
 
@@ -203,7 +203,7 @@ impl Renderer {
                     root_canvas,
                     &settings,
                     default_background.with_a((255.0 * transparency) as u8),
-                    font_dimensions,
+                    grid_scale,
                     &mut floating_rects,
                 )
             })
@@ -217,12 +217,7 @@ impl Renderer {
         root_canvas.restore();
     }
 
-    pub fn animate_frame(
-        &mut self,
-        window_size: &Dimensions,
-        padding_as_grid: &Rect,
-        dt: f32,
-    ) -> bool {
+    pub fn animate_frame(&mut self, grid_rect: &GridRect<f32>, dt: f32) -> bool {
         let windows = {
             let (mut root_windows, mut floating_windows): (
                 Vec<&mut RenderedWindow>,
@@ -245,13 +240,13 @@ impl Renderer {
         // Clippy recommends short-circuiting with any which is not what we want
         #[allow(clippy::unnecessary_fold)]
         let mut animating = windows.fold(false, |acc, window| {
-            acc | window.animate(&settings, window_size, padding_as_grid, dt)
+            acc | window.animate(&settings, grid_rect, dt)
         });
 
         let windows = &self.rendered_windows;
-        let font_dimensions = self.grid_renderer.font_dimensions;
+        let grid_scale = self.grid_renderer.grid_scale;
         self.cursor_renderer
-            .update_cursor_destination(font_dimensions.into(), windows);
+            .update_cursor_destination(grid_scale, windows);
 
         animating |= self
             .cursor_renderer
@@ -326,16 +321,14 @@ impl Renderer {
                     }
                     Entry::Vacant(vacant_entry) => {
                         if let WindowDrawCommand::Position {
-                            grid_position: (grid_left, grid_top),
-                            grid_size: (width, height),
+                            grid_position,
+                            grid_size,
                             ..
                         } = command
                         {
-                            let new_window = RenderedWindow::new(
-                                grid_id,
-                                (grid_left as f32, grid_top as f32).into(),
-                                (width, height).into(),
-                            );
+                            let grid_position = GridPos::from(grid_position).try_cast().unwrap();
+                            let grid_size = GridSize::from(grid_size).try_cast().unwrap();
+                            let new_window = RenderedWindow::new(grid_id, grid_position, grid_size);
                             vacant_entry.insert(new_window);
                         } else {
                             error!("WindowDrawCommand sent for uninitialized grid {}", grid_id);
@@ -351,7 +344,7 @@ impl Renderer {
                 result.font_changed = true;
             }
             DrawCommand::LineSpaceChanged(new_linespace) => {
-                self.grid_renderer.update_linespace(new_linespace);
+                self.grid_renderer.update_linespace(new_linespace as f32);
                 result.font_changed = true;
             }
             DrawCommand::DefaultStyleChanged(new_style) => {
@@ -373,11 +366,11 @@ impl Renderer {
             .for_each(|(_, w)| w.flush(renderer_settings));
     }
 
-    pub fn get_cursor_position(&self) -> Point {
-        self.cursor_renderer.get_current_position()
+    pub fn get_cursor_destination(&self) -> PixelPos<f32> {
+        self.cursor_renderer.get_destination()
     }
 
-    pub fn get_grid_size(&self) -> Dimensions {
+    pub fn get_grid_size(&self) -> GridSize<u32> {
         if let Some(main_grid) = self.rendered_windows.get(&1) {
             main_grid.grid_size
         } else {
diff --git a/src/renderer/rendered_window.rs b/src/renderer/rendered_window.rs
index d0bb268261..412c9bf5d1 100644
--- a/src/renderer/rendered_window.rs
+++ b/src/renderer/rendered_window.rs
@@ -3,19 +3,17 @@ use std::{cell::RefCell, rc::Rc, sync::Arc};
 use skia_safe::{
     canvas::SaveLayerRec,
     image_filters::blur,
-    scalar,
     utils::shadow_utils::{draw_shadow, ShadowFlags},
-    BlendMode, Canvas, ClipOp, Color, Contains, Matrix, Paint, Path, Picture, PictureRecorder,
-    Point, Point3, Rect,
+    BlendMode, Canvas, ClipOp, Color, Matrix, Paint, Path, Picture, PictureRecorder, Point3, Rect,
 };
 
 use crate::{
     cmd_line::CmdLineSettings,
-    dimensions::Dimensions,
     editor::{AnchorInfo, Style, WindowType},
     profiling::{tracy_plot, tracy_zone},
     renderer::{animation_utils::*, GridRenderer, RendererSettings},
     settings::SETTINGS,
+    units::{to_skia_rect, GridPos, GridRect, GridScale, GridSize, PixelRect},
     utils::RingBuffer,
 };
 
@@ -85,16 +83,16 @@ pub struct RenderedWindow {
     pub anchor_info: Option<AnchorInfo>,
     window_type: WindowType,
 
-    pub grid_size: Dimensions,
+    pub grid_size: GridSize<u32>,
 
     scrollback_lines: RingBuffer<Option<Rc<RefCell<Line>>>>,
     actual_lines: RingBuffer<Option<Rc<RefCell<Line>>>>,
     scroll_delta: isize,
     pub viewport_margins: ViewportMargins,
 
-    grid_start_position: Point,
-    pub grid_current_position: Point,
-    grid_destination: Point,
+    grid_start_position: GridPos<f32>,
+    pub grid_current_position: GridPos<f32>,
+    grid_destination: GridPos<f32>,
     position_t: f32,
 
     pub scroll_animation: CriticallyDampedSpringAnimation,
@@ -105,7 +103,7 @@ pub struct RenderedWindow {
 #[derive(Clone, Debug)]
 pub struct WindowDrawDetails {
     pub id: u64,
-    pub region: Rect,
+    pub region: PixelRect<f32>,
 }
 
 impl WindowDrawDetails {
@@ -119,7 +117,7 @@ impl WindowDrawDetails {
 }
 
 impl RenderedWindow {
-    pub fn new(id: u64, grid_position: Point, grid_size: Dimensions) -> RenderedWindow {
+    pub fn new(id: u64, grid_position: GridPos<i32>, grid_size: GridSize<u32>) -> RenderedWindow {
         RenderedWindow {
             id,
             hidden: false,
@@ -137,9 +135,9 @@ impl RenderedWindow {
                 inferred: true,
             },
 
-            grid_start_position: grid_position,
-            grid_current_position: grid_position,
-            grid_destination: grid_position,
+            grid_start_position: grid_position.cast(),
+            grid_current_position: grid_position.cast(),
+            grid_destination: grid_position.cast(),
             position_t: 2.0, // 2.0 is out of the 0.0 to 1.0 range and stops animation.
 
             scroll_animation: CriticallyDampedSpringAnimation::new(),
@@ -148,64 +146,46 @@ impl RenderedWindow {
         }
     }
 
-    pub fn pixel_region(&self, font_dimensions: Dimensions) -> Rect {
-        let current_pixel_position = Point::new(
-            self.grid_current_position.x * font_dimensions.width as f32,
-            self.grid_current_position.y * font_dimensions.height as f32,
-        );
-
-        let image_size: (i32, i32) = (self.grid_size * font_dimensions).into();
-
-        Rect::from_point_and_size(current_pixel_position, image_size)
+    pub fn pixel_region(&self, grid_scale: GridScale) -> PixelRect<f32> {
+        GridRect::<f32>::from_origin_and_size(self.grid_current_position, self.grid_size.cast())
+            * grid_scale
     }
 
-    fn get_target_position(&self, outer_size: &Dimensions, padding_as_grid: &Rect) -> Point {
-        let destination = Point {
-            x: self.grid_destination.x + padding_as_grid.left,
-            y: self.grid_destination.y + padding_as_grid.top,
-        };
+    fn get_target_position(&self, grid_rect: &GridRect<f32>) -> GridPos<f32> {
+        let destination = self.grid_destination + grid_rect.min.to_vector();
 
         if self.anchor_info.is_none() {
             return destination;
         }
 
-        // Note the rect is always as far top/left as possible, which means that the right and
-        // bottom paddings might be bigger than requested. This is done in order to avoid the text
-        // moving around when the window is resized.
-        let valid_rect = Rect {
-            left: padding_as_grid.left,
-            right: padding_as_grid.left + outer_size.width as scalar,
-            top: padding_as_grid.top,
-            bottom: padding_as_grid.top + outer_size.height as scalar,
-        };
+        let mut grid_size: GridSize<f32> = self.grid_size.cast();
 
-        let mut grid_size = Point::new(self.grid_size.width as f32, self.grid_size.height as f32);
         if matches!(self.window_type, WindowType::Message { .. }) {
             // The message grid size is always the full window size, so use the relative position to
             // calculate the actual grid size
-            grid_size.y -= self.grid_destination.y;
+            grid_size.height -= self.grid_destination.y;
         }
-
+        // If a floating window is partially outside the grid, then move it in from the right, but
+        // ensure that the left edge is always visible.
         let x = destination
             .x
-            .min(valid_rect.right - grid_size.x)
-            .max(valid_rect.left);
+            .min(grid_rect.max.x - grid_size.width)
+            .max(grid_rect.min.x);
 
         // For messages the last line is most important, (it shows press enter), so let the position go negative
         // Otherwise ensure that the window start row is within the screen
-        let mut y = destination.y.min(valid_rect.bottom - grid_size.y);
-        if matches!(self.window_type, WindowType::Message { .. }) {
-            y = y.max(valid_rect.top)
+        let mut y = destination.y.min(grid_rect.max.y - grid_size.height);
+        if !matches!(self.window_type, WindowType::Message { .. }) {
+            y = y.max(grid_rect.min.y)
         }
-        Point { x, y }
+        GridPos::<f32>::new(x, y)
     }
 
     /// Returns `true` if the window has been animated in this step.
     pub fn animate(
         &mut self,
         settings: &RendererSettings,
-        outer_size: &Dimensions,
-        padding_as_grid: &Rect,
+        grid_rect: &GridRect<f32>,
         dt: f32,
     ) -> bool {
         let mut animating = false;
@@ -221,10 +201,11 @@ impl RenderedWindow {
         let prev_position = self.grid_current_position;
         self.grid_current_position = ease_point(
             ease_out_expo,
-            self.grid_start_position,
-            self.get_target_position(outer_size, padding_as_grid),
+            self.grid_start_position.cast_unit(),
+            self.get_target_position(grid_rect).cast_unit(),
             self.position_t,
-        );
+        )
+        .cast_unit();
         animating |= self.grid_current_position != prev_position;
 
         let scrolling = self
@@ -244,14 +225,14 @@ impl RenderedWindow {
         &mut self,
         canvas: &Canvas,
         pixel_region: &Rect,
-        font_dimensions: Dimensions,
+        grid_scale: GridScale,
         default_background: Color,
     ) {
         let scroll_offset_lines = self.scroll_animation.position.floor();
         let scroll_offset = scroll_offset_lines - self.scroll_animation.position;
         let scroll_offset_lines = scroll_offset_lines as isize;
-        let scroll_offset_pixels = (scroll_offset * font_dimensions.height as f32).round() as isize;
-        let line_height = font_dimensions.height as f32;
+        let scroll_offset_pixels = (scroll_offset * grid_scale.0.height).round() as isize;
+        let line_height = grid_scale.0.height;
         let mut has_transparency = false;
 
         let lines: Vec<(Matrix, &Rc<RefCell<Line>>)> = if !self.scrollback_lines.is_empty() {
@@ -268,7 +249,7 @@ impl RenderedWindow {
                         pixel_region.top()
                             + (scroll_offset_pixels
                                 + ((i + self.viewport_margins.top as isize)
-                                    * font_dimensions.height as isize))
+                                    * grid_scale.0.height as isize))
                                 as f32,
                     ));
                     (matrix, line)
@@ -299,7 +280,7 @@ impl RenderedWindow {
                 let mut matrix = Matrix::new_identity();
                 matrix.set_translate((
                     pixel_region.left(),
-                    pixel_region.top() + (i * font_dimensions.height as isize) as f32,
+                    pixel_region.top() + (i * grid_scale.0.height as isize) as f32,
                 ));
                 (matrix, line)
             })
@@ -377,19 +358,20 @@ impl RenderedWindow {
         root_canvas: &Canvas,
         settings: &RendererSettings,
         default_background: Color,
-        font_dimensions: Dimensions,
-        previous_floating_rects: &mut Vec<Rect>,
+        grid_scale: GridScale,
+        previous_floating_rects: &mut Vec<PixelRect<f32>>,
     ) -> WindowDrawDetails {
         let has_transparency = default_background.a() != 255 || self.has_transparency();
 
-        let pixel_region = self.pixel_region(font_dimensions);
+        let pixel_region_box = self.pixel_region(grid_scale);
+        let pixel_region = to_skia_rect(&pixel_region_box);
         let transparent_floating = self.anchor_info.is_some() && has_transparency;
 
         if self.anchor_info.is_some()
             && settings.floating_shadow
             && !previous_floating_rects
                 .iter()
-                .any(|rect| rect.contains(pixel_region))
+                .any(|rect| rect.contains_box(&pixel_region_box))
         {
             root_canvas.save();
             let shadow_path = Path::rect(pixel_region, None);
@@ -418,7 +400,7 @@ impl RenderedWindow {
                 Some(ShadowFlags::DIRECTIONAL_LIGHT),
             );
             root_canvas.restore();
-            previous_floating_rects.push(pixel_region);
+            previous_floating_rects.push(pixel_region_box);
         }
 
         root_canvas.save();
@@ -460,38 +442,33 @@ impl RenderedWindow {
 
         let save_layer_rec = SaveLayerRec::default().bounds(&pixel_region).paint(&paint);
         root_canvas.save_layer(&save_layer_rec);
-        self.draw_surface(
-            root_canvas,
-            &pixel_region,
-            font_dimensions,
-            default_background,
-        );
+        self.draw_surface(root_canvas, &pixel_region, grid_scale, default_background);
         root_canvas.restore();
 
         root_canvas.restore();
 
         WindowDrawDetails {
             id: self.id,
-            region: pixel_region,
+            region: pixel_region_box,
         }
     }
 
     pub fn handle_window_draw_command(&mut self, draw_command: WindowDrawCommand) {
         match draw_command {
             WindowDrawCommand::Position {
-                grid_position: (grid_left, grid_top),
+                grid_position,
                 grid_size,
                 anchor_info,
                 window_type,
             } => {
                 tracy_zone!("position_cmd", 0);
 
-                let grid_left = grid_left.max(0.0) as f32;
-                let grid_top = grid_top.max(0.0) as f32;
-                let new_destination: Point = (grid_left, grid_top).into();
-                let new_grid_size: Dimensions = grid_size.into();
+                let new_grid_size: GridSize<u32> =
+                    GridSize::<u64>::from(grid_size).try_cast().unwrap();
+                let grid_position: GridPos<f32> =
+                    GridPos::<f64>::from(grid_position).try_cast().unwrap();
 
-                if self.grid_destination != new_destination {
+                if self.grid_destination != grid_position {
                     if self.grid_start_position.x.abs() > f32::EPSILON
                         || self.grid_start_position.y.abs() > f32::EPSILON
                     {
@@ -501,9 +478,9 @@ impl RenderedWindow {
                         // We don't want to animate since the window is animating out of the start location,
                         // so we set t to 2.0 to stop animations.
                         self.position_t = 2.0;
-                        self.grid_start_position = new_destination;
+                        self.grid_start_position = grid_position;
                     }
-                    self.grid_destination = new_destination;
+                    self.grid_destination = grid_position;
                 }
 
                 let height = new_grid_size.height as usize;
@@ -525,8 +502,8 @@ impl RenderedWindow {
                     self.hidden = false;
                     self.position_t = 2.0; // We don't want to animate since the window is becoming visible,
                                            // so we set t to 2.0 to stop animations.
-                    self.grid_start_position = new_destination;
-                    self.grid_destination = new_destination;
+                    self.grid_start_position = grid_position;
+                    self.grid_destination = grid_position;
                 }
             }
             WindowDrawCommand::DrawLine {
@@ -588,9 +565,9 @@ impl RenderedWindow {
             } => {
                 tracy_zone!("scroll_cmd", 0);
                 if top == 0
-                    && bottom == self.grid_size.height
+                    && bottom == u64::from(self.grid_size.height)
                     && left == 0
-                    && right == self.grid_size.width
+                    && right == u64::from(self.grid_size.width)
                     && cols == 0
                 {
                     self.actual_lines.rotate(rows as isize);
@@ -722,7 +699,7 @@ impl RenderedWindow {
         if height == 0 {
             return;
         }
-        let font_dimensions = grid_renderer.font_dimensions;
+        let grid_scale = grid_renderer.grid_scale;
 
         let mut prepare_line = |line: &Rc<RefCell<Line>>| {
             let mut line = line.borrow_mut();
@@ -732,10 +709,8 @@ impl RenderedWindow {
 
             let mut recorder = PictureRecorder::new();
 
-            let grid_rect = Rect::from_wh(
-                (self.grid_size.width * font_dimensions.width) as f32,
-                font_dimensions.height as f32,
-            );
+            let line_size = GridSize::new(self.grid_size.width, 1).cast() * grid_scale;
+            let grid_rect = Rect::from_wh(line_size.width, line_size.height);
             let canvas = recorder.begin_recording(grid_rect, None);
 
             let mut has_transparency = false;
@@ -748,9 +723,13 @@ impl RenderedWindow {
                     style,
                     ..
                 } = line_fragment;
-                let grid_position = (*window_left, 0);
-                let background_info =
-                    grid_renderer.draw_background(canvas, grid_position, *width, style);
+                let grid_position = (i32::try_from(*window_left).unwrap(), 0).into();
+                let background_info = grid_renderer.draw_background(
+                    canvas,
+                    grid_position,
+                    i32::try_from(*width).unwrap(),
+                    style,
+                );
                 custom_background |= background_info.custom_color;
                 has_transparency |= background_info.transparent;
             }
@@ -766,10 +745,15 @@ impl RenderedWindow {
                     width,
                     style,
                 } = line_fragment;
-                let grid_position = (*window_left, 0);
+                let grid_position = (i32::try_from(*window_left).unwrap(), 0).into();
 
-                foreground_drawn |=
-                    grid_renderer.draw_foreground(canvas, text, grid_position, *width, style);
+                foreground_drawn |= grid_renderer.draw_foreground(
+                    canvas,
+                    text,
+                    grid_position,
+                    i32::try_from(*width).unwrap(),
+                    style,
+                );
             }
             let foreground_picture =
                 foreground_drawn.then_some(recorder.finish_recording_as_picture(None).unwrap());
diff --git a/src/settings/mod.rs b/src/settings/mod.rs
index d72256d53d..512d8db840 100644
--- a/src/settings/mod.rs
+++ b/src/settings/mod.rs
@@ -18,8 +18,8 @@ use winit::event_loop::EventLoopProxy;
 use crate::{bridge::NeovimWriter, window::UserEvent};
 pub use from_value::ParseFromValue;
 pub use window_size::{
-    load_last_window_settings, save_window_size, PersistentWindowSettings, DEFAULT_GRID_SIZE,
-    MAX_GRID_SIZE, MIN_GRID_SIZE,
+    clamped_grid_size, load_last_window_settings, save_window_size, PersistentWindowSettings,
+    DEFAULT_GRID_SIZE, MIN_GRID_SIZE,
 };
 
 mod config;
diff --git a/src/settings/window_size.rs b/src/settings/window_size.rs
index 32b2c61b25..b12dff9181 100644
--- a/src/settings/window_size.rs
+++ b/src/settings/window_size.rs
@@ -4,25 +4,14 @@ use serde::{Deserialize, Serialize};
 use winit::dpi::{PhysicalPosition, PhysicalSize};
 
 use crate::{
-    dimensions::Dimensions, settings::SETTINGS, window::WindowSettings, window::WinitWindowWrapper,
+    settings::SETTINGS, units::GridSize, window::WindowSettings, window::WinitWindowWrapper,
 };
 
 const SETTINGS_FILE: &str = "neovide-settings.json";
 
-pub const DEFAULT_GRID_SIZE: Dimensions = Dimensions {
-    width: 100,
-    height: 50,
-};
-
-pub const MIN_GRID_SIZE: Dimensions = Dimensions {
-    width: 20,
-    height: 6,
-};
-
-pub const MAX_GRID_SIZE: Dimensions = Dimensions {
-    width: 10000,
-    height: 1000,
-};
+pub const DEFAULT_GRID_SIZE: GridSize<u32> = GridSize::new(100, 50);
+pub const MIN_GRID_SIZE: GridSize<u32> = GridSize::new(20, 6);
+pub const MAX_GRID_SIZE: GridSize<u32> = GridSize::new(10000, 1000);
 
 #[derive(Serialize, Deserialize, Debug)]
 pub enum PersistentWindowSettings {
@@ -33,7 +22,7 @@ pub enum PersistentWindowSettings {
         #[serde(default)]
         pixel_size: Option<PhysicalSize<u32>>,
         #[serde(default)]
-        grid_size: Option<Dimensions>,
+        grid_size: Option<GridSize<u32>>,
     },
 }
 
@@ -104,3 +93,7 @@ pub fn save_window_size(window_wrapper: &WinitWindowWrapper) {
     std::fs::write(&settings_path, json)
         .unwrap_or_else(|_| panic!("Can't write to {settings_path:?}"));
 }
+
+pub fn clamped_grid_size(grid_size: &GridSize<u32>) -> GridSize<u32> {
+    grid_size.clamp(MIN_GRID_SIZE, MAX_GRID_SIZE)
+}
diff --git a/src/units.rs b/src/units.rs
new file mode 100644
index 0000000000..861dd13271
--- /dev/null
+++ b/src/units.rs
@@ -0,0 +1,109 @@
+use std::ops::{Div, Mul};
+
+use euclid::{Box2D, Point2D, Size2D, Vector2D};
+
+/// Coordinates in grid units (multiplies of the font size)
+pub struct Grid;
+/// Coordinates in pixel units
+pub struct Pixel;
+
+pub type GridVec<T> = Vector2D<T, Grid>;
+pub type PixelVec<T> = Vector2D<T, Pixel>;
+
+pub type GridSize<T> = Size2D<T, Grid>;
+pub type PixelSize<T> = Size2D<T, Pixel>;
+
+pub type GridPos<T> = Point2D<T, Grid>;
+pub type PixelPos<T> = Point2D<T, Pixel>;
+
+pub type GridRect<T> = Box2D<T, Grid>;
+pub type PixelRect<T> = Box2D<T, Pixel>;
+
+pub fn to_skia_point(pos: PixelPos<f32>) -> skia_safe::Point {
+    skia_safe::Point::new(pos.x, pos.y)
+}
+
+pub fn to_skia_rect(rect: &PixelRect<f32>) -> skia_safe::Rect {
+    skia_safe::Rect {
+        left: rect.min.x,
+        top: rect.min.y,
+        right: rect.max.x,
+        bottom: rect.max.y,
+    }
+}
+
+// The Euclid library doesn't support two dimensional scales, so make our own simplified one
+#[derive(Copy, Clone)]
+pub struct GridScale(pub PixelSize<f32>);
+
+impl Mul<GridScale> for GridVec<f32> {
+    type Output = PixelVec<f32>;
+
+    #[inline]
+    fn mul(self, scale: GridScale) -> Self::Output {
+        Self::Output::new(self.x * scale.0.width, self.y * scale.0.height)
+    }
+}
+
+impl Mul<GridScale> for GridSize<f32> {
+    type Output = PixelSize<f32>;
+
+    #[inline]
+    fn mul(self, scale: GridScale) -> Self::Output {
+        Self::Output::new(self.width * scale.0.width, self.height * scale.0.height)
+    }
+}
+
+impl Mul<GridScale> for GridPos<f32> {
+    type Output = PixelPos<f32>;
+
+    #[inline]
+    fn mul(self, scale: GridScale) -> Self::Output {
+        Self::Output::new(self.x * scale.0.width, self.y * scale.0.height)
+    }
+}
+
+impl Mul<GridScale> for GridRect<f32> {
+    type Output = PixelRect<f32>;
+
+    #[inline]
+    fn mul(self, scale: GridScale) -> Self::Output {
+        Self::Output::new(self.min * scale, self.max * scale)
+    }
+}
+
+impl Div<GridScale> for PixelVec<f32> {
+    type Output = GridVec<f32>;
+
+    #[inline]
+    fn div(self, scale: GridScale) -> Self::Output {
+        Self::Output::new(self.x / scale.0.width, self.y / scale.0.height)
+    }
+}
+
+impl Div<GridScale> for PixelSize<f32> {
+    type Output = GridSize<f32>;
+
+    #[inline]
+    fn div(self, scale: GridScale) -> Self::Output {
+        Self::Output::new(self.width / scale.0.width, self.height / scale.0.height)
+    }
+}
+
+impl Div<GridScale> for PixelPos<f32> {
+    type Output = GridPos<f32>;
+
+    #[inline]
+    fn div(self, scale: GridScale) -> Self::Output {
+        Self::Output::new(self.x / scale.0.width, self.y / scale.0.height)
+    }
+}
+
+impl Div<GridScale> for PixelRect<f32> {
+    type Output = GridRect<f32>;
+
+    #[inline]
+    fn div(self, scale: GridScale) -> Self::Output {
+        Self::Output::new(self.min / scale, self.max / scale)
+    }
+}
diff --git a/src/window/mod.rs b/src/window/mod.rs
index d152a4a0fc..6a31c31924 100644
--- a/src/window/mod.rs
+++ b/src/window/mod.rs
@@ -38,14 +38,14 @@ use update_loop::UpdateLoop;
 
 use crate::{
     cmd_line::{CmdLineSettings, GeometryArgs},
-    dimensions::Dimensions,
     frame::Frame,
     renderer::{build_window_config, DrawCommand, WindowConfig},
     running_tracker::*,
     settings::{
-        load_last_window_settings, save_window_size, FontSettings, HotReloadConfigs,
-        PersistentWindowSettings, SettingsChanged, SETTINGS,
+        clamped_grid_size, load_last_window_settings, save_window_size, FontSettings,
+        HotReloadConfigs, PersistentWindowSettings, SettingsChanged, SETTINGS,
     },
+    units::GridSize,
 };
 pub use error_window::show_error_window;
 pub use settings::{WindowSettings, WindowSettingsChanged};
@@ -244,7 +244,7 @@ pub fn create_window(
 pub enum WindowSize {
     Size(PhysicalSize<u32>),
     Maximized,
-    Grid(Dimensions),
+    Grid(GridSize<u32>),
     NeovimGrid, // The geometry is read from init.vim/lua
 }
 
@@ -255,7 +255,10 @@ pub fn determine_window_size(window_settings: Option<&PersistentWindowSettings>)
         GeometryArgs {
             grid: Some(Some(dimensions)),
             ..
-        } => WindowSize::Grid(dimensions.clamped_grid_size()),
+        } => WindowSize::Grid(clamped_grid_size(&GridSize::new(
+            dimensions.width.try_into().unwrap(),
+            dimensions.height.try_into().unwrap(),
+        ))),
         GeometryArgs {
             grid: Some(None), ..
         } => WindowSize::NeovimGrid,
diff --git a/src/window/mouse_manager.rs b/src/window/mouse_manager.rs
index fd0f5863bb..786314ef53 100644
--- a/src/window/mouse_manager.rs
+++ b/src/window/mouse_manager.rs
@@ -4,9 +4,7 @@ use std::{
     time::{Duration, Instant},
 };
 
-use skia_safe::Rect;
 use winit::{
-    dpi::PhysicalPosition,
     event::{
         DeviceId, ElementState, Event, MouseButton, MouseScrollDelta, Touch, TouchPhase,
         WindowEvent,
@@ -18,35 +16,20 @@ use crate::{
     bridge::{send_ui, SerialCommand},
     renderer::{Renderer, WindowDrawDetails},
     settings::SETTINGS,
+    units::{GridPos, GridScale, GridVec, PixelPos, PixelRect, PixelSize, PixelVec},
     window::keyboard_manager::KeyboardManager,
     window::{UserEvent, WindowSettings},
 };
 
 fn clamp_position(
-    position: PhysicalPosition<f32>,
-    region: Rect,
-    (font_width, font_height): (u64, u64),
-) -> PhysicalPosition<f32> {
-    PhysicalPosition::new(
-        position
-            .x
-            .min(region.right - font_width as f32)
-            .max(region.left),
-        position
-            .y
-            .min(region.bottom - font_height as f32)
-            .max(region.top),
-    )
-}
-
-fn to_grid_coords(
-    position: PhysicalPosition<f32>,
-    (font_width, font_height): (u64, u64),
-) -> PhysicalPosition<u32> {
-    PhysicalPosition::new(
-        (position.x as u64 / font_width) as u32,
-        (position.y as u64 / font_height) as u32,
-    )
+    position: PixelPos<f32>,
+    region: PixelRect<f32>,
+    grid_scale: GridScale,
+) -> PixelPos<f32> {
+    let min = region.min;
+    let max = region.max - grid_scale.0;
+
+    position.clamp(min, max)
 }
 
 fn mouse_button_to_button_text(mouse_button: &MouseButton) -> Option<String> {
@@ -63,20 +46,20 @@ fn mouse_button_to_button_text(mouse_button: &MouseButton) -> Option<String> {
 #[derive(Debug)]
 struct TouchTrace {
     start_time: Instant,
-    start: PhysicalPosition<f32>,
-    last: PhysicalPosition<f32>,
+    start: PixelPos<f32>,
+    last: PixelPos<f32>,
     left_deadzone_once: bool,
 }
 
 pub struct MouseManager {
     dragging: Option<String>,
-    drag_position: PhysicalPosition<u32>,
+    drag_position: GridPos<i32>,
 
     has_moved: bool,
-    position: PhysicalPosition<u32>,
-    relative_position: PhysicalPosition<u32>,
+    position: GridPos<i32>,
+    relative_position: GridPos<i32>,
 
-    scroll_position: PhysicalPosition<f32>,
+    scroll_position: GridPos<f32>,
 
     // the tuple allows to keep track of different fingers per device
     touch_position: HashMap<(DeviceId, u64), TouchTrace>,
@@ -92,10 +75,10 @@ impl MouseManager {
         MouseManager {
             dragging: None,
             has_moved: false,
-            position: PhysicalPosition::new(0, 0),
-            relative_position: PhysicalPosition::new(0, 0),
-            drag_position: PhysicalPosition::new(0, 0),
-            scroll_position: PhysicalPosition::new(0.0, 0.0),
+            position: GridPos::origin(),
+            relative_position: GridPos::origin(),
+            drag_position: GridPos::origin(),
+            scroll_position: GridPos::<f32>::origin(),
             touch_position: HashMap::new(),
             window_details_under_mouse: None,
             mouse_hidden: false,
@@ -105,19 +88,18 @@ impl MouseManager {
 
     fn handle_pointer_motion(
         &mut self,
-        x: i32,
-        y: i32,
+        position: PixelPos<f32>,
         keyboard_manager: &KeyboardManager,
         renderer: &Renderer,
         window: &Window,
     ) {
-        let size = window.inner_size();
-        if x < 0 || x as u32 >= size.width || y < 0 || y as u32 >= size.height {
+        let window_size = window.inner_size();
+        let window_size = PixelSize::new(window_size.width as f32, window_size.height as f32);
+        let relative_window_rect = PixelRect::from_size(window_size);
+        if !relative_window_rect.contains(position) {
             return;
         }
 
-        let position: PhysicalPosition<f32> = PhysicalPosition::new(x as f32, y as f32);
-
         // If dragging, the relevant window (the one which we send all commands to) is the one
         // which the mouse drag started on. Otherwise its the top rendered window
         let relevant_window_details = if self.dragging.is_some() {
@@ -135,38 +117,26 @@ impl MouseManager {
             renderer
                 .window_regions
                 .iter()
-                .filter(|details| {
-                    position.x >= details.region.left
-                        && position.x < details.region.right
-                        && position.y >= details.region.top
-                        && position.y < details.region.bottom
-                })
+                .filter(|details| details.region.contains(position))
                 .last()
         };
 
         let global_bounds = relevant_window_details
             .map(|details| details.region)
-            .unwrap_or_else(|| Rect::from_wh(size.width as f32, size.height as f32));
-        let clamped_position = clamp_position(
-            position,
-            global_bounds,
-            renderer.grid_renderer.font_dimensions.into(),
-        );
-
-        self.position = to_grid_coords(
-            clamped_position,
-            renderer.grid_renderer.font_dimensions.into(),
-        );
+            .unwrap_or_else(|| relative_window_rect.cast());
+        let clamped_position =
+            clamp_position(position, global_bounds, renderer.grid_renderer.grid_scale);
+
+        self.position = (clamped_position / renderer.grid_renderer.grid_scale)
+            .floor()
+            .cast();
 
         if let Some(relevant_window_details) = relevant_window_details {
-            let relative_position = PhysicalPosition::new(
-                clamped_position.x - relevant_window_details.region.left,
-                clamped_position.y - relevant_window_details.region.top,
-            );
-            self.relative_position = to_grid_coords(
-                relative_position,
-                renderer.grid_renderer.font_dimensions.into(),
-            );
+            let relative_position = clamped_position - relevant_window_details.region.min;
+            self.relative_position = (relative_position.to_point()
+                / renderer.grid_renderer.grid_scale)
+                .floor()
+                .cast();
 
             let previous_position = self.drag_position;
             self.drag_position = self.relative_position;
@@ -178,7 +148,7 @@ impl MouseManager {
                 send_ui(SerialCommand::Drag {
                     button: self.dragging.as_ref().unwrap().to_owned(),
                     grid_id: relevant_window_details.event_grid_id(),
-                    position: self.drag_position.into(),
+                    position: self.drag_position.try_cast().unwrap().to_tuple(),
                     modifier_string: keyboard_manager.format_modifier_string("", true),
                 });
             } else {
@@ -191,7 +161,7 @@ impl MouseManager {
                         button: "move".into(),
                         action: "".into(), // this is ignored by nvim
                         grid_id: relevant_window_details.event_grid_id(),
-                        position: self.relative_position.into(),
+                        position: self.relative_position.try_cast().unwrap().to_tuple(),
                         modifier_string: keyboard_manager.format_modifier_string("", true),
                     })
                 }
@@ -229,7 +199,7 @@ impl MouseManager {
                         button: button_text.clone(),
                         action,
                         grid_id: details.event_grid_id(),
-                        position: position.into(),
+                        position: position.try_cast().unwrap().to_tuple(),
                         modifier_string: keyboard_manager.format_modifier_string("", true),
                     });
                 }
@@ -247,16 +217,16 @@ impl MouseManager {
         }
     }
 
-    fn handle_line_scroll(&mut self, x: f32, y: f32, keyboard_manager: &KeyboardManager) {
+    fn handle_line_scroll(&mut self, amount: GridVec<f32>, keyboard_manager: &KeyboardManager) {
         if !self.enabled {
             return;
         }
 
-        let previous_y = self.scroll_position.y as i64;
-        self.scroll_position.y += y;
-        let new_y = self.scroll_position.y as i64;
+        let previous: GridPos<i32> = self.scroll_position.floor().cast().cast_unit();
+        self.scroll_position += amount;
+        let new: GridPos<i32> = self.scroll_position.floor().cast().cast_unit();
 
-        let vertical_input_type = match new_y.partial_cmp(&previous_y) {
+        let vertical_input_type = match new.y.partial_cmp(&previous.y) {
             Some(Ordering::Greater) => Some("up"),
             Some(Ordering::Less) => Some("down"),
             _ => None,
@@ -270,19 +240,15 @@ impl MouseManager {
                     .as_ref()
                     .map(|details| details.id)
                     .unwrap_or(0),
-                position: self.drag_position.into(),
+                position: self.drag_position.try_cast().unwrap().to_tuple(),
                 modifier_string: keyboard_manager.format_modifier_string("", true),
             };
-            for _ in 0..(new_y - previous_y).abs() {
+            for _ in 0..(new.y - previous.y).abs() {
                 send_ui(scroll_command.clone());
             }
         }
 
-        let previous_x = self.scroll_position.x as i64;
-        self.scroll_position.x += x;
-        let new_x = self.scroll_position.x as i64;
-
-        let horizontal_input_type = match new_x.partial_cmp(&previous_x) {
+        let horizontal_input_type = match new.x.partial_cmp(&previous.x) {
             Some(Ordering::Greater) => Some("left"),
             Some(Ordering::Less) => Some("right"),
             _ => None,
@@ -296,10 +262,10 @@ impl MouseManager {
                     .as_ref()
                     .map(|details| details.id)
                     .unwrap_or(0),
-                position: self.drag_position.into(),
+                position: self.drag_position.try_cast().unwrap().to_tuple(),
                 modifier_string: keyboard_manager.format_modifier_string("", true),
             };
-            for _ in 0..(new_x - previous_x).abs() {
+            for _ in 0..(new.x - previous.x).abs() {
                 send_ui(scroll_command.clone());
             }
         }
@@ -307,15 +273,12 @@ impl MouseManager {
 
     fn handle_pixel_scroll(
         &mut self,
-        (font_width, font_height): (u64, u64),
-        (pixel_x, pixel_y): (f32, f32),
+        grid_scale: GridScale,
+        amount: PixelVec<f32>,
         keyboard_manager: &KeyboardManager,
     ) {
-        self.handle_line_scroll(
-            pixel_x / font_width as f32,
-            pixel_y / font_height as f32,
-            keyboard_manager,
-        );
+        let amount = amount / grid_scale;
+        self.handle_line_scroll(amount, keyboard_manager);
     }
 
     fn handle_touch(
@@ -324,7 +287,7 @@ impl MouseManager {
         renderer: &Renderer,
         window: &Window,
         finger_id: (DeviceId, u64),
-        location: PhysicalPosition<f32>,
+        location: PixelPos<f32>,
         phase: &TouchPhase,
     ) {
         match phase {
@@ -367,8 +330,7 @@ impl MouseManager {
 
                     if self.dragging.is_some() || dragging_just_now {
                         self.handle_pointer_motion(
-                            location.x.round() as i32,
-                            location.y.round() as i32,
+                            (location.x, location.y).into(),
                             keyboard_manager,
                             renderer,
                             window,
@@ -377,21 +339,23 @@ impl MouseManager {
                     // the double check might seem useless, but the if branch above might set
                     // trace.left_deadzone_once - which urges to check again
                     else if trace.left_deadzone_once {
-                        let delta = (trace.last.x - location.x, location.y - trace.last.y);
+                        let delta = (trace.last.x - location.x, location.y - trace.last.y).into();
 
                         // not updating the position would cause the movement to "escalate" from the
                         // starting point
                         trace.last = location;
 
-                        let font_size = renderer.grid_renderer.font_dimensions.into();
-                        self.handle_pixel_scroll(font_size, delta, keyboard_manager);
+                        self.handle_pixel_scroll(
+                            renderer.grid_renderer.grid_scale,
+                            delta,
+                            keyboard_manager,
+                        );
                     }
                 }
 
                 if dragging_just_now {
                     self.handle_pointer_motion(
-                        location.x.round() as i32,
-                        location.y.round() as i32,
+                        (location.x, location.y).into(),
                         keyboard_manager,
                         renderer,
                         window,
@@ -406,8 +370,7 @@ impl MouseManager {
                     }
                     if !trace.left_deadzone_once {
                         self.handle_pointer_motion(
-                            trace.start.x.round() as i32,
-                            trace.start.y.round() as i32,
+                            (trace.start.x, trace.start.y).into(),
                             keyboard_manager,
                             renderer,
                             window,
@@ -433,8 +396,7 @@ impl MouseManager {
                 ..
             } => {
                 self.handle_pointer_motion(
-                    position.x as i32,
-                    position.y as i32,
+                    (position.x as f32, position.y as f32).into(),
                     keyboard_manager,
                     renderer,
                     window,
@@ -451,7 +413,7 @@ impl MouseManager {
                         ..
                     },
                 ..
-            } => self.handle_line_scroll(*x, *y, keyboard_manager),
+            } => self.handle_line_scroll((*x, *y).into(), keyboard_manager),
             Event::WindowEvent {
                 event:
                     WindowEvent::MouseWheel {
@@ -460,8 +422,8 @@ impl MouseManager {
                     },
                 ..
             } => self.handle_pixel_scroll(
-                renderer.grid_renderer.font_dimensions.into(),
-                (delta.x as f32, delta.y as f32),
+                renderer.grid_renderer.grid_scale,
+                (delta.x as f32, delta.y as f32).into(),
                 keyboard_manager,
             ),
             Event::WindowEvent {
@@ -479,7 +441,7 @@ impl MouseManager {
                 renderer,
                 window,
                 (*device_id, *id),
-                location.cast(),
+                PixelPos::new(location.x as f32, location.y as f32),
                 phase,
             ),
             Event::WindowEvent {
diff --git a/src/window/window_wrapper.rs b/src/window/window_wrapper.rs
index 67b405eedd..95bfdb6b36 100644
--- a/src/window/window_wrapper.rs
+++ b/src/window/window_wrapper.rs
@@ -6,13 +6,14 @@ use super::{
 use crate::windows_utils::{register_right_click, unregister_right_click};
 use crate::{
     bridge::{send_ui, ParallelCommand, SerialCommand},
-    dimensions::Dimensions,
     profiling::{tracy_frame, tracy_gpu_collect, tracy_gpu_zone, tracy_plot, tracy_zone},
     renderer::{create_skia_renderer, DrawCommand, Renderer, SkiaRenderer, VSync, WindowConfig},
     running_tracker::RUNNING_TRACKER,
     settings::{
-        FontSettings, HotReloadConfigs, SettingsChanged, DEFAULT_GRID_SIZE, MIN_GRID_SIZE, SETTINGS,
+        clamped_grid_size, FontSettings, HotReloadConfigs, SettingsChanged, DEFAULT_GRID_SIZE,
+        MIN_GRID_SIZE, SETTINGS,
     },
+    units::{GridPos, GridRect, GridSize, PixelPos, PixelSize},
     window::{ShouldRender, WindowSize},
     CmdLineSettings,
 };
@@ -24,9 +25,8 @@ use super::macos::MacosWindowFeature;
 use icrate::Foundation::MainThreadMarker;
 
 use log::trace;
-use skia_safe::{scalar, Rect};
 use winit::{
-    dpi::{PhysicalPosition, PhysicalSize, Position},
+    dpi,
     event::{Event, WindowEvent},
     event_loop::EventLoopProxy,
     window::{Fullscreen, Theme},
@@ -61,12 +61,12 @@ pub struct WinitWindowWrapper {
     title: String,
     fullscreen: bool,
     font_changed_last_frame: bool,
-    saved_inner_size: PhysicalSize<u32>,
-    saved_grid_size: Option<Dimensions>,
+    saved_inner_size: dpi::PhysicalSize<u32>,
+    saved_grid_size: Option<GridSize<u32>>,
     ime_enabled: bool,
-    ime_position: PhysicalPosition<i32>,
-    requested_columns: Option<u64>,
-    requested_lines: Option<u64>,
+    ime_position: dpi::PhysicalPosition<i32>,
+    requested_columns: Option<u32>,
+    requested_lines: Option<u32>,
     ui_state: UIState,
     window_padding: WindowPadding,
     initial_window_size: WindowSize,
@@ -97,7 +97,7 @@ impl WinitWindowWrapper {
         log::info!(
             "window created (scale_factor: {:.4}, font_dimensions: {:?})",
             scale_factor,
-            renderer.grid_renderer.font_dimensions,
+            renderer.grid_renderer.grid_scale.0,
         );
 
         let WindowSettings {
@@ -142,7 +142,7 @@ impl WinitWindowWrapper {
             saved_inner_size,
             saved_grid_size: None,
             ime_enabled: input_ime,
-            ime_position: PhysicalPosition::new(-1, -1),
+            ime_position: dpi::PhysicalPosition::new(-1, -1),
             requested_columns: None,
             requested_lines: None,
             ui_state: UIState::Initing,
@@ -217,11 +217,11 @@ impl WinitWindowWrapper {
         match changed_setting {
             WindowSettingsChanged::ObservedColumns(columns) => {
                 log::info!("columns changed");
-                self.requested_columns = columns;
+                self.requested_columns = columns.map(|v| v.try_into().unwrap());
             }
             WindowSettingsChanged::ObservedLines(lines) => {
                 log::info!("lines changed");
-                self.requested_lines = lines;
+                self.requested_lines = lines.map(|v| v.try_into().unwrap());
             }
             WindowSettingsChanged::Fullscreen(fullscreen) => {
                 if self.fullscreen != fullscreen {
@@ -415,11 +415,9 @@ impl WinitWindowWrapper {
     pub fn animate_frame(&mut self, dt: f32) -> bool {
         tracy_zone!("animate_frame", 0);
 
-        let res = self.renderer.animate_frame(
-            &self.get_grid_size_from_window(0, 0),
-            &self.padding_as_grid(),
-            dt,
-        );
+        let res = self
+            .renderer
+            .animate_frame(&self.get_grid_rect_from_window(GridSize::zero()).cast(), dt);
         tracy_plot!("animate_frame", res as u8 as f64);
         self.renderer.prepare_lines();
         #[allow(clippy::let_and_return)]
@@ -441,7 +439,7 @@ impl WinitWindowWrapper {
                     self.skia_renderer.window().set_visible(true);
                     self.skia_renderer.window().set_maximized(true);
                 }
-                WindowSize::Grid(Dimensions { width, height }) => {
+                WindowSize::Grid(GridSize { width, height, .. }) => {
                     self.requested_columns = Some(width);
                     self.requested_lines = Some(height);
                     log::info!("Showing window {width}, {height}");
@@ -527,66 +525,74 @@ impl WinitWindowWrapper {
         should_render
     }
 
-    pub fn get_grid_size(&self) -> Dimensions {
+    pub fn get_grid_size(&self) -> GridSize<u32> {
         self.renderer.get_grid_size()
     }
 
     fn update_window_size_from_grid(&mut self, window_padding: &WindowPadding) {
         let window = self.skia_renderer.window();
 
-        let window_padding_width = window_padding.left + window_padding.right;
-        let window_padding_height = window_padding.top + window_padding.bottom;
+        let window_padding_size = PixelSize::new(
+            window_padding.left + window_padding.right,
+            window_padding.top + window_padding.bottom,
+        );
 
-        let grid_size = Dimensions {
-            width: self.requested_columns.take().unwrap_or(
+        let grid_size = clamped_grid_size(&GridSize::new(
+            self.requested_columns.take().unwrap_or(
                 self.saved_grid_size
                     .map_or(DEFAULT_GRID_SIZE.width, |v| v.width),
             ),
-            height: self.requested_lines.take().unwrap_or(
+            self.requested_lines.take().unwrap_or(
                 self.saved_grid_size
                     .map_or(DEFAULT_GRID_SIZE.height, |v| v.height),
             ),
-        };
+        ));
+
+        let new_size = (grid_size.cast() * self.renderer.grid_renderer.grid_scale)
+            .floor()
+            .cast()
+            .cast_unit()
+            + window_padding_size;
 
-        let mut new_size = self
-            .renderer
-            .grid_renderer
-            .convert_grid_to_physical(grid_size);
-        new_size.width += window_padding_width;
-        new_size.height += window_padding_height;
         log::info!(
             "Resizing window based on grid. Grid Size: {:?}, Window Size {:?}",
             grid_size,
             new_size
         );
+        let new_size = winit::dpi::PhysicalSize {
+            width: new_size.width,
+            height: new_size.height,
+        };
         let _ = window.request_inner_size(new_size);
     }
 
-    fn get_grid_size_from_window(&self, min_width: u64, min_height: u64) -> Dimensions {
+    fn get_grid_size_from_window(&self, min: GridSize<u32>) -> GridSize<u32> {
         let window_padding = self.window_padding;
-        let window_padding_width = window_padding.left + window_padding.right;
-        let window_padding_height = window_padding.top + window_padding.bottom;
+        let window_padding_size: PixelSize<u32> = PixelSize::new(
+            window_padding.left + window_padding.right,
+            window_padding.top + window_padding.bottom,
+        );
 
-        let content_size = PhysicalSize {
-            width: self.saved_inner_size.width - window_padding_width,
-            height: self.saved_inner_size.height - window_padding_height,
-        };
+        let content_size =
+            PixelSize::new(self.saved_inner_size.width, self.saved_inner_size.height)
+                - window_padding_size;
 
-        let grid_size = self
-            .renderer
-            .grid_renderer
-            .convert_physical_to_grid(content_size);
+        let grid_size = (content_size.cast() / self.renderer.grid_renderer.grid_scale)
+            .floor()
+            .cast();
 
-        Dimensions {
-            width: grid_size.width.max(min_width),
-            height: grid_size.height.max(min_height),
-        }
+        grid_size.max(min)
+    }
+
+    fn get_grid_rect_from_window(&self, min: GridSize<u32>) -> GridRect<f32> {
+        let size = self.get_grid_size_from_window(min).cast();
+        let pos = PixelPos::new(self.window_padding.left, self.window_padding.top).cast()
+            / self.renderer.grid_renderer.grid_scale;
+        GridRect::<f32>::from_origin_and_size(pos, size)
     }
 
     fn update_grid_size_from_window(&mut self) {
-        let min_width = MIN_GRID_SIZE.width;
-        let min_height = MIN_GRID_SIZE.height;
-        let grid_size = self.get_grid_size_from_window(min_width, min_height);
+        let grid_size = self.get_grid_size_from_window(MIN_GRID_SIZE);
 
         if self.saved_grid_size.as_ref() == Some(&grid_size) {
             trace!("Grid matched saved size, skip update.");
@@ -599,23 +605,26 @@ impl WinitWindowWrapper {
             self.saved_inner_size
         );
         send_ui(ParallelCommand::Resize {
-            width: grid_size.width,
-            height: grid_size.height,
+            width: grid_size.width.into(),
+            height: grid_size.height.into(),
         });
     }
 
     fn update_ime_position(&mut self) {
-        let font_dimensions = self.renderer.grid_renderer.font_dimensions;
-        let cursor_position = self.renderer.get_cursor_position();
-        let position = PhysicalPosition::new(
-            cursor_position.x.round() as i32,
-            cursor_position.y.round() as i32 + font_dimensions.height as i32,
-        );
+        let grid_scale = self.renderer.grid_renderer.grid_scale;
+        let font_dimensions = grid_scale.0;
+        let mut position = self.renderer.get_cursor_destination();
+        position.y += font_dimensions.height;
+        let position: GridPos<i32> = (position / grid_scale).floor().cast();
+        let position = dpi::PhysicalPosition {
+            x: position.x,
+            y: position.y,
+        };
         if position != self.ime_position {
             self.ime_position = position;
             self.skia_renderer.window().set_ime_cursor_area(
-                Position::Physical(position),
-                PhysicalSize::new(100, font_dimensions.height as u32),
+                dpi::Position::Physical(position),
+                dpi::PhysicalSize::new(100, font_dimensions.height as u32),
             );
         }
     }
@@ -626,14 +635,4 @@ impl WinitWindowWrapper {
         self.renderer.handle_os_scale_factor_change(scale_factor);
         self.skia_renderer.resize();
     }
-
-    fn padding_as_grid(&self) -> Rect {
-        let font_dimensions = self.renderer.grid_renderer.font_dimensions;
-        Rect {
-            left: self.window_padding.left as scalar / font_dimensions.width as scalar,
-            right: self.window_padding.right as scalar / font_dimensions.width as scalar,
-            top: self.window_padding.top as scalar / font_dimensions.height as scalar,
-            bottom: self.window_padding.bottom as scalar / font_dimensions.height as scalar,
-        }
-    }
 }