diff --git a/frontend/src/app/main/ui/workspace/viewport_wasm.cljs b/frontend/src/app/main/ui/workspace/viewport_wasm.cljs
index d5deb50c14..579b27c10b 100644
--- a/frontend/src/app/main/ui/workspace/viewport_wasm.cljs
+++ b/frontend/src/app/main/ui/workspace/viewport_wasm.cljs
@@ -270,7 +270,6 @@
         offset-y (if selecting-first-level-frame?
                    (:y first-shape)
                    (:y selected-frame))
-
         rule-area-size (/ rulers/ruler-area-size zoom)
         preview-blend (-> refs/workspace-preview-blend
                           (mf/deref))]
@@ -291,7 +290,7 @@
 
     (mf/with-effect [vport]
       (when @canvas-init?
-        (wasm.api/resize-canvas (:width vport) (:height vport))))
+        (wasm.api/resize-viewbox (:width vport) (:height vport))))
 
     (mf/with-effect [base-objects canvas-init?]
       (when @canvas-init?
@@ -351,8 +350,8 @@
                :ref canvas-ref
                :class (stl/css :render-shapes)
                :key (dm/str "render" page-id)
-               :width (:width vport 0)
-               :height (:height vport 0)
+               :width (* wasm.api/dpr (:width vport 0))
+               :height (* wasm.api/dpr (:height vport 0))
                :style {:background-color background
                        :pointer-events "none"}}]
 
diff --git a/frontend/src/app/render_wasm/api.cljs b/frontend/src/app/render_wasm/api.cljs
index 350de85aab..ac111c588f 100644
--- a/frontend/src/app/render_wasm/api.cljs
+++ b/frontend/src/app/render_wasm/api.cljs
@@ -16,6 +16,10 @@
 
 (defonce internal-frame-id nil)
 (defonce internal-module #js {})
+(defonce use-dpr? (contains? cf/flags :render-wasm-dpr))
+
+(def dpr
+  (if use-dpr? js/window.devicePixelRatio 1.0))
 
 ;; This should never be called from the outside.
 ;; This function receives a "time" parameter that we're not using but maybe in the future could be useful (it is the time since
@@ -169,31 +173,31 @@
        :stencil true
        :alpha true})
 
+
 (defn clear-canvas
   []
   ;; TODO: perform corresponding cleaning
   )
 
-(defn resize-canvas
+(defn resize-viewbox
   [width height]
-  (h/call internal-module "_resize_canvas" width height))
+  (h/call internal-module "_resize_viewbox" width height))
 
 (defn assign-canvas
   [canvas]
   (let [gl      (unchecked-get internal-module "GL")
-        init-fn (unchecked-get internal-module "_init")
-
         context (.getContext ^js canvas "webgl2" canvas-options)
 
         ;; Register the context with emscripten
         handle  (.registerContext ^js gl context #js {"majorVersion" 2})]
     (.makeContextCurrent ^js gl handle)
-    ;; Initialize Skia
-    (^function init-fn (.-width ^js canvas)
-                       (.-height ^js canvas)
-                       1)
-    (set! (.-width canvas) (.-clientWidth ^js canvas))
-    (set! (.-height canvas) (.-clientHeight ^js canvas))))
+
+    ;; Initialize Wasm Render Engine
+    (h/call internal-module "_init" (/ (.-width ^js canvas) dpr) (/ (.-height ^js canvas) dpr))
+    (h/call internal-module "_set_render_options" 0x01 dpr))
+
+  (set! (.-width canvas) (* dpr (.-clientWidth ^js canvas)))
+  (set! (.-height canvas) (* dpr (.-clientHeight ^js canvas))))
 
 (defonce module
   (if (exists? js/dynamicImport)
diff --git a/render-wasm/src/main.rs b/render-wasm/src/main.rs
index ef91740b37..76bd2bc742 100644
--- a/render-wasm/src/main.rs
+++ b/render-wasm/src/main.rs
@@ -1,11 +1,11 @@
-pub mod debug;
-pub mod images;
-pub mod math;
-pub mod render;
-pub mod shapes;
-pub mod state;
-pub mod utils;
-pub mod view;
+mod debug;
+mod images;
+mod math;
+mod render;
+mod shapes;
+mod state;
+mod utils;
+mod view;
 
 use skia_safe as skia;
 
@@ -31,13 +31,22 @@ fn init_gl() {
 
 /// This is called from JS after the WebGL context has been created.
 #[no_mangle]
-pub extern "C" fn init(width: i32, height: i32, debug: u32) {
-    let state_box = Box::new(State::with_capacity(width, height, debug, 2048));
+pub extern "C" fn init(width: i32, height: i32) {
+    let state_box = Box::new(State::new(width, height, 2048));
     unsafe {
         STATE = Some(state_box);
     }
 }
 
+#[no_mangle]
+pub extern "C" fn set_render_options(debug: u32, dpr: f32) {
+    let state = unsafe { STATE.as_mut() }.expect("got an invalid state pointer");
+    let render_state = state.render_state();
+
+    render_state.set_debug_flags(debug);
+    render_state.set_dpr(dpr);
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn render() {
     let state = unsafe { STATE.as_mut() }.expect("got an invalid state pointer");
@@ -63,7 +72,7 @@ pub extern "C" fn reset_canvas() {
 }
 
 #[no_mangle]
-pub extern "C" fn resize_canvas(width: i32, height: i32) {
+pub extern "C" fn resize_viewbox(width: i32, height: i32) {
     let state = unsafe { STATE.as_mut() }.expect("got an invalid state pointer");
     state.resize(width, height);
 }
@@ -71,19 +80,19 @@ pub extern "C" fn resize_canvas(width: i32, height: i32) {
 #[no_mangle]
 pub extern "C" fn set_view(zoom: f32, x: f32, y: f32) {
     let state = unsafe { STATE.as_mut() }.expect("got an invalid state pointer");
-    state.viewbox.set_all(zoom, x, y);
+    state.render_state().viewbox.set_all(zoom, x, y);
 }
 
 #[no_mangle]
 pub extern "C" fn set_view_zoom(zoom: f32) {
     let state = unsafe { STATE.as_mut() }.expect("got an invalid state pointer");
-    state.viewbox.set_zoom(zoom);
+    state.render_state().viewbox.set_zoom(zoom);
 }
 
 #[no_mangle]
 pub extern "C" fn set_view_xy(x: f32, y: f32) {
     let state = unsafe { STATE.as_mut() }.expect("got an invalid state pointer");
-    state.viewbox.set_xy(x, y);
+    state.render_state().viewbox.set_pan_xy(x, y);
 }
 
 #[no_mangle]
diff --git a/render-wasm/src/render.rs b/render-wasm/src/render.rs
index 4c6074c8d5..3573190df9 100644
--- a/render-wasm/src/render.rs
+++ b/render-wasm/src/render.rs
@@ -55,8 +55,38 @@ impl GpuState {
 pub(crate) struct CachedSurfaceImage {
     pub image: Image,
     pub viewbox: Viewbox,
-    // is_complete indicates if stored image renders the complete shape tree
-    pub is_complete: bool,
+    has_all_shapes: bool,
+}
+
+impl CachedSurfaceImage {
+    fn is_dirty(&self, viewbox: &Viewbox) -> bool {
+        !self.has_all_shapes && !self.viewbox.area.contains(viewbox.area)
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+struct RenderOptions {
+    debug_flags: u32,
+    dpr: Option<f32>,
+}
+
+impl Default for RenderOptions {
+    fn default() -> Self {
+        Self {
+            debug_flags: 0x00,
+            dpr: None,
+        }
+    }
+}
+
+impl RenderOptions {
+    pub fn is_debug_visible(&self) -> bool {
+        self.debug_flags & debug::DEBUG_VISIBLE == debug::DEBUG_VISIBLE
+    }
+
+    pub fn dpr(&self) -> f32 {
+        self.dpr.unwrap_or(1.0)
+    }
 }
 
 pub(crate) struct RenderState {
@@ -65,6 +95,8 @@ pub(crate) struct RenderState {
     pub drawing_surface: skia::Surface,
     pub debug_surface: skia::Surface,
     pub cached_surface_image: Option<CachedSurfaceImage>,
+    options: RenderOptions,
+    pub viewbox: Viewbox,
 }
 
 impl RenderState {
@@ -85,20 +117,41 @@ impl RenderState {
             drawing_surface,
             debug_surface,
             cached_surface_image: None,
+            options: RenderOptions::default(),
+            viewbox: Viewbox::new(width as f32, height as f32),
+        }
+    }
+
+    pub fn set_debug_flags(&mut self, debug: u32) {
+        self.options.debug_flags = debug;
+    }
+
+    pub fn set_dpr(&mut self, dpr: f32) {
+        if Some(dpr) != self.options.dpr {
+            self.options.dpr = Some(dpr);
+            self.resize(
+                self.viewbox.width.floor() as i32,
+                self.viewbox.height.floor() as i32,
+            );
         }
     }
 
     pub fn resize(&mut self, width: i32, height: i32) {
-        let surface = self.gpu_state.create_target_surface(width, height);
+        let dpr_width = (width as f32 * self.options.dpr()).floor() as i32;
+        let dpr_height = (height as f32 * self.options.dpr()).floor() as i32;
+
+        let surface = self.gpu_state.create_target_surface(dpr_width, dpr_height);
         self.final_surface = surface;
         self.drawing_surface = self
             .final_surface
-            .new_surface_with_dimensions((width, height))
+            .new_surface_with_dimensions((dpr_width, dpr_height))
             .unwrap();
         self.debug_surface = self
             .final_surface
-            .new_surface_with_dimensions((width, height))
+            .new_surface_with_dimensions((dpr_width, dpr_height))
             .unwrap();
+
+        self.viewbox.set_wh(width as f32, height as f32);
     }
 
     pub fn flush(&mut self) {
@@ -176,87 +229,95 @@ impl RenderState {
             .clear(skia::Color::TRANSPARENT);
     }
 
-    pub fn navigate(&mut self, viewbox: &Viewbox, shapes: &HashMap<Uuid, Shape>, debug: u32) {
-        self.reset_canvas();
-        if let Some(cached_surface_image) = &self.cached_surface_image {
-            // If we are drawing something bigger than the visible let's do a redraw
-            if !cached_surface_image.is_complete
-                && ((viewbox.x > cached_surface_image.viewbox.x)
-                    || (-viewbox.x + viewbox.area.width()
-                        > -cached_surface_image.viewbox.x
-                            + cached_surface_image.viewbox.area.width())
-                    || (viewbox.y > cached_surface_image.viewbox.y)
-                    || (-viewbox.y + viewbox.area.height()
-                        > -cached_surface_image.viewbox.y
-                            + cached_surface_image.viewbox.area.height()))
-            {
-                self.render_all(viewbox, shapes, true, debug);
+    pub fn navigate(&mut self, shapes: &HashMap<Uuid, Shape>) -> Result<(), String> {
+        if let Some(cached_surface_image) = self.cached_surface_image.as_ref() {
+            if cached_surface_image.is_dirty(&self.viewbox) {
+                self.render_all(shapes, true);
             } else {
-                let image = &cached_surface_image.image;
-                let paint = skia::Paint::default();
-                self.final_surface.canvas().save();
-                self.drawing_surface.canvas().save();
-
-                let navigate_zoom = viewbox.zoom / cached_surface_image.viewbox.zoom;
-                let navigate_x = cached_surface_image.viewbox.zoom
-                    * (viewbox.x - cached_surface_image.viewbox.x);
-                let navigate_y = cached_surface_image.viewbox.zoom
-                    * (viewbox.y - cached_surface_image.viewbox.y);
-
-                self.final_surface
-                    .canvas()
-                    .scale((navigate_zoom, navigate_zoom));
-                self.final_surface
-                    .canvas()
-                    .translate((navigate_x, navigate_y));
-                self.final_surface
-                    .canvas()
-                    .draw_image(image.clone(), (0, 0), Some(&paint));
-
-                self.final_surface.canvas().restore();
-                self.drawing_surface.canvas().restore();
+                self.render_all_from_cache()?;
             }
         }
 
-        self.flush();
+        Ok(())
     }
 
     pub fn render_all(
         &mut self,
-        viewbox: &Viewbox,
         shapes: &HashMap<Uuid, Shape>,
         generate_cached_surface_image: bool,
-        debug: u32, // Debug flags
     ) {
         self.reset_canvas();
-        self.scale(viewbox.zoom, viewbox.zoom);
-        self.translate(viewbox.x, viewbox.y);
-        let is_complete = self.render_shape_tree(&Uuid::nil(), viewbox, shapes);
+        self.scale(
+            self.viewbox.zoom * self.options.dpr(),
+            self.viewbox.zoom * self.options.dpr(),
+        );
+        self.translate(self.viewbox.pan_x, self.viewbox.pan_y);
+
+        let is_complete = self.render_shape_tree(&Uuid::nil(), shapes);
         if generate_cached_surface_image || self.cached_surface_image.is_none() {
             self.cached_surface_image = Some(CachedSurfaceImage {
                 image: self.final_surface.image_snapshot(),
-                viewbox: viewbox.clone(),
-                is_complete,
+                viewbox: self.viewbox,
+                has_all_shapes: is_complete,
             });
         }
-        if debug & debug::DEBUG_VISIBLE == debug::DEBUG_VISIBLE {
-            self.render_debug(viewbox);
+
+        if self.options.is_debug_visible() {
+            self.render_debug();
         }
 
         self.flush();
     }
 
-    fn render_debug_view(&mut self, viewbox: &Viewbox) {
+    fn render_all_from_cache(&mut self) -> Result<(), String> {
+        self.reset_canvas();
+
+        let cached = self
+            .cached_surface_image
+            .as_ref()
+            .ok_or("Uninitialized cached surface image")?;
+
+        let image = &cached.image;
+        let paint = skia::Paint::default();
+        self.final_surface.canvas().save();
+        self.drawing_surface.canvas().save();
+
+        let navigate_zoom = self.viewbox.zoom / cached.viewbox.zoom;
+        let navigate_x = cached.viewbox.zoom * (self.viewbox.pan_x - cached.viewbox.pan_x);
+        let navigate_y = cached.viewbox.zoom * (self.viewbox.pan_y - cached.viewbox.pan_y);
+
+        self.final_surface
+            .canvas()
+            .scale((navigate_zoom, navigate_zoom));
+        self.final_surface.canvas().translate((
+            navigate_x * self.options.dpr(),
+            navigate_y * self.options.dpr(),
+        ));
+        self.final_surface
+            .canvas()
+            .draw_image(image.clone(), (0, 0), Some(&paint));
+
+        self.final_surface.canvas().restore();
+        self.drawing_surface.canvas().restore();
+
+        self.flush();
+
+        Ok(())
+    }
+
+    fn render_debug_view(&mut self) {
         let mut paint = skia::Paint::default();
         paint.set_style(skia::PaintStyle::Stroke);
         paint.set_color(skia::Color::from_argb(255, 255, 0, 255));
         paint.set_stroke_width(1.);
-        let mut scaled_rect = viewbox.area.clone();
+
+        let mut scaled_rect = self.viewbox.area.clone();
         let x = 100. + scaled_rect.x() * 0.2;
         let y = 100. + scaled_rect.y() * 0.2;
         let width = scaled_rect.width() * 0.2;
         let height = scaled_rect.height() * 0.2;
         scaled_rect.set_xywh(x, y, width, height);
+
         self.debug_surface.canvas().draw_rect(scaled_rect, &paint);
     }
 
@@ -269,18 +330,20 @@ impl RenderState {
             skia::Color::from_argb(255, 0, 255, 255)
         });
         paint.set_stroke_width(1.);
+
         let mut scaled_rect = shape.selrect.clone();
         let x = 100. + scaled_rect.x() * 0.2;
         let y = 100. + scaled_rect.y() * 0.2;
         let width = scaled_rect.width() * 0.2;
         let height = scaled_rect.height() * 0.2;
         scaled_rect.set_xywh(x, y, width, height);
+
         self.debug_surface.canvas().draw_rect(scaled_rect, &paint);
     }
 
-    fn render_debug(&mut self, viewbox: &Viewbox) {
+    fn render_debug(&mut self) {
         let paint = skia::Paint::default();
-        self.render_debug_view(viewbox);
+        self.render_debug_view();
         self.debug_surface.draw(
             &mut self.final_surface.canvas(),
             (0.0, 0.0),
@@ -290,21 +353,16 @@ impl RenderState {
     }
 
     // Returns a boolean indicating if the viewbox contains the rendered shapes
-    fn render_shape_tree(
-        &mut self,
-        id: &Uuid,
-        viewbox: &Viewbox,
-        shapes: &HashMap<Uuid, Shape>,
-    ) -> bool {
+    fn render_shape_tree(&mut self, id: &Uuid, shapes: &HashMap<Uuid, Shape>) -> bool {
         let shape = shapes.get(&id).unwrap();
-        let mut is_complete = viewbox.area.contains(shape.selrect);
+        let mut is_complete = self.viewbox.area.contains(shape.selrect);
 
         if !id.is_nil() {
-            if !shape.selrect.intersects(viewbox.area) {
+            if !shape.selrect.intersects(self.viewbox.area) {
                 self.render_debug_shape(shape, false);
                 // TODO: This means that not all the shapes are renderer so we
                 // need to call a render_all on the zoom out.
-                return is_complete;
+                return is_complete; // TODO return is_complete or return false??
             } else {
                 self.render_debug_shape(shape, true);
             }
@@ -321,7 +379,7 @@ impl RenderState {
         // draw all the children shapes
         let shape_ids = shape.children.iter();
         for shape_id in shape_ids {
-            is_complete = self.render_shape_tree(shape_id, viewbox, shapes) && is_complete;
+            is_complete = self.render_shape_tree(shape_id, shapes) && is_complete;
         }
 
         self.final_surface.canvas().restore();
diff --git a/render-wasm/src/state.rs b/render-wasm/src/state.rs
index 2f602c970f..024ed8898a 100644
--- a/render-wasm/src/state.rs
+++ b/render-wasm/src/state.rs
@@ -1,10 +1,8 @@
 use std::collections::HashMap;
 use uuid::Uuid;
 
-use crate::math;
 use crate::render::RenderState;
 use crate::shapes::Shape;
-use crate::view::Viewbox;
 
 /// This struct holds the state of the Rust application between JS calls.
 ///
@@ -12,36 +10,24 @@ use crate::view::Viewbox;
 /// Note that rust-skia data structures are not thread safe, so a state
 /// must not be shared between different Web Workers.
 pub(crate) struct State<'a> {
-    pub debug: u32,
     pub render_state: RenderState,
     pub current_id: Option<Uuid>,
     pub current_shape: Option<&'a mut Shape>,
     pub shapes: HashMap<Uuid, Shape>,
-    pub viewbox: Viewbox,
 }
 
 impl<'a> State<'a> {
-    pub fn with_capacity(width: i32, height: i32, debug: u32, capacity: usize) -> Self {
+    pub fn new(width: i32, height: i32, capacity: usize) -> Self {
         State {
-            debug,
             render_state: RenderState::new(width, height),
             current_id: None,
             current_shape: None,
             shapes: HashMap::with_capacity(capacity),
-            viewbox: Viewbox {
-                x: 0.,
-                y: 0.,
-                zoom: 1.,
-                width: width as f32,
-                height: height as f32,
-                area: math::Rect::new_empty(),
-            },
         }
     }
 
     pub fn resize(&mut self, width: i32, height: i32) {
         self.render_state.resize(width, height);
-        self.viewbox.set_wh(width as f32, height as f32);
     }
 
     pub fn render_state(&'a mut self) -> &'a mut RenderState {
@@ -49,17 +35,13 @@ impl<'a> State<'a> {
     }
 
     pub fn navigate(&mut self) {
-        self.render_state
-            .navigate(&self.viewbox, &self.shapes, self.debug);
+        // TODO: propagate error to main fn
+        let _ = self.render_state.navigate(&self.shapes).unwrap();
     }
 
     pub fn render_all(&mut self, generate_cached_surface_image: bool) {
-        self.render_state.render_all(
-            &self.viewbox,
-            &self.shapes,
-            generate_cached_surface_image,
-            self.debug,
-        );
+        self.render_state
+            .render_all(&self.shapes, generate_cached_surface_image);
     }
 
     pub fn use_shape(&'a mut self, id: Uuid) {
diff --git a/render-wasm/src/view.rs b/render-wasm/src/view.rs
index 0f1ab1193d..399d511383 100644
--- a/render-wasm/src/view.rs
+++ b/render-wasm/src/view.rs
@@ -1,49 +1,67 @@
-use skia_safe as skia;
+use crate::math::Rect;
 
 #[derive(Debug, Copy, Clone)]
 pub(crate) struct Viewbox {
-    pub x: f32,
-    pub y: f32,
+    pub pan_x: f32,
+    pub pan_y: f32,
     pub width: f32,
     pub height: f32,
     pub zoom: f32,
-    pub area: skia::Rect,
+    pub area: Rect,
+}
+
+impl Default for Viewbox {
+    fn default() -> Self {
+        Self {
+            pan_x: 0.,
+            pan_y: 0.,
+            width: 0.0,
+            height: 0.0,
+            zoom: 1.0,
+            area: Rect::new_empty(),
+        }
+    }
 }
 
 impl Viewbox {
-    pub fn set_all(&mut self, zoom: f32, x: f32, y: f32) -> &Self {
-        self.x = x;
-        self.y = y;
+    pub fn new(width: f32, height: f32) -> Self {
+        let mut res = Self::default();
+        res.width = width;
+        res.height = height;
+        res.area.set_xywh(0., 0., width, height);
+
+        res
+    }
+
+    pub fn set_all(&mut self, zoom: f32, pan_x: f32, pan_y: f32) {
+        self.pan_x = pan_x;
+        self.pan_y = pan_y;
         self.zoom = zoom;
         self.area.set_xywh(
-            -self.x,
-            -self.y,
+            -self.pan_x,
+            -self.pan_y,
             self.width / self.zoom,
             self.height / self.zoom,
         );
-        self
     }
 
-    pub fn set_zoom(&mut self, zoom: f32) -> &Self {
+    pub fn set_zoom(&mut self, zoom: f32) {
         self.zoom = zoom;
         self.area
             .set_wh(self.width / self.zoom, self.height / self.zoom);
-        self
     }
 
-    pub fn set_xy(&mut self, x: f32, y: f32) -> &Self {
-        self.x = x;
-        self.y = y;
-        self.area.left = -x;
-        self.area.top = -y;
-        self
+    pub fn set_pan_xy(&mut self, pan_x: f32, pan_y: f32) {
+        self.pan_x = pan_x;
+        self.pan_y = pan_y;
+        self.area.left = -pan_x;
+        self.area.top = -pan_y;
     }
 
-    pub fn set_wh(&mut self, width: f32, height: f32) -> &Self {
+    pub fn set_wh(&mut self, width: f32, height: f32) {
         self.width = width;
         self.height = height;
         self.area
             .set_wh(self.width / self.zoom, self.height / self.zoom);
-        self
     }
 }