diff --git a/vpr/src/draw/draw.cpp b/vpr/src/draw/draw.cpp
index 6e890d7..23aad97 100644
--- a/vpr/src/draw/draw.cpp
+++ b/vpr/src/draw/draw.cpp
@@ -5,7 +5,7 @@
  * whenever the screen needs to be updated. Then, draw_main_canvas() will decide what
  * drawing subroutines to call depending on whether PLACEMENT or ROUTING is shown on screen.
  * The initial_setup_X() functions link the menu button signals to the corresponding drawing functions. 
- * As a note, looks into draw_global.c for understanding the data structures associated with drawing.
+ * As a note, looks into draw_global.c for understanding the data structures associated with drawing->
  *
  * 
  * Authors: Vaughn Betz, Long Yu (Mike) Wang, Dingyu (Tina) Yang
@@ -73,34 +73,34 @@
 //#define TIME_DRAWSCREEN /* Enable if want to track runtime for drawscreen() */
 
 /********************** Subroutines local to this module ********************/
-static void drawplace(ezgl::renderer& g);
-static void drawnets(ezgl::renderer& g);
-static void drawroute(enum e_draw_net_type draw_net_type, ezgl::renderer& g);
-static void draw_congestion(ezgl::renderer& g);
-static void draw_routing_costs(ezgl::renderer& g);
-static void draw_routing_bb(ezgl::renderer& g);
-static void draw_routing_util(ezgl::renderer& g);
-static void draw_crit_path(ezgl::renderer& g);
-static void draw_placement_macros(ezgl::renderer& g);
+static void drawplace(ezgl::renderer* g);
+static void drawnets(ezgl::renderer* g);
+static void drawroute(enum e_draw_net_type draw_net_type, ezgl::renderer* g);
+static void draw_congestion(ezgl::renderer* g);
+static void draw_routing_costs(ezgl::renderer* g);
+static void draw_routing_bb(ezgl::renderer* g);
+static void draw_routing_util(ezgl::renderer* g);
+static void draw_crit_path(ezgl::renderer* g);
+static void draw_placement_macros(ezgl::renderer* g);
 
 void act_on_key_press(ezgl::application* /*app*/, GdkEventKey* /*event*/, char* key_name);
 void act_on_mouse_press(ezgl::application* app, GdkEventButton* event, double x, double y);
 void act_on_mouse_move(ezgl::application* app, GdkEventButton* event, double x, double y);
 
-static void draw_routed_net(ClusterNetId net, ezgl::renderer& g);
-void draw_partial_route(const std::vector<int>& rr_nodes_to_draw, ezgl::renderer& g);
-static void draw_rr(ezgl::renderer& g);
-static void draw_rr_edges(int from_node, ezgl::renderer& g);
-static void draw_rr_pin(int inode, const ezgl::color& color, ezgl::renderer& g);
-static void draw_rr_chan(int inode, const ezgl::color color, ezgl::renderer& g);
-static void draw_rr_src_sink(int inode, ezgl::color color, ezgl::renderer& g);
-static void draw_pin_to_chan_edge(int pin_node, int chan_node, ezgl::renderer& g);
-static void draw_x(float x, float y, float size, ezgl::renderer& g);
-static void draw_pin_to_pin(int opin, int ipin, ezgl::renderer& g);
-static void draw_rr_switch(float from_x, float from_y, float to_x, float to_y, bool buffered, bool switch_configurable, ezgl::renderer& g);
-static void draw_chany_to_chany_edge(int from_node, int to_node, int to_track, short switch_type, ezgl::renderer& g);
-static void draw_chanx_to_chanx_edge(int from_node, int to_node, int to_track, short switch_type, ezgl::renderer& g);
-static void draw_chanx_to_chany_edge(int chanx_node, int chanx_track, int chany_node, int chany_track, enum e_edge_dir edge_dir, short switch_type, ezgl::renderer& g);
+static void draw_routed_net(ClusterNetId net, ezgl::renderer* g);
+void draw_partial_route(const std::vector<int>& rr_nodes_to_draw, ezgl::renderer* g);
+static void draw_rr(ezgl::renderer* g);
+static void draw_rr_edges(int from_node, ezgl::renderer* g);
+static void draw_rr_pin(int inode, const ezgl::color& color, ezgl::renderer* g);
+static void draw_rr_chan(int inode, const ezgl::color color, ezgl::renderer* g);
+static void draw_rr_src_sink(int inode, ezgl::color color, ezgl::renderer* g);
+static void draw_pin_to_chan_edge(int pin_node, int chan_node, ezgl::renderer* g);
+static void draw_x(float x, float y, float size, ezgl::renderer* g);
+static void draw_pin_to_pin(int opin, int ipin, ezgl::renderer* g);
+static void draw_rr_switch(float from_x, float from_y, float to_x, float to_y, bool buffered, bool switch_configurable, ezgl::renderer* g);
+static void draw_chany_to_chany_edge(int from_node, int to_node, int to_track, short switch_type, ezgl::renderer* g);
+static void draw_chanx_to_chanx_edge(int from_node, int to_node, int to_track, short switch_type, ezgl::renderer* g);
+static void draw_chanx_to_chany_edge(int chanx_node, int chanx_track, int chany_node, int chany_track, enum e_edge_dir edge_dir, short switch_type, ezgl::renderer* g);
 static int get_track_num(int inode, const vtr::OffsetMatrix<int>& chanx_track, const vtr::OffsetMatrix<int>& chany_track);
 static bool draw_if_net_highlighted(ClusterNetId inet);
 static int draw_check_rr_node_hit(float click_x, float click_y);
@@ -111,18 +111,18 @@
 static void draw_reset_blk_colors();
 static void draw_reset_blk_color(ClusterBlockId blk_id);
 
-static inline void draw_mux_with_size(ezgl::point2d origin, e_side orientation, float height, int size, ezgl::renderer& g);
-static inline ezgl::rectangle draw_mux(ezgl::point2d origin, e_side orientation, float height, ezgl::renderer& g);
-static inline ezgl::rectangle draw_mux(ezgl::point2d origin, e_side orientation, float height, float width, float height_scale, ezgl::renderer& g);
+static inline void draw_mux_with_size(ezgl::point2d origin, e_side orientation, float height, int size, ezgl::renderer* g);
+static inline ezgl::rectangle draw_mux(ezgl::point2d origin, e_side orientation, float height, ezgl::renderer* g);
+static inline ezgl::rectangle draw_mux(ezgl::point2d origin, e_side orientation, float height, float width, float height_scale, ezgl::renderer* g);
 
-static void draw_flyline_timing_edge(ezgl::point2d start, ezgl::point2d end, float incr_delay, ezgl::renderer& g);
-static void draw_routed_timing_edge(tatum::NodeId start_tnode, tatum::NodeId end_tnode, float incr_delay, ezgl::color color, ezgl::renderer& g);
-static void draw_routed_timing_edge_connection(tatum::NodeId src_tnode, tatum::NodeId sink_tnode, ezgl::color color, ezgl::renderer& g);
+static void draw_flyline_timing_edge(ezgl::point2d start, ezgl::point2d end, float incr_delay, ezgl::renderer* g);
+static void draw_routed_timing_edge(tatum::NodeId start_tnode, tatum::NodeId end_tnode, float incr_delay, ezgl::color color, ezgl::renderer* g);
+static void draw_routed_timing_edge_connection(tatum::NodeId src_tnode, tatum::NodeId sink_tnode, ezgl::color color, ezgl::renderer* g);
 static std::vector<int> trace_routed_connection_rr_nodes(const ClusterNetId net_id, const int driver_pin, const int sink_pin);
 static bool trace_routed_connection_rr_nodes_recurr(const t_rt_node* rt_node, int sink_rr_node, std::vector<int>& rr_nodes_on_path);
 static t_edge_size find_edge(int prev_inode, int inode);
 
-static void draw_color_map_legend(const vtr::ColorMap& cmap, ezgl::renderer& g);
+static void draw_color_map_legend(const vtr::ColorMap& cmap, ezgl::renderer* g);
 
 ezgl::color get_block_type_color(t_physical_tile_type_ptr type);
 ezgl::color lighten_color(ezgl::color color, float amount);
@@ -130,17 +130,17 @@
 static void draw_block_pin_util();
 
 static float get_router_rr_cost(const t_rr_node_route_inf node_inf, e_draw_router_rr_cost draw_router_rr_cost);
-static void draw_router_rr_costs(ezgl::renderer& g);
+static void draw_router_rr_costs(ezgl::renderer* g);
 
-static void draw_rr_costs(ezgl::renderer& g, const std::vector<float>& rr_costs, bool lowest_cost_first = true);
+static void draw_rr_costs(ezgl::renderer* g, const std::vector<float>& rr_costs, bool lowest_cost_first = true);
 
-void draw_main_canvas(ezgl::renderer& g);
-void initial_setup_NO_PICTURE_to_PLACEMENT(ezgl::application* app);
-void initial_setup_NO_PICTURE_to_PLACEMENT_with_crit_path(ezgl::application* app);
-void initial_setup_PLACEMENT_to_ROUTING(ezgl::application* app);
-void initial_setup_ROUTING_to_PLACEMENT(ezgl::application* app);
-void initial_setup_NO_PICTURE_to_ROUTING(ezgl::application* app);
-void initial_setup_NO_PICTURE_to_ROUTING_with_crit_path(ezgl::application* app);
+void draw_main_canvas(ezgl::renderer* g);
+void initial_setup_NO_PICTURE_to_PLACEMENT(ezgl::application* app, bool is_new_window);
+void initial_setup_NO_PICTURE_to_PLACEMENT_with_crit_path(ezgl::application* app, bool is_new_window);
+void initial_setup_PLACEMENT_to_ROUTING(ezgl::application* app, bool is_new_window);
+void initial_setup_ROUTING_to_PLACEMENT(ezgl::application* app, bool is_new_window);
+void initial_setup_NO_PICTURE_to_ROUTING(ezgl::application* app, bool is_new_window);
+void initial_setup_NO_PICTURE_to_ROUTING_with_crit_path(ezgl::application* app, bool is_new_window);
 void toggle_window_mode(GtkWidget* /*widget*/, ezgl::application* /*app*/);
 void setup_default_ezgl_callbacks(ezgl::application* app);
 
@@ -220,10 +220,10 @@
 }
 
 #ifndef NO_GRAPHICS
-void draw_main_canvas(ezgl::renderer& g) {
+void draw_main_canvas(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
 
-    g.set_font_size(14);
+    g->set_font_size(14);
 
     draw_block_pin_util();
     drawplace(g);
@@ -278,7 +278,7 @@
 /* function below intializes the interface window with a set of buttons and links 
  * signals to corresponding functions for situation where the window is opened from 
  * NO_PICTURE_to_PLACEMENT */
-void initial_setup_NO_PICTURE_to_PLACEMENT(ezgl::application* app) {
+void initial_setup_NO_PICTURE_to_PLACEMENT(ezgl::application* app, bool /*is_new_window*/) {
     //button to enter window_mode, created in main.ui
     GtkButton* window = (GtkButton*)app->get_object("Window");
     gtk_button_set_label(window, "Window");
@@ -311,16 +311,16 @@
 /* function below intializes the interface window with a set of buttons and links 
  * signals to corresponding functions for situation where the window is opened from 
  * NO_PICTURE_to_PLACEMENT_with_crit_path */
-void initial_setup_NO_PICTURE_to_PLACEMENT_with_crit_path(ezgl::application* app) {
-    initial_setup_NO_PICTURE_to_PLACEMENT(app);
+void initial_setup_NO_PICTURE_to_PLACEMENT_with_crit_path(ezgl::application* app, bool is_new_window) {
+    initial_setup_NO_PICTURE_to_PLACEMENT(app, is_new_window);
     button_for_toggle_crit_path();
 }
 
 /* function below intializes the interface window with a set of buttons and links 
  * signals to corresponding functions for situation where the window is opened from 
  * PLACEMENT_to_ROUTING */
-void initial_setup_PLACEMENT_to_ROUTING(ezgl::application* app) {
-    initial_setup_NO_PICTURE_to_PLACEMENT_with_crit_path(app);
+void initial_setup_PLACEMENT_to_ROUTING(ezgl::application* app, bool is_new_window) {
+    initial_setup_NO_PICTURE_to_PLACEMENT_with_crit_path(app, is_new_window);
     button_for_toggle_rr();
     button_for_toggle_congestion();
     button_for_toggle_congestion_cost();
@@ -332,8 +332,8 @@
 /* function below intializes the interface window with a set of buttons and links 
  * signals to corresponding functions for situation where the window is opened from 
  * ROUTING_to_PLACEMENT */
-void initial_setup_ROUTING_to_PLACEMENT(ezgl::application* app) {
-    initial_setup_PLACEMENT_to_ROUTING(app);
+void initial_setup_ROUTING_to_PLACEMENT(ezgl::application* app, bool is_new_window) {
+    initial_setup_PLACEMENT_to_ROUTING(app, is_new_window);
     std::string toggle_rr = "toggle_rr";
     std::string toggle_congestion = "toggle_congestion";
     std::string toggle_routing_congestion_cost = "toggle_routing_congestion_cost";
@@ -352,7 +352,7 @@
 /* function below intializes the interface window with a set of buttons and links 
  * signals to corresponding functions for situation where the window is opened from 
  * NO_PICTURE_to_ROUTING */
-void initial_setup_NO_PICTURE_to_ROUTING(ezgl::application* app) {
+void initial_setup_NO_PICTURE_to_ROUTING(ezgl::application* app, bool /*is_new_window*/) {
     GtkButton* window = (GtkButton*)app->get_object("Window");
     gtk_button_set_label(window, "Window");
     g_signal_connect(window, "clicked", G_CALLBACK(toggle_window_mode), app);
@@ -386,8 +386,8 @@
 /* function below intializes the interface window with a set of buttons and links 
  * signals to corresponding functions for situation where the window is opened from 
  * NO_PICTURE_to_ROUTING_with_crit_path */
-void initial_setup_NO_PICTURE_to_ROUTING_with_crit_path(ezgl::application* app) {
-    initial_setup_NO_PICTURE_to_ROUTING(app);
+void initial_setup_NO_PICTURE_to_ROUTING_with_crit_path(ezgl::application* app, bool is_new_window) {
+    initial_setup_NO_PICTURE_to_ROUTING(app, is_new_window);
     button_for_toggle_crit_path();
 }
 #endif //NO_GRAPHICS
@@ -803,7 +803,7 @@
     auto& device_ctx = g_vpr_ctx.device();
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
-    /* Allocate the structures needed to draw the placement and routing.  Set *
+    /* Allocate the structures needed to draw the placement and routing->  Set *
      * up the default colors for blocks and nets.                             */
     draw_coords->tile_x = (float*)vtr::malloc(device_ctx.grid.width() * sizeof(float));
     draw_coords->tile_y = (float*)vtr::malloc(device_ctx.grid.height() * sizeof(float));
@@ -916,7 +916,7 @@
 
 /* Draws the blocks placed on the proper clbs.  Occupied blocks are darker colours *
  * while empty ones are lighter colours and have a dashed border.      */
-static void drawplace(ezgl::renderer& g) {
+static void drawplace(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
     auto& device_ctx = g_vpr_ctx.device();
@@ -925,7 +925,7 @@
     ClusterBlockId bnum;
     int num_sub_tiles;
 
-    g.set_line_width(0);
+    g->set_line_width(0);
     for (size_t i = 0; i < device_ctx.grid.width(); i++) {
         for (size_t j = 0; j < device_ctx.grid.height(); j++) {
             /* Only the first block of a group should control drawing */
@@ -933,7 +933,7 @@
                 continue;
 
             num_sub_tiles = device_ctx.grid[i][j].type->capacity;
-            /* Don't draw if tile capacity is zero. eg. corners. */
+            /* Don't draw if tile capacity is zero. eg-> corners. */
             if (num_sub_tiles == 0) {
                 continue;
             }
@@ -953,38 +953,38 @@
                     block_color = get_block_type_color(device_ctx.grid[i][j].type);
                     block_color = lighten_color(block_color, EMPTY_BLOCK_LIGHTEN_FACTOR);
                 }
-                g.set_color(block_color);
+                g->set_color(block_color);
                 /* Get coords of current sub_tile */
                 ezgl::rectangle abs_clb_bbox = draw_coords->get_absolute_clb_bbox(i, j, k);
                 ezgl::point2d center = abs_clb_bbox.center();
 
-                g.fill_rectangle(abs_clb_bbox);
+                g->fill_rectangle(abs_clb_bbox);
 
-                g.set_color(ezgl::BLACK);
+                g->set_color(ezgl::BLACK);
 
-                g.set_line_dash((EMPTY_BLOCK_ID == bnum) ? ezgl::line_dash::asymmetric_5_3 : ezgl::line_dash::none);
-                g.draw_rectangle(abs_clb_bbox);
+                g->set_line_dash((EMPTY_BLOCK_ID == bnum) ? ezgl::line_dash::asymmetric_5_3 : ezgl::line_dash::none);
+                g->draw_rectangle(abs_clb_bbox);
                 /* Draw text if the space has parts of the netlist */
                 if (bnum != EMPTY_BLOCK_ID && bnum != INVALID_BLOCK_ID) {
                     auto& cluster_ctx = g_vpr_ctx.clustering();
                     std::string name = cluster_ctx.clb_nlist.block_name(bnum) + vtr::string_fmt(" (#%zu)", size_t(bnum));
 
-                    g.draw_text(center, name.c_str(), abs_clb_bbox.width(), abs_clb_bbox.height());
+                    g->draw_text(center, name.c_str(), abs_clb_bbox.width(), abs_clb_bbox.height());
                 }
                 /* Draw text for block type so that user knows what block */
                 if (device_ctx.grid[i][j].width_offset == 0 && device_ctx.grid[i][j].height_offset == 0) {
                     std::string block_type_loc = device_ctx.grid[i][j].type->name;
                     block_type_loc += vtr::string_fmt(" (%d,%d)", i, j);
 
-                    g.draw_text(center - ezgl::point2d(0, abs_clb_bbox.height() / 4),
-                                block_type_loc.c_str(), abs_clb_bbox.width(), abs_clb_bbox.height());
+                    g->draw_text(center - ezgl::point2d(0, abs_clb_bbox.height() / 4),
+                                 block_type_loc.c_str(), abs_clb_bbox.width(), abs_clb_bbox.height());
                 }
             }
         }
     }
 }
 
-static void drawnets(ezgl::renderer& g) {
+static void drawnets(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
     /* This routine draws the nets on the placement.  The nets have not *
@@ -994,8 +994,8 @@
     ClusterBlockId b1, b2;
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
-    g.set_line_dash(ezgl::line_dash::none);
-    g.set_line_width(0);
+    g->set_line_dash(ezgl::line_dash::none);
+    g->set_line_width(0);
 
     /* Draw the net as a star from the source to each sink. Draw from centers of *
      * blocks (or sub blocks in the case of IOs).                                */
@@ -1004,20 +1004,20 @@
         if (cluster_ctx.clb_nlist.net_is_ignored(net_id))
             continue; /* Don't draw */
 
-        g.set_color(draw_state->net_color[net_id]);
+        g->set_color(draw_state->net_color[net_id]);
         b1 = cluster_ctx.clb_nlist.net_driver_block(net_id);
         ezgl::point2d driver_center = draw_coords->get_absolute_clb_bbox(b1, cluster_ctx.clb_nlist.block_type(b1)).center();
         for (auto pin_id : cluster_ctx.clb_nlist.net_sinks(net_id)) {
             b2 = cluster_ctx.clb_nlist.pin_block(pin_id);
             ezgl::point2d sink_center = draw_coords->get_absolute_clb_bbox(b2, cluster_ctx.clb_nlist.block_type(b2)).center();
-            g.draw_line(driver_center, sink_center);
+            g->draw_line(driver_center, sink_center);
             /* Uncomment to draw a chain instead of a star. */
             /* driver_center = sink_center;  */
         }
     }
 }
 
-static void draw_congestion(ezgl::renderer& g) {
+static void draw_congestion(ezgl::renderer* g) {
     /* Draws all the overused routing resources (i.e. congestion) in various contrasting colors showing congestion ratio.   */
     t_draw_state* draw_state = get_draw_state_vars();
 
@@ -1053,7 +1053,7 @@
     std::unique_ptr<vtr::ColorMap> cmap = std::make_unique<vtr::PlasmaColorMap>(min_congestion_ratio, max_congestion_ratio);
 
     //Sort the nodes in ascending order of value for drawing, this ensures high
-    //valued nodes are not overdrawn by lower value ones (e.g. when zoomed-out far)
+    //valued nodes are not overdrawn by lower value ones (e.g-> when zoomed-out far)
     auto cmp_ascending_acc_cost = [&](int lhs_node, int rhs_node) {
         short lhs_occ = route_ctx.rr_node_route_inf[lhs_node].occ();
         short lhs_capacity = device_ctx.rr_nodes[lhs_node].capacity();
@@ -1077,7 +1077,7 @@
                 draw_state->net_color[net] = color;
             }
         }
-        g.set_line_width(0);
+        g->set_line_width(0);
         drawroute(HIGHLIGHTED, g);
 
         //Reset colors
@@ -1087,7 +1087,7 @@
             }
         }
     } else {
-        g.set_line_width(2);
+        g->set_line_width(2);
     }
 
     //Draw each congested node
@@ -1120,7 +1120,7 @@
     draw_state->color_map = std::move(cmap);
 }
 
-static void draw_routing_costs(ezgl::renderer& g) {
+static void draw_routing_costs(ezgl::renderer* g) {
     /* Draws routing resource nodes colored according to their congestion costs */
 
     t_draw_state* draw_state = get_draw_state_vars();
@@ -1135,7 +1135,7 @@
 
     auto& device_ctx = g_vpr_ctx.device();
     auto& route_ctx = g_vpr_ctx.routing();
-    g.set_line_width(0);
+    g->set_line_width(0);
 
     VTR_ASSERT(!route_ctx.rr_node_route_inf.empty());
 
@@ -1204,7 +1204,7 @@
     draw_rr_costs(g, rr_node_costs, true);
 }
 
-static void draw_routing_bb(ezgl::renderer& g) {
+static void draw_routing_bb(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
 
     if (draw_state->show_routing_bb == OPEN) {
@@ -1241,13 +1241,13 @@
     double draw_xhigh = draw_coords->tile_x[bb->xmax] + 2 * draw_coords->get_tile_width();
     double draw_yhigh = draw_coords->tile_y[bb->ymax] + 2 * draw_coords->get_tile_height();
 
-    g.set_color(blk_RED);
-    g.draw_rectangle({draw_xlow, draw_ylow}, {draw_xhigh, draw_yhigh});
+    g->set_color(blk_RED);
+    g->draw_rectangle({draw_xlow, draw_ylow}, {draw_xhigh, draw_yhigh});
 
     ezgl::color fill = blk_SKYBLUE;
     fill.alpha *= 0.3;
-    g.set_color(fill);
-    g.fill_rectangle({draw_xlow, draw_ylow}, {draw_xhigh, draw_yhigh});
+    g->set_color(fill);
+    g->fill_rectangle({draw_xlow, draw_ylow}, {draw_xhigh, draw_yhigh});
 
     draw_routed_net(net_id, g);
 
@@ -1259,20 +1259,20 @@
     application.update_message(msg.c_str());
 }
 
-void draw_rr(ezgl::renderer& g) {
+void draw_rr(ezgl::renderer* g) {
     /* Draws the routing resources that exist in the FPGA, if the user wants *
      * them drawn.                                                           */
     t_draw_state* draw_state = get_draw_state_vars();
     auto& device_ctx = g_vpr_ctx.device();
 
     if (draw_state->draw_rr_toggle == DRAW_NO_RR) {
-        g.set_line_width(3);
+        g->set_line_width(3);
         drawroute(HIGHLIGHTED, g);
-        g.set_line_width(0);
+        g->set_line_width(0);
         return;
     }
 
-    g.set_line_dash(ezgl::line_dash::none);
+    g->set_line_dash(ezgl::line_dash::none);
 
     for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
         if (!draw_state->draw_rr_node[inode].node_highlighted) {
@@ -1327,7 +1327,7 @@
     drawroute(HIGHLIGHTED, g);
 }
 
-static void draw_rr_chan(int inode, const ezgl::color color, ezgl::renderer& g) {
+static void draw_rr_chan(int inode, const ezgl::color color, ezgl::renderer* g) {
     auto& device_ctx = g_vpr_ctx.device();
 
     t_rr_type type = device_ctx.rr_nodes[inode].type();
@@ -1344,17 +1344,17 @@
         std::swap(start, end);
     }
 
-    g.set_color(color);
+    g->set_color(color);
     if (color != DEFAULT_RR_NODE_COLOR) {
         // If wire is highlighted, then draw with thicker linewidth.
-        g.set_line_width(3);
+        g->set_line_width(3);
     }
 
-    g.draw_line(start, end);
+    g->draw_line(start, end);
 
     if (color != DEFAULT_RR_NODE_COLOR) {
         // Revert width change
-        g.set_line_width(0);
+        g->set_line_width(0);
     }
 
     e_side mux_dir = TOP;
@@ -1424,14 +1424,14 @@
                 std::swap(arrow_color, text_color);
             }
 
-            g.set_color(arrow_color);
+            g->set_color(arrow_color);
             draw_triangle_along_line(g, arrow_loc_min, start, end);
 
-            g.set_color(text_color);
+            g->set_color(text_color);
             ezgl::rectangle bbox(ezgl::point2d(arrow_loc_min.x - DEFAULT_ARROW_SIZE / 2, arrow_loc_min.y - DEFAULT_ARROW_SIZE / 4),
                                  ezgl::point2d(arrow_loc_min.x + DEFAULT_ARROW_SIZE / 2, arrow_loc_min.y + DEFAULT_ARROW_SIZE / 4));
             ezgl::point2d center = bbox.center();
-            g.draw_text(center, std::to_string(switchpoint_min), bbox.width(), bbox.height());
+            g->draw_text(center, std::to_string(switchpoint_min), bbox.width(), bbox.height());
 
             if (k == coord_min) {
                 //Revert
@@ -1450,14 +1450,14 @@
                 std::swap(arrow_color, text_color);
             }
 
-            g.set_color(arrow_color);
+            g->set_color(arrow_color);
             draw_triangle_along_line(g, arrow_loc_max, start, end);
 
-            g.set_color(text_color);
+            g->set_color(text_color);
             ezgl::rectangle bbox(ezgl::point2d(arrow_loc_max.x - DEFAULT_ARROW_SIZE / 2, arrow_loc_max.y - DEFAULT_ARROW_SIZE / 4),
                                  ezgl::point2d(arrow_loc_max.x + DEFAULT_ARROW_SIZE / 2, arrow_loc_max.y + DEFAULT_ARROW_SIZE / 4));
             ezgl::point2d center = bbox.center();
-            g.draw_text(center, std::to_string(switchpoint_max), bbox.width(), bbox.height());
+            g->draw_text(center, std::to_string(switchpoint_max), bbox.width(), bbox.height());
 
             if (k == coord_max) {
                 //Revert
@@ -1465,10 +1465,10 @@
             }
         }
     }
-    g.set_color(color); //Ensure color is still set correctly if we drew any arrows/text
+    g->set_color(color); //Ensure color is still set correctly if we drew any arrows/text
 }
 
-static void draw_rr_edges(int inode, ezgl::renderer& g) {
+static void draw_rr_edges(int inode, ezgl::renderer* g) {
     /* Draws all the edges that the user wants shown between inode and what it *
      * connects to.  inode is assumed to be a CHANX, CHANY, or IPIN.           */
     t_draw_state* draw_state = get_draw_state_vars();
@@ -1501,25 +1501,25 @@
                         if (draw_state->draw_rr_node[inode].color == ezgl::MAGENTA) {
                             // If OPIN was clicked on, set color to fan-out
                             ezgl::color color = draw_state->draw_rr_node[to_node].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (draw_state->draw_rr_node[to_node].color == ezgl::MAGENTA) {
                             // If CHANX or CHANY got clicked, set color to fan-in
                             ezgl::color color = draw_state->draw_rr_node[inode].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else {
-                            g.set_color(ezgl::PINK);
+                            g->set_color(ezgl::PINK);
                         }
                         draw_pin_to_chan_edge(inode, to_node, g);
                         break;
                     case IPIN:
                         if (draw_state->draw_rr_node[inode].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[to_node].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (draw_state->draw_rr_node[to_node].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[inode].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else {
-                            g.set_color(ezgl::MEDIUM_PURPLE);
+                            g->set_color(ezgl::MEDIUM_PURPLE);
                         }
                         draw_pin_to_pin(inode, to_node, g);
                         break;
@@ -1548,12 +1548,12 @@
 
                         if (draw_state->draw_rr_node[inode].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[to_node].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (draw_state->draw_rr_node[to_node].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[inode].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else {
-                            g.set_color(blk_LIGHTSKYBLUE);
+                            g->set_color(blk_LIGHTSKYBLUE);
                         }
                         draw_pin_to_chan_edge(to_node, inode, g);
                         break;
@@ -1561,15 +1561,15 @@
                     case CHANX:
                         if (draw_state->draw_rr_node[inode].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[to_node].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (draw_state->draw_rr_node[to_node].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[inode].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (!edge_configurable) {
                             ezgl::color color = blk_DARKGREY;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else {
-                            g.set_color(blk_DARKGREEN);
+                            g->set_color(blk_DARKGREEN);
                         }
                         switch_type = device_ctx.rr_nodes[inode].edge_switch(iedge);
                         draw_chanx_to_chanx_edge(inode, to_node,
@@ -1579,14 +1579,14 @@
                     case CHANY:
                         if (draw_state->draw_rr_node[inode].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[to_node].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (draw_state->draw_rr_node[to_node].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[inode].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (!edge_configurable) {
-                            g.set_color(blk_DARKGREY);
+                            g->set_color(blk_DARKGREY);
                         } else {
-                            g.set_color(blk_DARKGREEN);
+                            g->set_color(blk_DARKGREEN);
                         }
                         switch_type = device_ctx.rr_nodes[inode].edge_switch(iedge);
                         draw_chanx_to_chany_edge(inode, from_ptc_num, to_node,
@@ -1618,12 +1618,12 @@
 
                         if (draw_state->draw_rr_node[inode].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[to_node].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (draw_state->draw_rr_node[to_node].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[inode].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else {
-                            g.set_color(blk_LIGHTSKYBLUE);
+                            g->set_color(blk_LIGHTSKYBLUE);
                         }
                         draw_pin_to_chan_edge(to_node, inode, g);
                         break;
@@ -1631,15 +1631,15 @@
                     case CHANX:
                         if (draw_state->draw_rr_node[inode].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[to_node].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (draw_state->draw_rr_node[to_node].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[inode].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (!edge_configurable) {
                             ezgl::color color = blk_DARKGREY;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else {
-                            g.set_color(blk_DARKGREEN);
+                            g->set_color(blk_DARKGREEN);
                         }
                         switch_type = device_ctx.rr_nodes[inode].edge_switch(iedge);
                         draw_chanx_to_chany_edge(to_node, to_ptc_num, inode,
@@ -1649,15 +1649,15 @@
                     case CHANY:
                         if (draw_state->draw_rr_node[inode].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[to_node].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (draw_state->draw_rr_node[to_node].color == ezgl::MAGENTA) {
                             ezgl::color color = draw_state->draw_rr_node[inode].color;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else if (!edge_configurable) {
                             ezgl::color color = blk_DARKGREY;
-                            g.set_color(color);
+                            g->set_color(color);
                         } else {
-                            g.set_color(blk_DARKGREEN);
+                            g->set_color(blk_DARKGREEN);
                         }
                         switch_type = device_ctx.rr_nodes[inode].edge_switch(iedge);
                         draw_chany_to_chany_edge(inode, to_node,
@@ -1681,14 +1681,14 @@
     } /* End of for each edge loop */
 }
 
-static void draw_x(float x, float y, float size, ezgl::renderer& g) {
+static void draw_x(float x, float y, float size, ezgl::renderer* g) {
     /* Draws an X centered at (x,y).  The width and height of the X are each    *
      * 2 * size.                                                                */
-    g.draw_line({x - size, y + size}, {x + size, y - size});
-    g.draw_line({x - size, y - size}, {x + size, y + size});
+    g->draw_line({x - size, y + size}, {x + size, y - size});
+    g->draw_line({x - size, y - size}, {x + size, y + size});
 }
 
-static void draw_chanx_to_chany_edge(int chanx_node, int chanx_track, int chany_node, int chany_track, enum e_edge_dir edge_dir, short switch_type, ezgl::renderer& g) {
+static void draw_chanx_to_chany_edge(int chanx_node, int chanx_track, int chany_node, int chany_track, enum e_edge_dir edge_dir, short switch_type, ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
     auto& device_ctx = g_vpr_ctx.device();
@@ -1747,7 +1747,7 @@
         y2 = chany_bbox.bottom();
     }
 
-    g.draw_line({x1, y1}, {x2, y2});
+    g->draw_line({x1, y1}, {x2, y2});
 
     if (draw_state->draw_rr_toggle == DRAW_ALL_RR || draw_state->draw_rr_node[chanx_node].node_highlighted) {
         if (edge_dir == FROM_X_TO_Y) {
@@ -1758,10 +1758,10 @@
     }
 }
 
-static void draw_chanx_to_chanx_edge(int from_node, int to_node, int to_track, short switch_type, ezgl::renderer& g) {
+static void draw_chanx_to_chanx_edge(int from_node, int to_node, int to_track, short switch_type, ezgl::renderer* g) {
     /* Draws a connection between two x-channel segments.  Passing in the track *
      * numbers allows this routine to be used for both rr_graph and routing     *
-     * drawing.                                                                 */
+     * drawing->                                                                 */
 
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
@@ -1836,21 +1836,21 @@
         }
     }
 
-    g.draw_line({x1, y1}, {x2, y2});
+    g->draw_line({x1, y1}, {x2, y2});
 
     if (draw_state->draw_rr_toggle == DRAW_ALL_RR || draw_state->draw_rr_node[from_node].node_highlighted) {
         draw_rr_switch(x1, y1, x2, y2, device_ctx.rr_switch_inf[switch_type].buffered(), device_ctx.rr_switch_inf[switch_type].configurable(), g);
     }
 }
 
-static void draw_chany_to_chany_edge(int from_node, int to_node, int to_track, short switch_type, ezgl::renderer& g) {
+static void draw_chany_to_chany_edge(int from_node, int to_node, int to_track, short switch_type, ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
     auto& device_ctx = g_vpr_ctx.device();
 
     /* Draws a connection between two y-channel segments.  Passing in the track *
      * numbers allows this routine to be used for both rr_graph and routing     *
-     * drawing.                                                                 */
+     * drawing->                                                                 */
 
     float x1, x2, y1, y2;
     ezgl::rectangle from_chan;
@@ -1919,7 +1919,7 @@
     }
 
     /* UDSD Modification by WMF End */
-    g.draw_line({x1, y1}, {x2, y2});
+    g->draw_line({x1, y1}, {x2, y2});
 
     if (draw_state->draw_rr_toggle == DRAW_ALL_RR || draw_state->draw_rr_node[from_node].node_highlighted) {
         draw_rr_switch(x1, y1, x2, y2, device_ctx.rr_switch_inf[switch_type].buffered(), device_ctx.rr_switch_inf[switch_type].configurable(), g);
@@ -1968,7 +1968,7 @@
     return bound_box;
 }
 
-static void draw_rr_switch(float from_x, float from_y, float to_x, float to_y, bool buffered, bool configurable, ezgl::renderer& g) {
+static void draw_rr_switch(float from_x, float from_y, float to_x, float to_y, bool buffered, bool configurable, ezgl::renderer* g) {
     /* Draws a buffer (triangle) or pass transistor (circle) on the edge        *
      * connecting from to to, depending on the status of buffered.  The drawing *
      * is closest to the from_node, since it reflects the switch type of from.  */
@@ -1978,7 +1978,7 @@
             float xcen = from_x + (to_x - from_x) / 10.;
             float ycen = from_y + (to_y - from_y) / 10.;
             const float switch_rad = 0.15;
-            g.draw_arc({xcen, ycen}, switch_rad, 0., 360.);
+            g->draw_arc({xcen, ycen}, switch_rad, 0., 360.);
         } else {
             //Pass, nothing to draw
         }
@@ -1993,7 +1993,7 @@
     }
 }
 
-static void draw_rr_pin(int inode, const ezgl::color& color, ezgl::renderer& g) {
+static void draw_rr_pin(int inode, const ezgl::color& color, ezgl::renderer* g) {
     /* Draws an IPIN or OPIN rr_node.  Note that the pin can appear on more    *
      * than one side of a clb.  Also note that this routine can change the     *
      * current color to BLACK.                                                 */
@@ -2006,16 +2006,16 @@
 
     int ipin = device_ctx.rr_nodes[inode].ptc_num();
 
-    g.set_color(color);
+    g->set_color(color);
 
     /* TODO: This is where we can hide fringe physical pins and also identify globals (hide, color, show) */
     draw_get_rr_pin_coords(inode, &xcen, &ycen);
-    g.fill_rectangle({xcen - draw_coords->pin_size, ycen - draw_coords->pin_size},
-                     {xcen + draw_coords->pin_size, ycen + draw_coords->pin_size});
+    g->fill_rectangle({xcen - draw_coords->pin_size, ycen - draw_coords->pin_size},
+                      {xcen + draw_coords->pin_size, ycen + draw_coords->pin_size});
     sprintf(str, "%d", ipin);
-    g.set_color(ezgl::BLACK);
-    g.draw_text({xcen, ycen}, str, 2 * draw_coords->pin_size, 2 * draw_coords->pin_size);
-    g.set_color(color);
+    g->set_color(ezgl::BLACK);
+    g->draw_text({xcen, ycen}, str, 2 * draw_coords->pin_size, 2 * draw_coords->pin_size);
+    g->set_color(color);
 }
 
 /* Returns the coordinates at which the center of this pin should be drawn. *
@@ -2081,7 +2081,7 @@
     *ycen = yc;
 }
 
-static void draw_rr_src_sink(int inode, ezgl::color color, ezgl::renderer& g) {
+static void draw_rr_src_sink(int inode, ezgl::color color, ezgl::renderer* g) {
     t_draw_coords* draw_coords = get_draw_coords_vars();
 
     auto& device_ctx = g_vpr_ctx.device();
@@ -2091,24 +2091,24 @@
     int xhigh = device_ctx.rr_nodes[inode].xhigh();
     int yhigh = device_ctx.rr_nodes[inode].yhigh();
 
-    g.set_color(color);
+    g->set_color(color);
 
-    g.fill_rectangle({draw_coords->get_tile_width() * xlow, draw_coords->get_tile_height() * ylow},
-                     {draw_coords->get_tile_width() * xhigh, draw_coords->get_tile_height() * yhigh});
+    g->fill_rectangle({draw_coords->get_tile_width() * xlow, draw_coords->get_tile_height() * ylow},
+                      {draw_coords->get_tile_width() * xhigh, draw_coords->get_tile_height() * yhigh});
 }
 
 /* Draws the nets in the positions fixed by the router.  If draw_net_type is *
  * ALL_NETS, draw all the nets.  If it is HIGHLIGHTED, draw only the nets    *
  * that are not coloured black (useful for drawing over the rr_graph).       */
 
-static void drawroute(enum e_draw_net_type draw_net_type, ezgl::renderer& g) {
+static void drawroute(enum e_draw_net_type draw_net_type, ezgl::renderer* g) {
     /* Next free track in each channel segment if routing is GLOBAL */
 
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
     t_draw_state* draw_state = get_draw_state_vars();
 
-    g.set_line_dash(ezgl::line_dash::none);
+    g->set_line_dash(ezgl::line_dash::none);
 
     /* Now draw each net, one by one.      */
 
@@ -2120,7 +2120,7 @@
     } /* End for (each net) */
 }
 
-static void draw_routed_net(ClusterNetId net_id, ezgl::renderer& g) {
+static void draw_routed_net(ClusterNetId net_id, ezgl::renderer* g) {
     auto& route_ctx = g_vpr_ctx.routing();
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
@@ -2129,7 +2129,7 @@
     if (cluster_ctx.clb_nlist.net_is_ignored(net_id)) /* Don't draw. */
         return;
 
-    if (route_ctx.trace[net_id].head == nullptr) /* No routing.  Skip.  (Allows me to draw */
+    if (route_ctx.trace[net_id].head == nullptr) /* No routing->  Skip.  (Allows me to draw */
         return;                                  /* partially complete routes).            */
 
     t_trace* tptr = route_ctx.trace[net_id].head; /* SOURCE to start */
@@ -2171,7 +2171,7 @@
 }
 
 //Draws the set of rr_nodes specified, using the colors set in draw_state
-void draw_partial_route(const std::vector<int>& rr_nodes_to_draw, ezgl::renderer& g) {
+void draw_partial_route(const std::vector<int>& rr_nodes_to_draw, ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     auto& device_ctx = g_vpr_ctx.device();
 
@@ -2602,11 +2602,11 @@
     if (window_point_1_collected) {
         // draw a grey, dashed-line box to indicate the zoom-in region
         app->refresh_drawing();
-        ezgl::renderer g = app->get_renderer();
-        g.set_line_dash(ezgl::line_dash::asymmetric_5_3);
-        g.set_color(blk_GREY);
-        g.set_line_width(2);
-        g.draw_rectangle(point_1, {x, y});
+        ezgl::renderer* g = app->get_renderer();
+        g->set_line_dash(ezgl::line_dash::asymmetric_5_3);
+        g->set_color(blk_GREY);
+        g->set_line_width(2);
+        g->draw_rectangle(point_1, {x, y});
         return;
     }
 
@@ -2726,7 +2726,7 @@
  * A 'relative_position' of 1. draws the triangle centered at 'end'.
  * Fractional values draw the triangle along the line
  */
-void draw_triangle_along_line(ezgl::renderer& g, ezgl::point2d start, ezgl::point2d end, float relative_position, float arrow_size) {
+void draw_triangle_along_line(ezgl::renderer* g, ezgl::point2d start, ezgl::point2d end, float relative_position, float arrow_size) {
     VTR_ASSERT(relative_position >= 0. && relative_position <= 1.);
     float xdelta = end.x - start.x;
     float ydelta = end.y - start.y;
@@ -2741,7 +2741,7 @@
  * arrow_size, rotated such that it points in the direction
  * of the directed line segment start -> end.
  */
-void draw_triangle_along_line(ezgl::renderer& g, ezgl::point2d loc, ezgl::point2d start, ezgl::point2d end, float arrow_size) {
+void draw_triangle_along_line(ezgl::renderer* g, ezgl::point2d loc, ezgl::point2d start, ezgl::point2d end, float arrow_size) {
     draw_triangle_along_line(g, loc.x, loc.y, start.x, end.x, start.y, end.y, arrow_size);
 }
 
@@ -2753,7 +2753,7 @@
  * Note that the parameters are in a strange order
  */
 
-void draw_triangle_along_line(ezgl::renderer& g, float xend, float yend, float x1, float x2, float y1, float y2, float arrow_size) {
+void draw_triangle_along_line(ezgl::renderer* g, float xend, float yend, float x1, float x2, float y1, float y2, float arrow_size) {
     float switch_rad = arrow_size / 2;
     float xdelta, ydelta;
     float magnitude;
@@ -2775,10 +2775,10 @@
     poly.push_back({xbaseline + yunit * switch_rad, ybaseline - xunit * switch_rad});
     poly.push_back({xbaseline - yunit * switch_rad, ybaseline + xunit * switch_rad});
 
-    g.fill_poly(poly);
+    g->fill_poly(poly);
 }
 
-static void draw_pin_to_chan_edge(int pin_node, int chan_node, ezgl::renderer& g) {
+static void draw_pin_to_chan_edge(int pin_node, int chan_node, ezgl::renderer* g) {
     /* This routine draws an edge from the pin_node to the chan_node (CHANX or   *
      * CHANY).  The connection is made to the nearest end of the track instead   *
      * of perpendicular to the track to symbolize a single-drive connection.     */
@@ -2842,7 +2842,7 @@
                       "in draw_pin_to_chan_edge: Invalid channel node %d.\n", chan_node);
         }
     }
-    g.draw_line({x1, y1}, {x2, y2});
+    g->draw_line({x1, y1}, {x2, y2});
 
     //don't draw the ex, or triangle unless zoomed in really far
     if (chan_rr.direction() == BI_DIRECTION || !is_opin(pin_rr.pin_num(), grid_type)) {
@@ -2854,7 +2854,7 @@
     }
 }
 
-static void draw_pin_to_pin(int opin_node, int ipin_node, ezgl::renderer& g) {
+static void draw_pin_to_pin(int opin_node, int ipin_node, ezgl::renderer* g) {
     /* This routine draws an edge from the opin rr node to the ipin rr node */
     auto& device_ctx = g_vpr_ctx.device();
     VTR_ASSERT(device_ctx.rr_nodes[opin_node].type() == OPIN);
@@ -2866,28 +2866,28 @@
     float x2 = 0, y2 = 0;
     draw_get_rr_pin_coords(ipin_node, &x2, &y2);
 
-    g.draw_line({x1, y1}, {x2, y2});
+    g->draw_line({x1, y1}, {x2, y2});
 
     float xend = x2 + (x1 - x2) / 10.;
     float yend = y2 + (y1 - y2) / 10.;
     draw_triangle_along_line(g, xend, yend, x1, x2, y1, y2);
 }
 
-static inline void draw_mux_with_size(ezgl::point2d origin, e_side orientation, float height, int size, ezgl::renderer& g) {
-    g.set_color(ezgl::YELLOW);
+static inline void draw_mux_with_size(ezgl::point2d origin, e_side orientation, float height, int size, ezgl::renderer* g) {
+    g->set_color(ezgl::YELLOW);
     auto bounds = draw_mux(origin, orientation, height, g);
 
-    g.set_color(ezgl::BLACK);
-    g.draw_text(bounds.center(), std::to_string(size), bounds.width(), bounds.height());
+    g->set_color(ezgl::BLACK);
+    g->draw_text(bounds.center(), std::to_string(size), bounds.width(), bounds.height());
 }
 
 //Draws a mux
-static inline ezgl::rectangle draw_mux(ezgl::point2d origin, e_side orientation, float height, ezgl::renderer& g) {
+static inline ezgl::rectangle draw_mux(ezgl::point2d origin, e_side orientation, float height, ezgl::renderer* g) {
     return draw_mux(origin, orientation, height, 0.4 * height, 0.6, g);
 }
 
 //Draws a mux, height/width define the bounding box, scale [0.,1.] controls the slope of the muxes sides
-static inline ezgl::rectangle draw_mux(ezgl::point2d origin, e_side orientation, float height, float width, float scale, ezgl::renderer& g) {
+static inline ezgl::rectangle draw_mux(ezgl::point2d origin, e_side orientation, float height, float width, float scale, ezgl::renderer* g) {
     std::vector<ezgl::point2d> mux_polygon;
 
     switch (orientation) {
@@ -2923,7 +2923,7 @@
         default:
             VTR_ASSERT_MSG(false, "Unrecognized orientation");
     }
-    g.fill_poly(mux_polygon);
+    g->fill_poly(mux_polygon);
 
     ezgl::point2d min((float)mux_polygon[0].x, (float)mux_polygon[0].y);
     ezgl::point2d max((float)mux_polygon[0].x, (float)mux_polygon[0].y);
@@ -2971,7 +2971,7 @@
     return point;
 }
 
-static void draw_crit_path(ezgl::renderer& g) {
+static void draw_crit_path(ezgl::renderer* g) {
     tatum::TimingPathCollector path_collector;
 
     t_draw_state* draw_state = get_draw_state_vars();
@@ -3005,8 +3005,8 @@
 
             float delay = arr_time - prev_arr_time;
             if (draw_state->show_crit_path == DRAW_CRIT_PATH_FLYLINES || draw_state->show_crit_path == DRAW_CRIT_PATH_FLYLINES_DELAYS) {
-                g.set_color(color);
-                g.set_line_dash(ezgl::line_dash::none);
+                g->set_color(color);
+                g->set_line_dash(ezgl::line_dash::none);
                 draw_flyline_timing_edge(tnode_draw_coord(prev_node), tnode_draw_coord(node), delay, g);
             } else {
                 VTR_ASSERT(draw_state->show_crit_path != DRAW_NO_CRIT_PATH);
@@ -3020,8 +3020,8 @@
     }
 }
 
-static void draw_flyline_timing_edge(ezgl::point2d start, ezgl::point2d end, float incr_delay, ezgl::renderer& g) {
-    g.draw_line(start, end);
+static void draw_flyline_timing_edge(ezgl::point2d start, ezgl::point2d end, float incr_delay, ezgl::renderer* g) {
+    g->draw_line(start, end);
     draw_triangle_along_line(g, start, end, 0.95, 40 * DEFAULT_ARROW_SIZE);
     draw_triangle_along_line(g, start, end, 0.05, 40 * DEFAULT_ARROW_SIZE);
 
@@ -3057,25 +3057,25 @@
         ss << 1e9 * incr_delay; //In nanoseconds
         std::string incr_delay_str = ss.str();
 
-        g.draw_text(text_bbox.center(), incr_delay_str.c_str(), text_bbox.width(), text_bbox.height());
+        g->draw_text(text_bbox.center(), incr_delay_str.c_str(), text_bbox.width(), text_bbox.height());
     }
 }
 
-static void draw_routed_timing_edge(tatum::NodeId start_tnode, tatum::NodeId end_tnode, float incr_delay, ezgl::color color, ezgl::renderer& g) {
+static void draw_routed_timing_edge(tatum::NodeId start_tnode, tatum::NodeId end_tnode, float incr_delay, ezgl::color color, ezgl::renderer* g) {
     draw_routed_timing_edge_connection(start_tnode, end_tnode, color, g);
 
-    g.set_line_dash(ezgl::line_dash::asymmetric_5_3);
-    g.set_line_width(3);
-    g.set_color(color);
+    g->set_line_dash(ezgl::line_dash::asymmetric_5_3);
+    g->set_line_width(3);
+    g->set_color(color);
 
-    draw_flyline_timing_edge((ezgl::point2d)tnode_draw_coord(start_tnode), (ezgl::point2d)tnode_draw_coord(end_tnode), (float)incr_delay, (ezgl::renderer&)g);
+    draw_flyline_timing_edge((ezgl::point2d)tnode_draw_coord(start_tnode), (ezgl::point2d)tnode_draw_coord(end_tnode), (float)incr_delay, (ezgl::renderer*)g);
 
-    g.set_line_width(0);
-    g.set_line_dash(ezgl::line_dash::none);
+    g->set_line_width(0);
+    g->set_line_dash(ezgl::line_dash::none);
 }
 
 //Collect all the drawing locations associated with the timing edge between start and end
-static void draw_routed_timing_edge_connection(tatum::NodeId src_tnode, tatum::NodeId sink_tnode, ezgl::color color, ezgl::renderer& g) {
+static void draw_routed_timing_edge_connection(tatum::NodeId src_tnode, tatum::NodeId sink_tnode, ezgl::color color, ezgl::renderer* g) {
     auto& atom_ctx = g_vpr_ctx.atom();
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& timing_ctx = g_vpr_ctx.timing();
@@ -3129,7 +3129,7 @@
                 draw_state->draw_rr_node[inode].color = color;
             }
 
-            draw_partial_route((std::vector<int>)routed_rr_nodes, (ezgl::renderer&)g);
+            draw_partial_route((std::vector<int>)routed_rr_nodes, (ezgl::renderer*)g);
         } else {
             //Connection entirely within the CLB, we don't draw the internal routing so treat it as a fly-line
             VTR_ASSERT(clb_src_block == clb_sink_block);
@@ -3210,13 +3210,13 @@
     return ezgl::color(color.r * 255, color.g * 255, color.b * 255);
 }
 
-static void draw_color_map_legend(const vtr::ColorMap& cmap, ezgl::renderer& g) {
+static void draw_color_map_legend(const vtr::ColorMap& cmap, ezgl::renderer* g) {
     constexpr float LEGEND_WIDTH_FAC = 0.075;
     constexpr float LEGEND_VERT_OFFSET_FAC = 0.05;
     constexpr float TEXT_OFFSET = 10;
     constexpr size_t NUM_COLOR_POINTS = 1000;
 
-    g.set_coordinate_system(ezgl::SCREEN);
+    g->set_coordinate_system(ezgl::SCREEN);
 
     float screen_width = application.get_canvas(application.get_main_canvas_id())->width();
     float screen_height = application.get_canvas(application.get_main_canvas_id())->height();
@@ -3232,30 +3232,30 @@
         float val = cmap.min() + (float(i) / NUM_COLOR_POINTS) * range;
         ezgl::color color = to_ezgl_color(cmap.color(val));
 
-        g.set_color(color);
-        g.fill_rectangle({legend.left(), legend.top() - i * height_incr},
-                         {legend.right(), legend.top() - (i + 1) * height_incr});
+        g->set_color(color);
+        g->fill_rectangle({legend.left(), legend.top() - i * height_incr},
+                          {legend.right(), legend.top() - (i + 1) * height_incr});
     }
 
     //Min mark
-    g.set_color(blk_SKYBLUE); // set to skyblue so its easier to see
+    g->set_color(blk_SKYBLUE); // set to skyblue so its easier to see
     std::string str = vtr::string_fmt("%.3g", cmap.min());
-    g.draw_text({legend.center_x(), legend.top() - TEXT_OFFSET}, str.c_str());
+    g->draw_text({legend.center_x(), legend.top() - TEXT_OFFSET}, str.c_str());
 
     //Mid marker
-    g.set_color(ezgl::BLACK);
+    g->set_color(ezgl::BLACK);
     str = vtr::string_fmt("%.3g", cmap.min() + (cmap.range() / 2.));
-    g.draw_text({legend.center_x(), legend.center_y()}, str.c_str());
+    g->draw_text({legend.center_x(), legend.center_y()}, str.c_str());
 
     //Max marker
-    g.set_color(ezgl::BLACK);
+    g->set_color(ezgl::BLACK);
     str = vtr::string_fmt("%.3g", cmap.max());
-    g.draw_text({legend.center_x(), legend.bottom() + TEXT_OFFSET}, str.c_str());
+    g->draw_text({legend.center_x(), legend.bottom() + TEXT_OFFSET}, str.c_str());
 
-    g.set_color(ezgl::BLACK);
-    g.draw_rectangle(legend);
+    g->set_color(ezgl::BLACK);
+    g->draw_rectangle(legend);
 
-    g.set_coordinate_system(ezgl::WORLD);
+    g->set_coordinate_system(ezgl::WORLD);
 }
 
 ezgl::color get_block_type_color(t_physical_tile_type_ptr type) {
@@ -3342,7 +3342,7 @@
     }
 }
 
-static void draw_routing_util(ezgl::renderer& g) {
+static void draw_routing_util(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     if (draw_state->show_routing_util == DRAW_NO_ROUTING_UTIL) {
         return;
@@ -3387,16 +3387,16 @@
                 chanx_util = routing_util(chanx_usage[x][y], chanx_avail[x][y]);
                 ezgl::color chanx_color = to_ezgl_color(cmap->color(chanx_util));
                 chanx_color.alpha *= ALPHA;
-                g.set_color(chanx_color);
+                g->set_color(chanx_color);
                 ezgl::rectangle bb({draw_coords->tile_x[x], draw_coords->tile_y[y] + 1 * tile_height},
                                    {draw_coords->tile_x[x] + 1 * tile_width, draw_coords->tile_y[y + 1]});
-                g.fill_rectangle(bb);
+                g->fill_rectangle(bb);
 
-                g.set_color(ezgl::BLACK);
+                g->set_color(ezgl::BLACK);
                 if (draw_state->show_routing_util == DRAW_ROUTING_UTIL_WITH_VALUE) {
-                    g.draw_text(bb.center(), vtr::string_fmt("%.2f", chanx_util).c_str(), bb.width(), bb.height());
+                    g->draw_text(bb.center(), vtr::string_fmt("%.2f", chanx_util).c_str(), bb.width(), bb.height());
                 } else if (draw_state->show_routing_util == DRAW_ROUTING_UTIL_WITH_FORMULA) {
-                    g.draw_text(bb.center(), vtr::string_fmt("%.2f = %.0f / %.0f", chanx_util, chanx_usage[x][y], chanx_avail[x][y]).c_str(), bb.width(), bb.height());
+                    g->draw_text(bb.center(), vtr::string_fmt("%.2f = %.0f / %.0f", chanx_util, chanx_usage[x][y], chanx_avail[x][y]).c_str(), bb.width(), bb.height());
                 }
 
                 sb_util += chanx_util;
@@ -3407,16 +3407,16 @@
                 chany_util = routing_util(chany_usage[x][y], chany_avail[x][y]);
                 ezgl::color chany_color = to_ezgl_color(cmap->color(chany_util));
                 chany_color.alpha *= ALPHA;
-                g.set_color(chany_color);
+                g->set_color(chany_color);
                 ezgl::rectangle bb({draw_coords->tile_x[x] + 1 * tile_width, draw_coords->tile_y[y]},
                                    {draw_coords->tile_x[x + 1], draw_coords->tile_y[y] + 1 * tile_height});
-                g.fill_rectangle(bb);
+                g->fill_rectangle(bb);
 
-                g.set_color(ezgl::BLACK);
+                g->set_color(ezgl::BLACK);
                 if (draw_state->show_routing_util == DRAW_ROUTING_UTIL_WITH_VALUE) {
-                    g.draw_text(bb.center(), vtr::string_fmt("%.2f", chany_util).c_str(), bb.width(), bb.height());
+                    g->draw_text(bb.center(), vtr::string_fmt("%.2f", chany_util).c_str(), bb.width(), bb.height());
                 } else if (draw_state->show_routing_util == DRAW_ROUTING_UTIL_WITH_FORMULA) {
-                    g.draw_text(bb.center(), vtr::string_fmt("%.2f = %.0f / %.0f", chany_util, chany_usage[x][y], chany_avail[x][y]).c_str(), bb.width(), bb.height());
+                    g->draw_text(bb.center(), vtr::string_fmt("%.2f = %.0f / %.0f", chany_util, chany_usage[x][y], chany_avail[x][y]).c_str(), bb.width(), bb.height());
                 }
 
                 sb_util += chany_util;
@@ -3434,23 +3434,23 @@
             sb_util /= chan_count;
             ezgl::color sb_color = to_ezgl_color(cmap->color(sb_util));
             sb_color.alpha *= ALPHA;
-            g.set_color(sb_color);
+            g->set_color(sb_color);
             ezgl::rectangle bb({draw_coords->tile_x[x] + 1 * tile_width, draw_coords->tile_y[y] + 1 * tile_height},
                                {draw_coords->tile_x[x + 1], draw_coords->tile_y[y + 1]});
-            g.fill_rectangle(bb);
+            g->fill_rectangle(bb);
 
             //Draw over blocks
             if (draw_state->show_routing_util == DRAW_ROUTING_UTIL_OVER_BLOCKS) {
                 if (x < device_ctx.grid.width() - 2 && y < device_ctx.grid.height() - 2) {
                     ezgl::rectangle bb2({draw_coords->tile_x[x + 1], draw_coords->tile_y[y + 1]},
                                         {draw_coords->tile_x[x + 1] + 1 * tile_width, draw_coords->tile_y[y + 1] + 1 * tile_width});
-                    g.fill_rectangle(bb2);
+                    g->fill_rectangle(bb2);
                 }
             }
-            g.set_color(ezgl::BLACK);
+            g->set_color(ezgl::BLACK);
             if (draw_state->show_routing_util == DRAW_ROUTING_UTIL_WITH_VALUE
                 || draw_state->show_routing_util == DRAW_ROUTING_UTIL_WITH_FORMULA) {
-                g.draw_text(bb.center(), vtr::string_fmt("%.2f", sb_util).c_str(), bb.width(), bb.height());
+                g->draw_text(bb.center(), vtr::string_fmt("%.2f", sb_util).c_str(), bb.width(), bb.height());
             }
         }
     }
@@ -3470,7 +3470,7 @@
     VPR_THROW(VPR_ERROR_DRAW, "Invalid Router RR cost drawing type");
 }
 
-static void draw_router_rr_costs(ezgl::renderer& g) {
+static void draw_router_rr_costs(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     if (draw_state->show_router_rr_cost == DRAW_NO_ROUTER_RR_COST) {
         return;
@@ -3508,14 +3508,14 @@
     }
 }
 
-static void draw_rr_costs(ezgl::renderer& g, const std::vector<float>& rr_costs, bool lowest_cost_first) {
+static void draw_rr_costs(ezgl::renderer* g, const std::vector<float>& rr_costs, bool lowest_cost_first) {
     t_draw_state* draw_state = get_draw_state_vars();
 
     /* Draws routing costs */
 
     auto& device_ctx = g_vpr_ctx.device();
 
-    g.set_line_width(0);
+    g->set_line_width(0);
 
     VTR_ASSERT(rr_costs.size() == device_ctx.rr_nodes.size());
 
@@ -3532,7 +3532,7 @@
     std::unique_ptr<vtr::ColorMap> cmap = std::make_unique<vtr::PlasmaColorMap>(min_cost, max_cost);
 
     //Draw the nodes in ascending order of value, this ensures high valued nodes
-    //are not overdrawn by lower value ones (e.g. when zoomed-out far)
+    //are not overdrawn by lower value ones (e.g-> when zoomed-out far)
     std::vector<int> nodes(device_ctx.rr_nodes.size());
     std::iota(nodes.begin(), nodes.end(), 0);
     auto cmp_ascending_cost = [&](int lhs_node, int rhs_node) {
@@ -3576,7 +3576,7 @@
     draw_state->color_map = std::move(cmap);
 }
 
-static void draw_placement_macros(ezgl::renderer& g) {
+static void draw_placement_macros(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
 
     if (draw_state->show_placement_macros == DRAW_NO_PLACEMENT_MACROS) {
@@ -3620,13 +3620,13 @@
         double draw_xhigh = draw_coords->tile_x[xhigh];
         double draw_yhigh = draw_coords->tile_y[yhigh];
 
-        g.set_color(blk_RED);
-        g.draw_rectangle({draw_xlow, draw_ylow}, {draw_xhigh, draw_yhigh});
+        g->set_color(blk_RED);
+        g->draw_rectangle({draw_xlow, draw_ylow}, {draw_xhigh, draw_yhigh});
 
         ezgl::color fill = blk_SKYBLUE;
         fill.alpha *= 0.3;
-        g.set_color(fill);
-        g.fill_rectangle({draw_xlow, draw_ylow}, {draw_xhigh, draw_yhigh});
+        g->set_color(fill);
+        g->fill_rectangle({draw_xlow, draw_ylow}, {draw_xhigh, draw_yhigh});
     }
 }
 
diff --git a/vpr/src/draw/draw.h b/vpr/src/draw/draw.h
index e161f50..eb8dd4c 100644
--- a/vpr/src/draw/draw.h
+++ b/vpr/src/draw/draw.h
@@ -34,9 +34,9 @@
 void draw_get_rr_pin_coords(int inode, float* xcen, float* ycen);
 void draw_get_rr_pin_coords(const t_rr_node* node, float* xcen, float* ycen);
 
-void draw_triangle_along_line(ezgl::renderer& g, ezgl::point2d start, ezgl::point2d end, float relative_position = 1., float arrow_size = DEFAULT_ARROW_SIZE);
-void draw_triangle_along_line(ezgl::renderer& g, ezgl::point2d loc, ezgl::point2d start, ezgl::point2d end, float arrow_size = DEFAULT_ARROW_SIZE);
-void draw_triangle_along_line(ezgl::renderer& g, float xend, float yend, float x1, float x2, float y1, float y2, float arrow_size = DEFAULT_ARROW_SIZE);
+void draw_triangle_along_line(ezgl::renderer* g, ezgl::point2d start, ezgl::point2d end, float relative_position = 1., float arrow_size = DEFAULT_ARROW_SIZE);
+void draw_triangle_along_line(ezgl::renderer* g, ezgl::point2d loc, ezgl::point2d start, ezgl::point2d end, float arrow_size = DEFAULT_ARROW_SIZE);
+void draw_triangle_along_line(ezgl::renderer* g, float xend, float yend, float x1, float x2, float y1, float y2, float arrow_size = DEFAULT_ARROW_SIZE);
 
 const ezgl::color SELECTED_COLOR = ezgl::GREEN;
 const ezgl::color DRIVES_IT_COLOR = ezgl::RED;
diff --git a/vpr/src/draw/intra_logic_block.cpp b/vpr/src/draw/intra_logic_block.cpp
index 96f64c2..40eb8aa 100644
--- a/vpr/src/draw/intra_logic_block.cpp
+++ b/vpr/src/draw/intra_logic_block.cpp
@@ -2,10 +2,10 @@
  * The four main subroutines defined here are draw_internal_alloc_blk(),
  * draw_internal_init_blk(), draw_internal_draw_subblk(), and toggle_blk_internal().
  * When VPR graphics initially sets up, draw_internal_alloc_blk() will be called from
- * draw.c to allocate space for the structures needed for internal blks drawing.
+ * draw.c to allocate space for the structures needed for internal blks drawing->
  * Before any drawing, draw_internal_init_blk() will pre-compute a bounding box
  * for each sub-block in the pb_graph of every physical block type. When the menu button
- * "Blk Internal" is pressed, toggle_blk_internal() will enable internal blocks drawing.
+ * "Blk Internal" is pressed, toggle_blk_internal() will enable internal blocks drawing->
  * Then, with each subsequent click on the button, toggle_blk_internal() will propel one
  * more level of pbs to be drawn. Draw_internal_draw_subblk() will be called whenever
  * new blocks need to be drawn, and this function is responsible for drawing sub-blocks
@@ -46,10 +46,10 @@
 t_pb* highlight_sub_block_helper(const ClusterBlockId clb_index, t_pb* pb, const ezgl::point2d& local_pt, int max_depth);
 
 #    ifndef NO_GRAPHICS
-static void draw_internal_pb(const ClusterBlockId clb_index, t_pb* pb, const ezgl::rectangle& parent_bbox, const t_logical_block_type_ptr type, ezgl::renderer& g);
-void draw_atoms_fanin_fanout_flylines(const std::vector<AtomBlockId>& atoms, ezgl::renderer& g);
-void draw_selected_pb_flylines(ezgl::renderer& g);
-void draw_one_logical_connection(const AtomPinId src_pin, const AtomPinId sink_pin, ezgl::renderer& g);
+static void draw_internal_pb(const ClusterBlockId clb_index, t_pb* pb, const ezgl::rectangle& parent_bbox, const t_logical_block_type_ptr type, ezgl::renderer* g);
+void draw_atoms_fanin_fanout_flylines(const std::vector<AtomBlockId>& atoms, ezgl::renderer* g);
+void draw_selected_pb_flylines(ezgl::renderer* g);
+void draw_one_logical_connection(const AtomPinId src_pin, const AtomPinId sink_pin, ezgl::renderer* g);
 #    endif /* NO_GRAPHICS */
 
 /************************* Subroutine definitions begin *********************************/
@@ -135,7 +135,7 @@
 }
 
 #    ifndef NO_GRAPHICS
-void draw_internal_draw_subblk(ezgl::renderer& g) {
+void draw_internal_draw_subblk(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     if (!draw_state->show_blk_internal) {
         return;
@@ -316,7 +316,7 @@
  * which a netlist block can map to, and draws each sub-block inside its parent block. With
  * each click on the "Blk Internal" button, a new level is shown.
  */
-static void draw_internal_pb(const ClusterBlockId clb_index, t_pb* pb, const ezgl::rectangle& parent_bbox, const t_logical_block_type_ptr type, ezgl::renderer& g) {
+static void draw_internal_pb(const ClusterBlockId clb_index, t_pb* pb, const ezgl::rectangle& parent_bbox, const t_logical_block_type_ptr type, ezgl::renderer* g) {
     t_draw_coords* draw_coords = get_draw_coords_vars();
     t_draw_state* draw_state = get_draw_state_vars();
     t_selected_sub_block_info& sel_sub_info = get_selected_sub_block_info();
@@ -336,52 +336,52 @@
             // if this is a top level pb, and only if it isn't selected (ie. a funny colour),
             // overwrite it. (but stil draw the text)
 
-            g.set_color(ezgl::WHITE);
-            g.fill_rectangle(abs_bbox);
-            g.set_color(ezgl::BLACK);
-            g.set_line_dash(ezgl::line_dash::none);
-            g.draw_rectangle(abs_bbox);
+            g->set_color(ezgl::WHITE);
+            g->fill_rectangle(abs_bbox);
+            g->set_color(ezgl::BLACK);
+            g->set_line_dash(ezgl::line_dash::none);
+            g->draw_rectangle(abs_bbox);
         }
     } else {
         if (pb->name != nullptr) {
             // If block is used, draw it in colour with solid border.
-            g.set_line_dash(ezgl::line_dash::none);
+            g->set_line_dash(ezgl::line_dash::none);
 
             // type_index indicates what type of block.
             const int type_index = type->index;
 
             // determine default background color
             if (sel_sub_info.is_selected(pb->pb_graph_node, clb_index)) {
-                g.set_color(SELECTED_COLOR);
+                g->set_color(SELECTED_COLOR);
             } else if (sel_sub_info.is_sink_of_selected(pb->pb_graph_node, clb_index)) {
-                g.set_color(DRIVES_IT_COLOR);
+                g->set_color(DRIVES_IT_COLOR);
             } else if (sel_sub_info.is_source_of_selected(pb->pb_graph_node, clb_index)) {
-                g.set_color(DRIVEN_BY_IT_COLOR);
+                g->set_color(DRIVEN_BY_IT_COLOR);
             } else if (pb_type->depth != draw_state->show_blk_internal && pb->child_pbs != nullptr) {
-                g.set_color(ezgl::WHITE); // draw anything else that will have a child as white
+                g->set_color(ezgl::WHITE); // draw anything else that will have a child as white
             } else if (type_index < 3) {
-                g.set_color(blk_LIGHTGREY);
+                g->set_color(blk_LIGHTGREY);
             } else if (type_index < 3 + MAX_BLOCK_COLOURS) {
-                g.set_color((block_colors[MAX_BLOCK_COLOURS + type_index - 3]));
+                g->set_color((block_colors[MAX_BLOCK_COLOURS + type_index - 3]));
             } else {
-                g.set_color((block_colors[2 * MAX_BLOCK_COLOURS - 1]));
+                g->set_color((block_colors[2 * MAX_BLOCK_COLOURS - 1]));
             }
         } else {
             // If block is not used, draw as empty block (ie. white
             // background with dashed border).
 
-            g.set_line_dash(ezgl::line_dash::asymmetric_5_3);
-            g.set_color(ezgl::WHITE);
+            g->set_line_dash(ezgl::line_dash::asymmetric_5_3);
+            g->set_color(ezgl::WHITE);
         }
-        g.fill_rectangle(abs_bbox);
-        g.set_color(ezgl::BLACK);
-        g.draw_rectangle(abs_bbox);
+        g->fill_rectangle(abs_bbox);
+        g->set_color(ezgl::BLACK);
+        g->draw_rectangle(abs_bbox);
     }
 
     /// then draw text ///
 
     if (pb->name != nullptr) {
-        g.set_font_size(16); // note: calc_text_xbound(...) assumes this is 16
+        g->set_font_size(16); // note: calc_text_xbound(...) assumes this is 16
         if (pb_type->depth == draw_state->show_blk_internal || pb->child_pbs == nullptr) {
             // If this pb is at the lowest displayed level, or has no more children, then
             // label it in the center with its type and name
@@ -393,7 +393,7 @@
 
             sprintf(blk_tag, "%s(%s)", pb_type->name, pb->name);
 
-            g.draw_text(
+            g->draw_text(
                 abs_bbox.center(),
                 blk_tag,
                 abs_bbox.width(),
@@ -403,7 +403,7 @@
         } else {
             // else (ie. has chilren, and isn't at the lowest displayed level)
             // just label its type, and put it up at the top so we can see it
-            g.draw_text(
+            g->draw_text(
                 ezgl::point2d(abs_bbox.center_x(),
                               abs_bbox.top() - (abs_bbox.height()) / 15.0),
                 pb_type->name,
@@ -412,7 +412,7 @@
         }
     } else {
         // If child block is not used, label it only by its type
-        g.draw_text(
+        g->draw_text(
             abs_bbox.center(),
             pb_type->name,
             abs_bbox.width(),
@@ -452,7 +452,7 @@
     }
 }
 
-void draw_selected_pb_flylines(ezgl::renderer& g) {
+void draw_selected_pb_flylines(ezgl::renderer* g) {
     t_selected_sub_block_info& sel_sub_info = get_selected_sub_block_info();
 
     const t_pb* pb = sel_sub_info.get_selected_pb();
@@ -463,13 +463,13 @@
     }
 }
 
-void draw_atoms_fanin_fanout_flylines(const std::vector<AtomBlockId>& atoms, ezgl::renderer& g) {
+void draw_atoms_fanin_fanout_flylines(const std::vector<AtomBlockId>& atoms, ezgl::renderer* g) {
     std::set<AtomBlockId> atoms_set(atoms.begin(), atoms.end());
 
     auto& atom_nl = g_vpr_ctx.atom().nlist;
 
-    g.set_line_dash(ezgl::line_dash::none);
-    g.set_line_width(2);
+    g->set_line_dash(ezgl::line_dash::none);
+    g->set_line_width(2);
 
     for (AtomBlockId blk : atoms) {
         for (AtomPinId ipin : atom_nl.block_input_pins(blk)) {
@@ -479,14 +479,14 @@
             AtomBlockId net_driver_blk = atom_nl.pin_block(net_driver);
 
             if (atoms_set.count(net_driver_blk)) {
-                g.set_color(ezgl::ORANGE); //Internal
+                g->set_color(ezgl::ORANGE); //Internal
             } else {
-                g.set_color(ezgl::BLUE); //External input
+                g->set_color(ezgl::BLUE); //External input
             }
 
             ezgl::point2d start = atom_pin_draw_coord(net_driver);
             ezgl::point2d end = atom_pin_draw_coord(ipin);
-            g.draw_line(start, end);
+            g->draw_line(start, end);
             draw_triangle_along_line(g, start, end, 0.95, 40 * DEFAULT_ARROW_SIZE);
             draw_triangle_along_line(g, start, end, 0.05, 40 * DEFAULT_ARROW_SIZE);
         }
@@ -498,14 +498,14 @@
                 AtomBlockId net_sink_blk = atom_nl.pin_block(net_sink);
 
                 if (atoms_set.count(net_sink_blk)) {
-                    g.set_color(ezgl::ORANGE); //Internal
+                    g->set_color(ezgl::ORANGE); //Internal
                 } else {
-                    g.set_color(ezgl::RED); //External output
+                    g->set_color(ezgl::RED); //External output
                 }
 
                 ezgl::point2d start = atom_pin_draw_coord(opin);
                 ezgl::point2d end = atom_pin_draw_coord(net_sink);
-                g.draw_line(start, end);
+                g->draw_line(start, end);
                 draw_triangle_along_line(g, start, end, 0.95, 40 * DEFAULT_ARROW_SIZE);
                 draw_triangle_along_line(g, start, end, 0.05, 40 * DEFAULT_ARROW_SIZE);
             }
@@ -542,13 +542,13 @@
 }
 
 #    ifndef NO_GRAPHICS
-void draw_logical_connections(ezgl::renderer& g) {
+void draw_logical_connections(ezgl::renderer* g) {
     const t_selected_sub_block_info& sel_subblk_info = get_selected_sub_block_info();
     t_draw_state* draw_state = get_draw_state_vars();
 
     auto& atom_ctx = g_vpr_ctx.atom();
 
-    g.set_line_dash(ezgl::line_dash::none);
+    g->set_line_dash(ezgl::line_dash::none);
 
     // iterate over all the atom nets
     for (auto net_id : atom_ctx.nlist.nets()) {
@@ -566,11 +566,11 @@
             ClusterBlockId sink_clb = atom_ctx.lookup.atom_clb(sink_blk_id);
 
             if (src_is_selected && sel_subblk_info.is_sink_of_selected(sink_pb_gnode, sink_clb)) {
-                g.set_color(DRIVES_IT_COLOR);
+                g->set_color(DRIVES_IT_COLOR);
             } else if (src_is_src_of_selected && sel_subblk_info.is_in_selected_subtree(sink_pb_gnode, sink_clb)) {
-                g.set_color(DRIVEN_BY_IT_COLOR);
+                g->set_color(DRIVEN_BY_IT_COLOR);
             } else if (draw_state->show_nets == DRAW_LOGICAL_CONNECTIONS && (draw_state->showing_sub_blocks() || src_clb != sink_clb)) {
-                g.set_color(ezgl::BLACK); // if showing all, draw the other ones in black
+                g->set_color(ezgl::BLACK); // if showing all, draw the other ones in black
             } else {
                 continue; // not showing all, and not the sperified block, so skip
             }
@@ -635,12 +635,12 @@
  * The *_abs_bbox parameters are for mild optmization, as the absolute bbox can be calculated
  * more effeciently elsewhere.
  */
-void draw_one_logical_connection(const AtomPinId src_pin, const AtomPinId sink_pin, ezgl::renderer& g) {
+void draw_one_logical_connection(const AtomPinId src_pin, const AtomPinId sink_pin, ezgl::renderer* g) {
     ezgl::point2d src_point = atom_pin_draw_coord(src_pin);
     ezgl::point2d sink_point = atom_pin_draw_coord(sink_pin);
 
     // draw a link connecting the pins.
-    g.draw_line(src_point, sink_point);
+    g->draw_line(src_point, sink_point);
 
     auto& atom_ctx = g_vpr_ctx.atom();
     if (atom_ctx.lookup.atom_clb(atom_ctx.nlist.pin_block(src_pin)) == atom_ctx.lookup.atom_clb(atom_ctx.nlist.pin_block(sink_pin))) {
diff --git a/vpr/src/draw/intra_logic_block.h b/vpr/src/draw/intra_logic_block.h
index dff491e..0cc0788 100644
--- a/vpr/src/draw/intra_logic_block.h
+++ b/vpr/src/draw/intra_logic_block.h
@@ -114,7 +114,7 @@
  * grid tiles and calls helper function to draw inside each block.
  */
 #    ifndef NO_GRAPHICS
-void draw_internal_draw_subblk(ezgl::renderer& g);
+void draw_internal_draw_subblk(ezgl::renderer* g);
 #    endif /* NO_GRAPHICS */
 
 /* Determines which part of a block to highlight, and stores it,
@@ -134,7 +134,7 @@
  * and if there is a selected sub-block, it will highlight it's conections
  */
 
-void draw_logical_connections(ezgl::renderer& g);
+void draw_logical_connections(ezgl::renderer* g);
 
 void find_pin_index_at_model_scope(const AtomPinId the_pin, const AtomBlockId lblk, int* pin_index, int* total_pins);