diff --git a/drivers/st7789/st7789.cpp b/drivers/st7789/st7789.cpp
index 705641ff..36fddfa8 100644
--- a/drivers/st7789/st7789.cpp
+++ b/drivers/st7789/st7789.cpp
@@ -118,6 +118,30 @@ namespace pimoroni {
     //   dma_channel, &config, &spi_get_hw(spi)->dr, frame_buffer, width * height, false);
   }
 
+  spi_inst_t* ST7789::get_spi() const {
+    return spi;
+  }
+
+  int ST7789::get_cs() const {
+    return cs;
+  }
+
+  int ST7789::get_dc() const {
+    return dc;
+  }
+
+  int ST7789::get_sck() const {
+    return sck;
+  }
+
+  int ST7789::get_mosi() const {
+    return mosi;
+  }
+
+  int ST7789::get_bl() const {
+    return bl;
+  }
+
   void ST7789::command(uint8_t command, size_t len, const char *data) {
     //dma_channel_wait_for_finish_blocking(dma_channel);
 
diff --git a/drivers/st7789/st7789.hpp b/drivers/st7789/st7789.hpp
index 4b352ada..2061fcba 100644
--- a/drivers/st7789/st7789.hpp
+++ b/drivers/st7789/st7789.hpp
@@ -43,6 +43,13 @@ namespace pimoroni {
 
     void init(bool auto_init_sequence = true, bool round = false);
 
+    spi_inst_t* get_spi() const;
+    int get_cs() const;
+    int get_dc() const;    
+    int get_sck() const;
+    int get_mosi() const;
+    int get_bl() const;
+
     void command(uint8_t command, size_t len = 0, const char *data = NULL);
     void vsync_callback(gpio_irq_callback_t callback);
     void update(bool dont_block = false);
diff --git a/libraries/breakout_roundlcd/breakout_roundlcd.cpp b/libraries/breakout_roundlcd/breakout_roundlcd.cpp
index 2e9fa620..157899d8 100644
--- a/libraries/breakout_roundlcd/breakout_roundlcd.cpp
+++ b/libraries/breakout_roundlcd/breakout_roundlcd.cpp
@@ -18,29 +18,29 @@ namespace pimoroni {
     screen.init(true, true);
   }
 
-  // spi_inst_t* BreakoutRoundLCD::get_spi() const {
-  //   return screen.get_spi();
-  // }
+  spi_inst_t* BreakoutRoundLCD::get_spi() const {
+    return screen.get_spi();
+  }
 
-  // int BreakoutRoundLCD::get_cs() const {
-  //   return screen.get_cs();
-  // }
+  int BreakoutRoundLCD::get_cs() const {
+    return screen.get_cs();
+  }
 
-  // int BreakoutRoundLCD::get_dc() const {
-  //   return screen.get_dc();
-  // }
+  int BreakoutRoundLCD::get_dc() const {
+    return screen.get_dc();
+  }
 
-  // int BreakoutRoundLCD::get_sck() const {
-  //   return screen.get_sck();
-  // }
+  int BreakoutRoundLCD::get_sck() const {
+    return screen.get_sck();
+  }
 
-  // int BreakoutRoundLCD::get_mosi() const {
-  //   return screen.get_mosi();
-  // }
+  int BreakoutRoundLCD::get_mosi() const {
+    return screen.get_mosi();
+  }
 
-  // int BreakoutRoundLCD::get_miso() const {
-  //   return screen.get_miso();
-  // }
+  int BreakoutRoundLCD::get_bl() const {
+    return screen.get_bl();
+  }
 
   void BreakoutRoundLCD::update() {
     screen.update();
diff --git a/libraries/breakout_roundlcd/breakout_roundlcd.hpp b/libraries/breakout_roundlcd/breakout_roundlcd.hpp
index a03a6bdd..0f707b3a 100644
--- a/libraries/breakout_roundlcd/breakout_roundlcd.hpp
+++ b/libraries/breakout_roundlcd/breakout_roundlcd.hpp
@@ -39,12 +39,12 @@ namespace pimoroni {
   public:
     void init();
 
-    // spi_inst_t* get_spi() const;
-    // int get_cs() const;
-    // int get_dc() const;
-    // int get_sck() const;
-    // int get_mosi() const;
-    // int get_miso() const;
+    spi_inst_t* get_spi() const;
+    int get_cs() const;
+    int get_dc() const;
+    int get_sck() const;
+    int get_mosi() const;
+    int get_bl() const;
 
     void update();
     void set_backlight(uint8_t brightness);
diff --git a/micropython/examples/breakout_roundlcd/demo.py b/micropython/examples/breakout_roundlcd/demo.py
new file mode 100644
index 00000000..63c5265c
--- /dev/null
+++ b/micropython/examples/breakout_roundlcd/demo.py
@@ -0,0 +1,69 @@
+import time, random, math
+from breakout_roundlcd import BreakoutRoundLCD
+
+width = BreakoutRoundLCD.WIDTH
+height = BreakoutRoundLCD.HEIGHT
+
+display_buffer = bytearray(width * height * 2)  # 2-bytes per pixel (RGB565)
+display = BreakoutRoundLCD(display_buffer)
+
+display.set_backlight(1.0)
+
+RADIUS = width // 2
+
+def hsv_to_rgb(h, s, v):
+    if s == 0.0:
+        return v, v, v
+    i = int(h * 6.0) # XXX assume int() truncates!
+    f = (h * 6.0) - i
+    p = v * (1.0 - s)
+    q = v * (1.0 - s * f)
+    t = v * (1.0 - s * (1.0 - f))
+    i = i % 6
+    if i == 0:
+        return v, t, p
+    if i == 1:
+        return q, v, p
+    if i == 2:
+        return p, v, t
+    if i == 3:
+        return p, q, v
+    if i == 4:
+        return t, p, v
+    if i == 5:
+        return v, p, q
+
+t = 0
+while True:
+    display.set_pen(0, 0, 0)
+    display.clear()
+
+    angle = t % (math.pi * 2)
+    
+    prev_x = RADIUS
+    prev_y = RADIUS
+
+    steps = 30.0
+    angle_step = 0.5
+        
+    for step in range(int(steps)):
+        angle += angle_step
+
+        distance = RADIUS / steps * step
+        distance += step * 0.2
+
+        r, g, b = [int(c * 255) for c in hsv_to_rgb((t / 10.0) + distance / 120.0, 1.0, 1.0)]
+
+        x = RADIUS + int(distance * math.cos(angle))
+        y = RADIUS + int(distance * math.sin(angle))
+
+        l = ((math.sin(t + angle) + 1) / 2.0) * 10
+        display.set_pen(r, g, b)
+        display.circle(int(x), int(y), int(l))
+
+        prev_x = x
+        prev_y = y
+ 
+    display.update()
+    time.sleep(0.02)
+    t += 0.02
\ No newline at end of file
diff --git a/micropython/modules/breakout_roundlcd/breakout_roundlcd.c b/micropython/modules/breakout_roundlcd/breakout_roundlcd.c
new file mode 100644
index 00000000..4010fcca
--- /dev/null
+++ b/micropython/modules/breakout_roundlcd/breakout_roundlcd.c
@@ -0,0 +1,78 @@
+#include "breakout_roundlcd.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// BreakoutRoundLCD Class
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/***** Methods *****/
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRoundLCD_update_obj, BreakoutRoundLCD_update);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_set_backlight_obj, 1, BreakoutRoundLCD_set_backlight);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_set_pen_obj, 1, BreakoutRoundLCD_set_pen);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_create_pen_obj, 1, BreakoutRoundLCD_create_pen);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_set_clip_obj, 1, BreakoutRoundLCD_set_clip);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRoundLCD_remove_clip_obj, BreakoutRoundLCD_remove_clip);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRoundLCD_clear_obj, BreakoutRoundLCD_clear);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_pixel_obj, 1, BreakoutRoundLCD_pixel);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_pixel_span_obj, 1, BreakoutRoundLCD_pixel_span);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_rectangle_obj, 1, BreakoutRoundLCD_rectangle);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_circle_obj, 1, BreakoutRoundLCD_circle);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_character_obj, 1, BreakoutRoundLCD_character);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_text_obj, 1, BreakoutRoundLCD_text);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_polygon_obj, 1, BreakoutRoundLCD_polygon);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_triangle_obj, 1, BreakoutRoundLCD_triangle);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRoundLCD_line_obj, 1, BreakoutRoundLCD_line);
+
+/***** Binding of Methods *****/
+STATIC const mp_rom_map_elem_t BreakoutRoundLCD_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&BreakoutRoundLCD_update_obj) },
+    { MP_ROM_QSTR(MP_QSTR_set_backlight), MP_ROM_PTR(&BreakoutRoundLCD_set_backlight_obj) },
+    { MP_ROM_QSTR(MP_QSTR_set_pen), MP_ROM_PTR(&BreakoutRoundLCD_set_pen_obj) },
+    { MP_ROM_QSTR(MP_QSTR_create_pen), MP_ROM_PTR(&BreakoutRoundLCD_create_pen_obj) },
+    { MP_ROM_QSTR(MP_QSTR_set_clip), MP_ROM_PTR(&BreakoutRoundLCD_set_clip_obj) },
+    { MP_ROM_QSTR(MP_QSTR_remove_clip), MP_ROM_PTR(&BreakoutRoundLCD_remove_clip_obj) },
+    { MP_ROM_QSTR(MP_QSTR_clear), MP_ROM_PTR(&BreakoutRoundLCD_clear_obj) },
+    { MP_ROM_QSTR(MP_QSTR_pixel), MP_ROM_PTR(&BreakoutRoundLCD_pixel_obj) },
+    { MP_ROM_QSTR(MP_QSTR_pixel_span), MP_ROM_PTR(&BreakoutRoundLCD_pixel_span_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rectangle), MP_ROM_PTR(&BreakoutRoundLCD_rectangle_obj) },
+    { MP_ROM_QSTR(MP_QSTR_circle), MP_ROM_PTR(&BreakoutRoundLCD_circle_obj) },
+    { MP_ROM_QSTR(MP_QSTR_character), MP_ROM_PTR(&BreakoutRoundLCD_character_obj) },
+    { MP_ROM_QSTR(MP_QSTR_text), MP_ROM_PTR(&BreakoutRoundLCD_text_obj) },
+    { MP_ROM_QSTR(MP_QSTR_polygon), MP_ROM_PTR(&BreakoutRoundLCD_polygon_obj) },
+    { MP_ROM_QSTR(MP_QSTR_triangle), MP_ROM_PTR(&BreakoutRoundLCD_triangle_obj) },
+    { MP_ROM_QSTR(MP_QSTR_line), MP_ROM_PTR(&BreakoutRoundLCD_line_obj) },
+    { MP_ROM_QSTR(MP_QSTR_WIDTH), MP_ROM_INT(WIDTH) },
+    { MP_ROM_QSTR(MP_QSTR_HEIGHT), MP_ROM_INT(HEIGHT) },
+};
+STATIC MP_DEFINE_CONST_DICT(BreakoutRoundLCD_locals_dict, BreakoutRoundLCD_locals_dict_table);
+
+/***** Class Definition *****/
+const mp_obj_type_t breakout_roundlcd_BreakoutRoundLCD_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_breakout_roundlcd,
+    .print = BreakoutRoundLCD_print,
+    .make_new = BreakoutRoundLCD_make_new,
+    .locals_dict = (mp_obj_dict_t*)&BreakoutRoundLCD_locals_dict,
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// breakout_roundlcd Module
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/***** Globals Table *****/
+STATIC const mp_map_elem_t breakout_roundlcd_globals_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_breakout_roundlcd) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_BreakoutRoundLCD), (mp_obj_t)&breakout_roundlcd_BreakoutRoundLCD_type },
+};
+STATIC MP_DEFINE_CONST_DICT(mp_module_breakout_roundlcd_globals, breakout_roundlcd_globals_table);
+
+/***** Module Definition *****/
+const mp_obj_module_t breakout_roundlcd_user_cmodule = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&mp_module_breakout_roundlcd_globals,
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+MP_REGISTER_MODULE(MP_QSTR_breakout_roundlcd, breakout_roundlcd_user_cmodule, MODULE_BREAKOUT_ROUNDLCD_ENABLED);
+////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
\ No newline at end of file
diff --git a/micropython/modules/breakout_roundlcd/breakout_roundlcd.cpp b/micropython/modules/breakout_roundlcd/breakout_roundlcd.cpp
new file mode 100644
index 00000000..50aaeb12
--- /dev/null
+++ b/micropython/modules/breakout_roundlcd/breakout_roundlcd.cpp
@@ -0,0 +1,499 @@
+#include "../../../pimoroni-pico/libraries/breakout_roundlcd/breakout_roundlcd.hpp"
+
+#define MP_OBJ_TO_PTR2(o, t) ((t *)(uintptr_t)(o))
+
+#define IS_VALID_PERIPH(spi, pin)   ((((pin) & 8) >> 3) == (spi))
+#define IS_VALID_SCK(spi, pin)      (((pin) & 3) == 2 && IS_VALID_PERIPH(spi, pin))
+#define IS_VALID_MOSI(spi, pin)     (((pin) & 3) == 3 && IS_VALID_PERIPH(spi, pin))
+#define IS_VALID_MISO(spi, pin)     (((pin) & 3) == 0 && IS_VALID_PERIPH(spi, pin))
+
+
+using namespace pimoroni;
+
+extern "C" {
+#include "breakout_roundlcd.h"
+
+/***** Variables Struct *****/
+typedef struct _breakout_roundlcd_BreakoutRoundLCD_obj_t {
+    mp_obj_base_t base;
+    BreakoutRoundLCD *breakout;
+} breakout_roundlcd_BreakoutRoundLCD_obj_t;
+
+/***** Print *****/
+void BreakoutRoundLCD_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    (void)kind; //Unused input parameter    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+    BreakoutRoundLCD* breakout = self->breakout;
+    mp_print_str(print, "BreakoutRoundLCD(");
+
+    mp_print_str(print, "spi = ");
+    mp_obj_print_helper(print, mp_obj_new_int((breakout->get_spi() == spi0) ? 0 : 1), PRINT_REPR);
+
+    mp_print_str(print, ", cs = ");
+    mp_obj_print_helper(print, mp_obj_new_int(breakout->get_cs()), PRINT_REPR);
+
+    mp_print_str(print, ", dc = ");
+    mp_obj_print_helper(print, mp_obj_new_int(breakout->get_dc()), PRINT_REPR);
+
+    mp_print_str(print, ", sck = ");
+    mp_obj_print_helper(print, mp_obj_new_int(breakout->get_sck()), PRINT_REPR);
+
+    mp_print_str(print, ", mosi = ");
+    mp_obj_print_helper(print, mp_obj_new_int(breakout->get_mosi()), PRINT_REPR);
+
+    mp_print_str(print, ", bl = ");
+    mp_obj_print_helper(print, mp_obj_new_int(breakout->get_bl()), PRINT_REPR);
+
+    mp_print_str(print, ")");
+}
+
+/***** Constructor *****/
+mp_obj_t BreakoutRoundLCD_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = nullptr;
+
+    if(n_args <= 1) {
+        enum { ARG_buffer };
+        static const mp_arg_t allowed_args[] = {
+            { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        };
+
+        // Parse args.
+        mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+        mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+        self = m_new_obj(breakout_roundlcd_BreakoutRoundLCD_obj_t);
+        self->base.type = &breakout_roundlcd_BreakoutRoundLCD_type;
+        
+        mp_buffer_info_t bufinfo;
+        mp_get_buffer_raise(args[ARG_buffer].u_obj, &bufinfo, MP_BUFFER_RW);
+
+        self->breakout = new BreakoutRoundLCD((uint16_t *)bufinfo.buf);     
+    }
+    else {
+        enum { ARG_buffer, ARG_spi, ARG_cs, ARG_dc, ARG_sck, ARG_mosi };
+        static const mp_arg_t allowed_args[] = {
+            { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ },
+            { MP_QSTR_spi, MP_ARG_REQUIRED | MP_ARG_INT },
+            { MP_QSTR_cs, MP_ARG_REQUIRED | MP_ARG_INT },
+            { MP_QSTR_dc, MP_ARG_REQUIRED | MP_ARG_INT },
+            { MP_QSTR_sck, MP_ARG_REQUIRED | MP_ARG_INT },
+            { MP_QSTR_mosi, MP_ARG_REQUIRED | MP_ARG_INT },
+        };
+
+        // Parse args.
+        mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+        mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+        mp_buffer_info_t bufinfo;
+        mp_get_buffer_raise(args[ARG_buffer].u_obj, &bufinfo, MP_BUFFER_RW);
+
+        // Get SPI bus.
+        int spi_id = args[ARG_spi].u_int;
+        if(spi_id < 0 || spi_id > 1) {
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("SPI(%d) doesn't exist"), spi_id);
+        }
+
+        int sck = args[ARG_sck].u_int;
+        if(!IS_VALID_SCK(spi_id, sck)) {
+            mp_raise_ValueError(MP_ERROR_TEXT("bad SCK pin"));
+        }       
+
+        int mosi = args[ARG_mosi].u_int;
+        if(!IS_VALID_SCK(spi_id, mosi)) {
+            mp_raise_ValueError(MP_ERROR_TEXT("bad MOSI pin"));
+        }
+
+        self = m_new_obj(breakout_roundlcd_BreakoutRoundLCD_obj_t);
+        self->base.type = &breakout_roundlcd_BreakoutRoundLCD_type;
+        
+        spi_inst_t *spi = (spi_id == 0) ? spi0 : spi1;
+        self->breakout = new BreakoutRoundLCD((uint16_t *)bufinfo.buf, spi, args[ARG_cs].u_int, args[ARG_dc].u_int, sck, mosi);
+    }
+
+    self->breakout->init();
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+/***** Methods *****/
+mp_obj_t BreakoutRoundLCD_update(mp_obj_t self_in) {
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+    self->breakout->update();
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_set_backlight(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_brightness };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_brightness, MP_ARG_REQUIRED | MP_ARG_OBJ },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    float brightness = mp_obj_get_float(args[ARG_brightness].u_obj);
+
+    if(brightness < 0 || brightness > 1.0f)
+        mp_raise_ValueError("brightness out of range. Expected 0.0 to 1.0");
+    else
+        self->breakout->set_backlight((uint8_t)(brightness * 255.0f));
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_set_pen(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+
+    if(n_args <= 2) {
+        enum { ARG_self, ARG_pen };
+        static const mp_arg_t allowed_args[] = {
+            { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+            { MP_QSTR_pen, MP_ARG_REQUIRED | MP_ARG_INT },
+        };
+
+        mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+        mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+        breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+        int pen = args[ARG_pen].u_int;
+
+        if(pen < 0 || pen > 0xffff)
+            mp_raise_ValueError("p is not a valid pen.");
+        else
+            self->breakout->set_pen(pen);
+    }
+    else {
+        enum { ARG_self, ARG_r, ARG_g, ARG_b };
+        static const mp_arg_t allowed_args[] = {
+            { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+            { MP_QSTR_r, MP_ARG_REQUIRED | MP_ARG_INT },
+            { MP_QSTR_g, MP_ARG_REQUIRED | MP_ARG_INT },
+            { MP_QSTR_b, MP_ARG_REQUIRED | MP_ARG_INT },
+        };
+
+        mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+        mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+        breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+        int r = args[ARG_r].u_int;
+        int g = args[ARG_g].u_int;
+        int b = args[ARG_b].u_int;
+
+        if(r < 0 || r > 255)
+            mp_raise_ValueError("r out of range. Expected 0 to 255");
+        else if(g < 0 || g > 255)
+            mp_raise_ValueError("g out of range. Expected 0 to 255");
+        else if(b < 0 || b > 255)
+            mp_raise_ValueError("b out of range. Expected 0 to 255");
+        else
+            self->breakout->set_pen(r, g, b);
+    }
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_create_pen(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    int pen = 0;
+
+    enum { ARG_self, ARG_r, ARG_g, ARG_b };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_r, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_g, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_b, MP_ARG_REQUIRED | MP_ARG_INT },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    int r = args[ARG_r].u_int;
+    int g = args[ARG_g].u_int;
+    int b = args[ARG_b].u_int;
+
+    if(r < 0 || r > 255)
+        mp_raise_ValueError("r out of range. Expected 0 to 255");
+    else if(g < 0 || g > 255)
+        mp_raise_ValueError("g out of range. Expected 0 to 255");
+    else if(b < 0 || b > 255)
+        mp_raise_ValueError("b out of range. Expected 0 to 255");
+    else
+        pen = self->breakout->create_pen(r, g, b);
+
+    return mp_obj_new_int(pen);
+}
+
+mp_obj_t BreakoutRoundLCD_set_clip(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_x, ARG_y, ARG_w, ARG_h };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_x1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_w, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_h, MP_ARG_REQUIRED | MP_ARG_INT },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    int x = args[ARG_x].u_int;
+    int y = args[ARG_y].u_int;
+    int w = args[ARG_w].u_int;
+    int h = args[ARG_h].u_int;
+
+    Rect r(x, y, w, h);
+    self->breakout->set_clip(r);
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_remove_clip(mp_obj_t self_in) {
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+    self->breakout->remove_clip();
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_clear(mp_obj_t self_in) {
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+    self->breakout->clear();
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_pixel(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_x, ARG_y };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_x1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y1, MP_ARG_REQUIRED | MP_ARG_INT },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    int x = args[ARG_x].u_int;
+    int y = args[ARG_y].u_int;
+
+    Point p(x, y);
+    self->breakout->pixel(p);
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_pixel_span(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_x, ARG_y, ARG_l };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_x1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_l, MP_ARG_REQUIRED | MP_ARG_INT },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    int x = args[ARG_x].u_int;
+    int y = args[ARG_y].u_int;
+    int l = args[ARG_l].u_int;
+
+    Point p(x, y);
+    self->breakout->pixel_span(p, l);
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_rectangle(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_x, ARG_y, ARG_w, ARG_h };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_x1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_w, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_h, MP_ARG_REQUIRED | MP_ARG_INT },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    int x = args[ARG_x].u_int;
+    int y = args[ARG_y].u_int;
+    int w = args[ARG_w].u_int;
+    int h = args[ARG_h].u_int;
+
+    Rect r(x, y, w, h);
+    self->breakout->rectangle(r);
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_circle(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_x, ARG_y, ARG_r };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_x1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_r, MP_ARG_REQUIRED | MP_ARG_INT },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    int x = args[ARG_x].u_int;
+    int y = args[ARG_y].u_int;
+    int r = args[ARG_r].u_int;
+
+    Point p(x, y);
+    self->breakout->circle(p, r);
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_character(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_char, ARG_x, ARG_y, ARG_scale };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_char, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_x1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_scale, MP_ARG_INT, {.u_int = 2} },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    int c = mp_obj_get_int(args[ARG_char].u_obj);
+    int x = args[ARG_y].u_int;
+    int y = args[ARG_y].u_int;
+
+    Point p(x, y);
+    if(n_args == 4) {
+        int scale = args[ARG_scale].u_int;
+        self->breakout->character((char)c, p, scale);
+    }
+    else
+        self->breakout->character((char)c, p);
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_text(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_text, ARG_x, ARG_y, ARG_wrap, ARG_scale };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_text, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_x1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_wr, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_scale, MP_ARG_INT, {.u_int = 2} },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    mp_check_self(mp_obj_is_str_or_bytes(args[ARG_text].u_obj));
+    GET_STR_DATA_LEN(args[ARG_text].u_obj, str, str_len);
+
+    std::string t((const char*)str);
+
+    int x = args[ARG_x].u_int;
+    int y = args[ARG_y].u_int;
+    int wrap = args[ARG_wrap].u_int;
+
+    Point p(x, y);
+    if(n_args == 5) {
+        int scale = args[ARG_scale].u_int;
+        self->breakout->text(t, p, wrap, scale);
+    }
+    else
+        self->breakout->text(t, p, wrap);
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_polygon(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+
+    mp_raise_NotImplementedError("polygon is not implemented. Please avoid using this function for now");
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_triangle(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_x1, ARG_y1, ARG_x2, ARG_y2, ARG_x3, ARG_y3 };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_x1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_x2, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y2, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_x3, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y3, MP_ARG_REQUIRED | MP_ARG_INT },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    int x1 = args[ARG_x1].u_int;
+    int y1 = args[ARG_y1].u_int;
+    int x2 = args[ARG_x1].u_int;
+    int y2 = args[ARG_y1].u_int;
+    int x3 = args[ARG_x1].u_int;
+    int y3 = args[ARG_y1].u_int;
+
+    Point p1(x1, y1);
+    Point p2(x2, y2);
+    Point p3(x3, y3);
+    self->breakout->triangle(p1, p2, p3);
+
+    return mp_const_none;
+}
+
+mp_obj_t BreakoutRoundLCD_line(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_x1, ARG_y1, ARG_x2, ARG_y2 };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_x1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y1, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_x2, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_y2, MP_ARG_REQUIRED | MP_ARG_INT },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    
+    breakout_roundlcd_BreakoutRoundLCD_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_roundlcd_BreakoutRoundLCD_obj_t);
+
+    int x1 = args[ARG_x1].u_int;
+    int y1 = args[ARG_y1].u_int;
+    int x2 = args[ARG_x1].u_int;
+    int y2 = args[ARG_y1].u_int;
+
+    Point p1(x1, y1);
+    Point p2(x2, y2);
+    self->breakout->line(p1, p2);
+
+    return mp_const_none;
+}
+}
\ No newline at end of file
diff --git a/micropython/modules/breakout_roundlcd/breakout_roundlcd.h b/micropython/modules/breakout_roundlcd/breakout_roundlcd.h
new file mode 100644
index 00000000..7089c574
--- /dev/null
+++ b/micropython/modules/breakout_roundlcd/breakout_roundlcd.h
@@ -0,0 +1,32 @@
+// Include MicroPython API.
+#include "py/runtime.h"
+#include "py/objstr.h"
+
+/***** Constants *****/
+static const int WIDTH = 240;
+static const int HEIGHT = 240;
+
+
+/***** Extern of Class Definition *****/
+extern const mp_obj_type_t breakout_roundlcd_BreakoutRoundLCD_type;
+
+/***** Extern of Class Methods *****/
+extern void BreakoutRoundLCD_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind);
+extern mp_obj_t BreakoutRoundLCD_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args);
+extern mp_obj_t  BreakoutRoundLCD_update(mp_obj_t self_in);
+extern mp_obj_t  BreakoutRoundLCD_set_backlight(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+
+extern mp_obj_t  BreakoutRoundLCD_set_pen(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_create_pen(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_set_clip(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_remove_clip(mp_obj_t self_in);
+extern mp_obj_t  BreakoutRoundLCD_clear(mp_obj_t self_in);
+extern mp_obj_t  BreakoutRoundLCD_pixel(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_pixel_span(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_rectangle(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_circle(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_character(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_text(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_polygon(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_triangle(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t  BreakoutRoundLCD_line(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
\ No newline at end of file
diff --git a/micropython/modules/breakout_roundlcd/micropython.cmake b/micropython/modules/breakout_roundlcd/micropython.cmake
new file mode 100644
index 00000000..aeb65d94
--- /dev/null
+++ b/micropython/modules/breakout_roundlcd/micropython.cmake
@@ -0,0 +1,20 @@
+set(MOD_NAME breakout_roundlcd)
+string(TOUPPER ${MOD_NAME} MOD_NAME_UPPER)
+add_library(usermod_${MOD_NAME} INTERFACE)
+
+target_sources(usermod_${MOD_NAME} INTERFACE
+    ${CMAKE_CURRENT_LIST_DIR}/${MOD_NAME}.c
+    ${CMAKE_CURRENT_LIST_DIR}/${MOD_NAME}.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/../../../libraries/${MOD_NAME}/${MOD_NAME}.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/../../../drivers/st7789/st7789.cpp
+)
+
+target_include_directories(usermod_${MOD_NAME} INTERFACE
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+target_compile_definitions(usermod_${MOD_NAME} INTERFACE
+    -DMODULE_${MOD_NAME_UPPER}_ENABLED=1
+)
+
+target_link_libraries(usermod INTERFACE usermod_${MOD_NAME})
\ No newline at end of file
diff --git a/micropython/modules/breakout_roundlcd/micropython.mk b/micropython/modules/breakout_roundlcd/micropython.mk
new file mode 100755
index 00000000..5123b805
--- /dev/null
+++ b/micropython/modules/breakout_roundlcd/micropython.mk
@@ -0,0 +1,13 @@
+set(MOD_NAME breakout_roundlcd)
+PICOSCROLL_MOD_DIR := $(USERMOD_DIR)
+
+# Add our source files to the respective variables.
+SRC_USERMOD += $(PICOSCROLL_MOD_DIR)/${MOD_NAME}.c
+SRC_USERMOD_CXX += $(PICOSCROLL_MOD_DIR)/${MOD_NAME}.cpp
+
+# Add our module directory to the include path.
+CFLAGS_USERMOD += -I$(PICOSCROLL_MOD_DIR)
+CXXFLAGS_USERMOD += -I$(PICOSCROLL_MOD_DIR)
+
+# We use C++ features so have to link against the standard library.
+LDFLAGS_USERMOD += -lstdc++
\ No newline at end of file
diff --git a/micropython/modules/micropython.cmake b/micropython/modules/micropython.cmake
index 781baf42..642f7001 100644
--- a/micropython/modules/micropython.cmake
+++ b/micropython/modules/micropython.cmake
@@ -1,3 +1,4 @@
+include(${CMAKE_CURRENT_LIST_DIR}/breakout_roundlcd/micropython.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/pico_scroll/micropython.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/pico_rgb_keypad/micropython.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/pico_unicorn/micropython.cmake)