diff --git a/buffer.cpp b/buffer.cpp
new file mode 100644
index 0000000..a6babec
--- /dev/null
+++ b/buffer.cpp
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "datatypes.cpp"
+#include "helpers.cpp"
+
+namespace UwU {
+      // Buffer object - can be a wayland surface or a virtual buffer
+  class Buffer {
+    public:
+        Buffer(uint16_t width, uint16_t height) {
+        uint8_t pixels[width * height * 4];
+        this->pixels = pixels;
+        this->width = width;
+        this->height = height;
+        this->stride = width * 4;
+        }
+        // Buffer(uint8_t* pixels, uint16_t width, uint16_t height, uint16_t stride) {
+        //   this->pixels = pixels;
+        //   this->width = width;
+        //   this->height = height;
+        //   this->stride = stride;
+        // }
+        Buffer() {}
+        uint8_t* pixels;
+        uint16_t width;
+        uint16_t height;
+        uint16_t stride;
+
+        void drawPixel(Coord2 coord, Color color) {
+            size_t i = (size_t)coord.y * stride + (size_t)coord.x * 4;
+            uint8_t b0 = pixels[i + 0];
+            uint8_t g0 = pixels[i + 1];
+            uint8_t r0 = pixels[i + 2];
+            uint8_t b = Helpers::lerp8(b0, color.b, color.a);
+            uint8_t g = Helpers::lerp8(g0, color.g, color.a);
+            uint8_t r = Helpers::lerp8(r0, color.r, color.a);
+            pixels[i + 0] = b;    // B
+            pixels[i + 1] = g;    // G
+            pixels[i + 2] = r;    // R
+            pixels[i + 3] = 0xff; // A
+            return;
+        }
+  };
+}
\ No newline at end of file
diff --git a/draw b/draw
new file mode 100755
index 0000000..cf98c58
Binary files /dev/null and b/draw differ
diff --git a/draw.cpp b/draw.cpp
new file mode 100644
index 0000000..96568e8
--- /dev/null
+++ b/draw.cpp
@@ -0,0 +1,313 @@
+/* Example program that links against the waymini library.
+ * No external dependencies beyond waymini itself and the C standard library.
+ */
+
+#include "waymini.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "datatypes.cpp"
+#include "helpers.cpp"
+#include "triangle.cpp"
+#include "buffer.cpp"
+#include "surface.cpp"
+
+// this should be handled elsewhere, eventually, maybe, probably
+static void onKey(void *user, uint32_t keycode, uint32_t state) {
+  if (keycode == 1) {
+  	exit(1);
+  }
+  (void)user;
+  const char *label = state ? "down" : "up  ";
+  printf("key %s: %u\n", label, keycode);
+  fflush(stdout);
+}
+
+namespace UwU {
+
+  class Draw {
+    private:
+      class Surface surface;
+      // void putPixel(uint32_t x, uint32_t y, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 0xff) {
+      //     size_t i = (size_t)y * surface.getStride() + (size_t)x * 4;
+      //     uint8_t b0 = pixels[i + 0];
+      //     uint8_t g0 = pixels[i + 1];
+      //     uint8_t r0 = pixels[i + 2];
+      //     b = Helpers::lerp8(b0, b, a);
+      //     g = Helpers::lerp8(g0, g, a);
+      //     r = Helpers::lerp8(r0, r, a);
+      //     pixels[i + 0] = b;    // B
+      //     pixels[i + 1] = g;    // G
+      //     pixels[i + 2] = r;    // R
+      //     pixels[i + 3] = 0xff; // A
+      // }
+
+      // plot lines if m <= 1
+      void lineLow(int32_t x0, int32_t y0, int32_t x1, int32_t y1, Color color) {
+        int32_t dx = x1 - x0;
+        int32_t dy = y1 - y0;
+        int32_t yi = 1;
+        if (dy < 0) {
+          yi = -1;
+          dy = -dy;
+        }
+        int32_t d = (2 * dy) - dx;
+        int32_t y = y0;
+        for (int32_t x = x0; x < x1; x++) {
+          // putPixel(x, y, color.r, color.g, color.b, color.a);
+          surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), color);
+          if (d > 0) {
+            y += yi;
+            d += (2 * (dy - dx));
+          } else {
+            d += (2 * dy);
+          }
+        }
+        return;
+      }
+
+      // plot lines if m >1
+      void lineHigh(int32_t x0, int32_t y0, int32_t x1, int32_t y1, Color color) {
+        int32_t dx = x1 - x0;
+        int32_t dy = y1 - y0;
+        int32_t xi = 1;
+        if (dx < 0) {
+          xi = -1;
+          dx = -dx;
+        }
+        int32_t d = (2 * dx) - dy;
+        int32_t x = x0;
+        for (int32_t y = y0; y < y1; y++) {
+          // putPixel(x, y, color.r, color.g, color.b, color.a);
+          surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), color);
+          if (d > 0) {
+            x += xi;
+            d += (2 * (dx - dy));
+          } else {
+            d += (2 * dx);
+          }
+        }
+        return;
+      }
+    
+    public:
+
+      
+      Draw(uint16_t width, uint16_t height, waymini_key_cb onKey)
+        : surface(width, height, onKey) {}
+
+      bool shouldClose() {
+        return surface.shouldClose();
+      }
+
+      void updateSize() {
+        surface.updateSize();
+        return;
+      }
+
+      uint16_t getWidth() {
+        return surface.getWidth();
+      }
+
+      uint16_t getHeight() {
+        return surface.getHeight();
+      }
+
+      uint16_t getStride() {
+        return surface.getStride();
+      }
+
+      void present() {
+        surface.present();
+        return;
+      }
+
+      void destroy() {
+        surface.destroy();
+        return;
+      }
+      
+      // Draw a rectangle (duh)
+      void rectangle(Coord2 point0, Coord2 point1, Color color) {
+        if (point0.x > getWidth() || point0.y > getHeight() || point1.x > getWidth() || point1.y > getHeight()) {return;};
+        for (uint32_t y = point0.y; y < point1.y; y++) {
+          for (uint32_t x = point0.x; x < point1.x; x++) {
+            // putPixel(x, y, color.r, color.g, color.b, color.a);
+            surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), color);
+          }
+        }
+        return;
+      }
+
+      // Draws a rectangle with a 4-point color gradient
+      void rectangleGradient(Coord2 point0, Coord2 point1, Color colorUL, Color colorUR, Color colorLL, Color colorLR) {
+        // convert to int32_t and ensure x1>x0 && y1>y0
+        int32_t x0, y0, x1, y1;
+        if (point0.x > point1.x) {
+          x0 = (int32_t)point1.x;
+          x1 = (int32_t)point0.x;
+        } else {
+          x0 = (int32_t)point0.x;
+          x1 = (int32_t)point1.x;
+        }
+        if (point0.y > point1.y) {
+          y0 = (int32_t)point1.y;
+          y1 = (int32_t)point0.y;
+        } else {
+          y0 = (int32_t)point0.y;
+          y1 = (int32_t)point1.y;
+        }
+
+        // setup gradient coefficient arrays
+        int32_t w = x1 - x0 + 1;
+        int32_t h = y1 - y0 + 1;
+        int16_t xGrad[w];
+        int16_t yGrad[h];
+
+        // calculate gradient coefficients
+        Helpers::bresenham(0, 0, w - 1, 255, xGrad);
+        Helpers::bresenham(0, 0, h - 1, 255, yGrad);
+
+        // for each point calculate, alpha blend and print color
+        Color Lmix = Color();
+        Color Rmix = Color();
+        Color Xmix = Color();
+        for (int32_t y = y0; y <= y1; y++) {
+          Lmix = Helpers::lerpColor(colorUL, colorLL, (uint8_t)yGrad[y - y0]);
+          Rmix = Helpers::lerpColor(colorUR, colorLR, (uint8_t)yGrad[y - y0]);
+          for (int32_t x = x0; x <= x1; x++) {
+            Xmix = Helpers::lerpColor(Lmix, Rmix, (uint8_t)xGrad[x - x0]);
+            // putPixel(x, y, Xmix.r, Xmix.g, Xmix.b, Xmix.a);
+            surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), Xmix);
+          }
+        }
+        return;
+      }
+      
+      // Fill a simple gradient. Each row is stride bytes.
+      void rainbow() {
+        for (uint32_t y = 0; y < getHeight(); y++) {
+          for (uint32_t x = 0; x < getWidth(); x++) {
+            surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), Color(
+              (uint8_t)(y * 255 / getHeight()),
+              0x00,
+              (uint8_t)(x * 255 / getWidth()),
+              0xff));
+            // size_t i = (size_t)y * getStride() + (size_t)x * 4;
+            // pixels[i + 0] = (uint8_t)(y * 255 / getHeight());  // B
+            // pixels[i + 1] = 0x00;                               // G
+            // pixels[i + 2] = (uint8_t)(x * 255 / getWidth());   // R
+            // pixels[i + 3] = 0xFF;                               // A
+          }
+        }
+      }
+
+      // Draw a single point
+      void point (Coord2 point, Color color) {
+        if (point.x > getWidth() || point.y > getHeight()) {return;};
+        // putPixel(point.x, point.y, color.r, color.g, color.b, color.a);
+        surface.buffer.drawPixel(point, color);
+      }
+
+      // Uses Bresenham's line algorithm to draw line of any slope
+      void line (Coord2 point0, Coord2 point1, Color color) {
+        if (point0.x > getWidth() || point0.y > getHeight() || point1.x > getWidth() || point1.y > getHeight()) {return;};
+        int32_t x0 = (int32_t)point0.x;
+        int32_t y0 = (int32_t)point0.y;
+        int32_t x1 = (int32_t)point1.x;
+        int32_t y1 = (int32_t)point1.y;
+        if (abs(y1 - y0) < abs(x1 - x0)) {
+          if (x0 > x1) {
+            lineLow(x1, y1, x0, y0, color);
+          } else {
+            lineLow(x0, y0, x1, y1, color);
+          }
+        } else {
+          if (y0 > y1) {
+            lineHigh(x1, y1, x0, y0, color);
+          } else {
+            lineHigh(x0, y0, x1, y1, color);
+          }
+        }
+      }
+
+      // Draw a horizontally bounded trapezoid
+      // coords.y1 >= coords.y0
+      // todo move to private and add public checks
+      void trapezoid (Trapezoid coords, Color color) {
+        printf("(%u, %u, %u, %u, %u, %u)", coords.y0, coords.y1, coords.xl0, coords.xl1, coords.xr0, coords.xr1);
+        uint16_t height = 1 + coords.y1 - coords.y0;
+        int16_t LeftBound[height];
+        int16_t RightBound[height];
+  
+        Helpers::bresenham(0, coords.xl0, coords.y1 - coords.y0, coords.xl1, LeftBound);
+        Helpers::bresenham(0, coords.xr0, coords.y1 - coords.y0, coords.xr1, RightBound);
+  
+        printf("leftbound\n");
+        for (uint16_t i = 0; i < height; i++) {
+          printf("(%u, %u)\n", i, LeftBound[i]);
+        }
+        printf("rightbound\n");
+        for (uint16_t i = 0; i < height; i++) {
+          printf("(%u, %u)\n", i, RightBound[i]);
+        }
+
+        for (uint16_t i = 0; i < height; i++) {
+          for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
+            // printf("(%u, %u)", x, i + coords.y0);
+            surface.buffer.drawPixel(Coord2(x, i + coords.y0), color);
+          }
+        }
+        return;
+      }
+
+      // Draw a triangle
+      void triangle (uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, Color color) {
+        Triangle triangle = Triangle(x0, y0, x1, y1, x2, y2);
+        triangle.draw(surface.buffer, color);
+        return;
+      }
+    };
+  }
+
+int main(void) {
+  uint32_t w = 800, h = 480;
+  UwU::Color fuchsia = UwU::Color(0xb00b6940);
+  UwU::Color red = UwU::Color(0xff0000ff);
+  UwU::Color green = UwU::Color(0x00ff00ff);
+  UwU::Color blue = UwU::Color(0x0000ffff);
+  UwU::Color alpha = UwU::Color(0x00000000);
+  printf("r: %u, g:%u, b:%u, a:%u\n", fuchsia.r, fuchsia.g, fuchsia.b, fuchsia.a);
+
+  // struct waymini *wm = waymini_create(w, h, on_key, NULL);
+  UwU::Draw draw = UwU::Draw(w, h, onKey);
+
+  draw.rainbow();
+
+  
+  draw.rectangle(UwU::Coord2(69, 69), UwU::Coord2(420, 420), fuchsia);
+  draw.rectangleGradient(UwU::Coord2(200, 200), UwU::Coord2(600, 400), red, blue, alpha, red);
+
+  draw.trapezoid(UwU::Trapezoid(300, 400, 360, 380, 600, 400), green);
+  draw.triangle(280, 100, 240, 290, 320, 300, green);
+
+
+  draw.point(UwU::Coord2(387, 43), green);
+  draw.line(UwU::Coord2(300, 100), UwU::Coord2(250, 469), green);
+  draw.line(UwU::Coord2(250, 100), UwU::Coord2(300, 469), green);
+  draw.line(UwU::Coord2(300, 100), UwU::Coord2(469, 250), green);
+  draw.line(UwU::Coord2(469, 100), UwU::Coord2(300, 250), green);
+  draw.line(UwU::Coord2(100, 300), UwU::Coord2(250, 469), green);
+  draw.line(UwU::Coord2(250, 300), UwU::Coord2(100, 469), green);
+  draw.line(UwU::Coord2(100, 300), UwU::Coord2(469, 250), green);
+  draw.line(UwU::Coord2(469, 300), UwU::Coord2(100, 250), green);
+  draw.present();
+
+  while (!draw.shouldClose()) {}
+
+  draw.destroy();
+  return 0;
+}
diff --git a/surface.cpp b/surface.cpp
new file mode 100644
index 0000000..d11d318
--- /dev/null
+++ b/surface.cpp
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "waymini.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "datatypes.cpp"
+#include "buffer.cpp"
+
+namespace UwU {
+    class Surface {
+        public:
+            Surface(uint16_t width, uint16_t height, waymini_key_cb onKey) {
+                this->wm = waymini_create((uint32_t)width, (uint32_t)height, onKey, NULL);
+                if (!this->wm) exit(1);
+                
+                // this->buffer = Buffer(
+                //     (uint8_t*)waymini_get_pixels(this->wm),
+                //     waymini_get_width(this->wm),
+                //     waymini_get_height(this->wm),
+                //     waymini_get_stride(this->wm));
+                this->buffer.pixels = (uint8_t*)waymini_get_pixels(this->wm);
+                this->buffer.width = waymini_get_width(this->wm);
+                this->buffer.height = waymini_get_height(this->wm);
+                this->buffer.stride = waymini_get_stride(this->wm);
+                printf("surface: %ux%u stride=%u\n", waymini_get_width(this->wm), waymini_get_height(this->wm), waymini_get_stride(this->wm));
+
+                if (!this->buffer.pixels) {
+                    waymini_destroy(this->wm);
+                    exit(1);
+                }
+            }
+            class Buffer buffer;
+            struct waymini* wm;
+
+            // get current size of wayland surface and update buffer
+            void updateSize() {
+                buffer.width = waymini_get_width(wm);
+                buffer.height = waymini_get_height(wm);
+                buffer.stride = waymini_get_stride(wm);
+                return;
+            }
+            
+            uint32_t getWidth() {
+                updateSize();
+                return buffer.width;
+            }
+            
+            uint32_t getHeight() {
+                updateSize();
+                return buffer.height;
+            }
+            
+            uint32_t getStride() {
+                updateSize();
+                return buffer.stride;
+            }
+            
+            void present() {
+                waymini_present(wm);
+                return;
+            }
+            
+            void destroy() {
+                waymini_destroy(wm);
+                return;
+            }
+
+            bool shouldClose() {
+                if (waymini_should_close(wm) || waymini_dispatch(wm) < 0) {
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+    };
+}
\ No newline at end of file