make janky titlebar

flake.nix

@@ -37,6 +37,7 @@
             pkg-config
             binutils
             curlMinimal
+            curl-config
             clang
             bear
             naga-cli
@@ -48,12 +49,14 @@
           ] else if pkgs.system == "x86_64-linux" then [
             pkg-config
             binutils
+            curlMinimal
             clang
             bear
             naga-cli
             libGL
             mesa
             gf
+            wayland
             xorg.libX11
             xorg.libXi
             xorg.xinput

justfile

@@ -1,16 +1,32 @@
 alias b := build
 alias r := run
 
+c_flags := if os() == "macos" {
+    "$(curl-config --libs) -framework Cocoa -framework QuartzCore -framework CoreImage -framework Metal -framework MetalKit -ObjC"
+} else if os_family() == "unix" {
+    "$(curl-config --libs) -lEGL -lGLESv2 -lGL -lm -lwayland-client -lwayland-egl -lX11 -lXi -lXcursor -Wno-implicit-function-declaration"
+} else { "" }
+
+[macos]
 build: transpile_shaders_metal
     mkdir -p bin
-    cc -Ivendor/ -O0 -g -Wall -Wextra $(curl-config --libs) -framework Cocoa -framework QuartzCore -framework CoreImage -framework Metal -framework MetalKit -ObjC src/*.c -o bin/chat_client
-    # cc -Ivendor/ -g -Wall -Wextra src/*.c -o bin/chat_client -lEGL -lGLESv2 -lGL -lm -lX11 -lXi -lXcursor
-    # cc bin/*.o -o bin/chat_client -lEGL -lGLESv2 -lGL -lm -lX11 -lXi -lXcursor
+    cc -Ivendor/ -O0 -g -Wall -Wextra {{ c_flags }} src/*.c -o bin/chat_client
+
+[linux]
+build: generate_wayland_protocols
+    mkdir -p bin
+    cc -Ivendor/ -O0 -g -Wall -Wextra {{ c_flags }} src/*.c src/wayland-crap/*.c -o bin/chat_client
 
 run: build
-    # nixGLIntel ./bin/chat_client
-    ./bin/chat_client
+    nixGLIntel ./bin/chat_client
+    # ./bin/chat_client
 
+[linux]
+generate_wayland_protocols:
+    wayland-scanner client-header src/wayland-crap/xdg-shell.xml src/wayland-crap/xdg-shell.h
+    wayland-scanner code src/wayland-crap/xdg-shell.xml src/wayland-crap/xdg-shell.c
+
+[macos]
 transpile_shaders_metal:
     mkdir -p bin/transpiled_shaders
 

shaders/text_atlas_fragment.glsl

@@ -0,0 +1,18 @@
+#version 440 core
+
+struct VertexOutput {
+    vec4 position;
+    vec2 tex_coord;
+};
+
+
+layout(location = 0) in VertexOutput out_vertex;
+layout(location = 1) uniform highp sampler2D atlas_texture;
+
+out vec4 color;
+
+void main() {
+    float text_color = texture(atlas_texture, out_vertex.tex_coord).r;
+
+    color = vec4(text_color * vec3(1,1,1), text_color);
+}

shaders/text_atlas_vertex.glsl

@@ -0,0 +1,55 @@
+#version 440 core
+
+struct Vertex {
+    vec2 position;
+    vec2 tex_coord;
+};
+
+struct VertexOutput {
+    vec4 position;
+    vec2 tex_coord;
+};
+
+struct Glyph {
+    vec2 atlas_position;
+    vec2 size;
+    vec2 target_position;
+    float y_offset;
+    float _haha_alignment;
+};
+
+layout(std430, binding = 0) readonly buffer VertexBlock {
+    Vertex vertices[];
+};
+
+layout(std430, binding = 1) readonly buffer GlyphBlock {
+    Glyph glyphs[];
+};
+
+layout(std430, binding = 2) readonly buffer ParamsBlock {
+    vec2 screen_size;
+};
+
+vec4 to_device_position(vec2 position, vec2 size) {
+    return vec4(((position / size) * 2.0) - vec2(1.0), 1.0, 1.0);
+}
+
+layout(location = 0) out VertexOutput out_vertex;
+
+void main() {
+    Glyph glyph = glyphs[gl_InstanceID];
+
+    vec2 scaled_size = ((vertices[gl_VertexID].position + 1.0) / 2.0) * (glyph.size/2.0);
+    vec2 scaled_size_2 = ((vertices[gl_VertexID].position + 1.0) / 2.0) * (glyph.size);
+    vec2 glyph_pos = scaled_size + glyph.target_position + vec2(0, glyph.y_offset/2.0+24);
+
+    vec4 device_position = to_device_position(glyph_pos, screen_size);
+    vec2 atlas_position = (scaled_size_2 + glyph.atlas_position) / 512.0;
+
+    device_position.y = -device_position.y;
+
+    out_vertex.position = device_position;
+    out_vertex.tex_coord = atlas_position;
+
+    gl_Position = device_position;
+}

shaders/ui_rect_fragment.glsl

@@ -0,0 +1,45 @@
+#version 440 core
+
+struct UiRectFragment {
+    highp vec4 device_position;
+    highp vec2 position;
+    highp vec2 size;
+    highp vec2 border_size;
+    highp vec2 screen_size;
+    highp vec2 tex_coord;
+    highp vec4 color;
+};
+
+in UiRectFragment out_rect;
+
+layout(location = 0) out highp vec4 color;
+
+highp float rect_sdf(
+    highp vec2 absolute_pixel_position,
+    highp vec2 origin,
+    highp vec2 size,
+    highp float corner_radius
+) {
+    highp vec2 half_size = size / 2.0;
+    highp vec2 rect_center = origin + half_size;
+
+    highp vec2 pixel_position = abs(absolute_pixel_position - rect_center);
+    highp vec2 shrunk_corner_position = half_size - corner_radius;
+
+    highp vec2 pixel_to_shrunk_corner = max(vec2(0), pixel_position - shrunk_corner_position);
+    highp float distance_to_shrunk_corner = length(pixel_to_shrunk_corner);
+    highp float distance = distance_to_shrunk_corner - corner_radius;
+
+    return distance;
+}
+
+void main() {
+    highp vec2 pixel_pos = out_rect.tex_coord.xy * out_rect.screen_size;
+
+    highp float distance = rect_sdf(pixel_pos, out_rect.position, out_rect.size, out_rect.border_size.x);
+    if (distance <= 0.0) {
+        color = out_rect.color;
+    } else {
+        color = vec4(0);
+    }
+}

shaders/ui_rect_vertex.glsl

@@ -0,0 +1,50 @@
+#version 440 core
+
+struct Vertex {
+    vec2 position;
+    vec2 tex_coord;
+};
+
+struct UiRect {
+    vec4 position;
+    vec4 size;
+    vec4 border_size;
+    vec4 color;
+};
+
+struct UiRectFragment {
+    highp vec4 device_position;
+    highp vec2 position;
+    highp vec2 size;
+    highp vec2 border_size;
+    highp vec2 screen_size;
+    highp vec2 tex_coord;
+    highp vec4 color;
+};
+
+layout(std430, binding = 0) readonly buffer VertexBlock {
+    Vertex vertices[];
+};
+
+layout(std430, binding = 1) readonly buffer RectBlock {
+    UiRect rects[];
+};
+layout(std430, binding = 2) readonly buffer ParamsBlock {
+    vec2 screen_size;
+};
+
+out UiRectFragment out_rect;
+
+void main() {
+    UiRect rect = rects[gl_InstanceID];
+
+    out_rect.device_position = vec4(vertices[gl_VertexID].position, 1, 1);
+    out_rect.position = rect.position.xy;
+    out_rect.size = rect.size.xy;
+    out_rect.border_size = rect.border_size.xy;
+    out_rect.screen_size = screen_size;
+    out_rect.tex_coord = vertices[gl_VertexID].tex_coord;
+    out_rect.color = rect.color;
+
+    gl_Position = vec4(vertices[gl_VertexID].position, 1, 1);
+}

src/ed_array.h

@@ -1,80 +1,85 @@
 #ifndef ED_ARRAY_INCLUDED
 #define ED_ARRAY_INCLUDED
-#include <stdio.h>
-#include <stdlib.h>
 #include <assert.h>
 #include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-#define array(T) struct T ## _Array
-#define arrayTemplate(T) array(T) {\
-    size_t size, capacity;\
-    T *data;\
-};\
-array(T) T ## _ArrayConstruct(size_t size) {\
-    array(T) this;\
-    this.size = 0;\
-    this.capacity = size;\
-    this.data = malloc(size * sizeof(T));\
-    if (!this.data) {\
-        assert("failed to allocate memory for array");\
-    }\
-    return this;\
-};\
-void T ## _PushArray(array(T) *arr, T value) {\
-    if (arr->size+1 <= arr->capacity) {\
-        arr->data[arr->size] = value;\
-        arr->size += 1;\
-    } else {\
-        fprintf(stderr, "failed to push to u8 array, size+num > capacity\n");\
-    }\
-};\
-void T ## _PushArrayMulti(array(T) *arr, T *values, size_t len) {\
-    for (size_t i = 0; i < len; ++i) {\
-        T ## _PushArray(arr, values[i]);\
-    }\
-};\
-void T ## _InsertArrayAt(array(T) *arr, size_t loc, T value) {\
-    if (arr->size == arr->capacity) {\
-        arr->capacity *= 2;\
-        void *new_data = realloc(arr->data, arr->capacity);\
-        if (new_data == NULL) {\
-            fprintf(stderr, "out of memory when reallocating array\n");\
-        }\
-        arr->data = new_data;\
-    }\
-    memcpy(&arr->data[loc+1], &arr->data[loc], arr->size * sizeof(T));\
-    arr->data[loc] = value;\
-    arr->size += 1;\
-};
+#define array(T) struct T##_Array
+#define arrayTemplate(T)                                                       \
+    array(T) {                                                                 \
+        size_t size, capacity;                                                 \
+        T *data;                                                               \
+    };                                                                         \
+    array(T) T##_ArrayConstruct(size_t size) {                                 \
+        array(T) this;                                                         \
+        this.size = 0;                                                         \
+        this.capacity = size;                                                  \
+        this.data = malloc(size * sizeof(T));                                  \
+        if (!this.data) {                                                      \
+            assert("failed to allocate memory for array");                     \
+        }                                                                      \
+        return this;                                                           \
+    };                                                                         \
+    void T##_PushArray(array(T) * arr, T value) {                              \
+        if (arr->size + 1 <= arr->capacity) {                                  \
+            arr->data[arr->size] = value;                                      \
+            arr->size += 1;                                                    \
+        } else {                                                               \
+            fprintf(stderr,                                                    \
+                    "failed to push to u8 array, size+num > capacity\n");      \
+        }                                                                      \
+    };                                                                         \
+    void T##_PushArrayMulti(array(T) * arr, T * values, size_t len) {          \
+        for (size_t i = 0; i < len; ++i) {                                     \
+            T##_PushArray(arr, values[i]);                                     \
+        }                                                                      \
+    };                                                                         \
+    void T##_InsertArrayAt(array(T) * arr, size_t loc, T value) {              \
+        if (arr->size == arr->capacity) {                                      \
+            arr->capacity *= 2;                                                \
+            void *new_data = realloc(arr->data, arr->capacity);                \
+            if (new_data == NULL) {                                            \
+                fprintf(stderr, "out of memory when reallocating array\n");    \
+            }                                                                  \
+            arr->data = new_data;                                              \
+        }                                                                      \
+        memcpy(&arr->data[loc + 1], &arr->data[loc], arr->size * sizeof(T));   \
+        arr->data[loc] = value;                                                \
+        arr->size += 1;                                                        \
+    };
 
-#define slice(T) struct T ## _Slice
-#define sliceTemplate(T) slice(T) {\
-    size_t len;\
-    T *data;\
-};\
-array(T) T ## _FromSlice(slice(T) s) {\
-    array(T) arr = T ## _ArrayConstruct(s.len);\
-    memcpy(arr.data, s.data, sizeof(T) * s.len);\
-    arr.size = s.len;\
-    return arr;\
-}\
-slice(T) T ## _SliceConstruct(void *data, size_t len) {\
-    slice(T) this;\
-    this.len = len;\
-    this.data = data;\
-    return this;\
-}
+#define slice(T) struct T##_Slice
+#define sliceTemplate(T)                                                       \
+    slice(T) {                                                                 \
+        size_t len;                                                            \
+        T *data;                                                               \
+    };                                                                         \
+    array(T) T##_FromSlice(slice(T) s) {                                       \
+        array(T) arr = T##_ArrayConstruct(s.len);                              \
+        memcpy(arr.data, s.data, sizeof(T) * s.len);                           \
+        arr.size = s.len;                                                      \
+        return arr;                                                            \
+    }                                                                          \
+    slice(T) T##_SliceConstruct(void *data, size_t len) {                      \
+        slice(T) this;                                                         \
+        this.len = len;                                                        \
+        this.data = data;                                                      \
+        return this;                                                           \
+    }
 
-#define newArray(T, size) T ## _ArrayConstruct(size)
-#define newArrayFromSlice(T, s) T ## _FromSlice(s)
-#define pushArray(T, arr, value) T ## _PushArray(arr, (value))
-#define pushArrayMulti(T, arr, values, len) T ## _PushArrayMulti(arr, values, len)
+#define newArray(T, size) T##_ArrayConstruct(size)
+#define newArrayFromSlice(T, s) T##_FromSlice(s)
+#define pushArray(T, arr, value) T##_PushArray(arr, (value))
+#define pushArrayMulti(T, arr, values, len) T##_PushArrayMulti(arr, values, len)
 
-#define insertArrayAt(T, arr, loc, value) T ## _InsertArrayAt(arr, loc, (value))
+#define insertArrayAt(T, arr, loc, value) T##_InsertArrayAt(arr, loc, (value))
 
-#define newSlice(T, data, len) T ## _SliceConstruct(data, len)
+#define newSlice(T, data, len) T##_SliceConstruct(data, len)
 
 arrayTemplate(uint8_t);
 sliceTemplate(uint8_t);
+arrayTemplate(uint32_t);
+sliceTemplate(uint32_t);
 
 #endif

src/file_io.h

@@ -1,7 +1,7 @@
 #ifndef ED_FILE_IO_INCLUDED
 #define ED_FILE_IO_INCLUDED
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 #include "string.h"
 
@@ -11,12 +11,16 @@ bool load_file(string file_path, size_t size, void *buffer);
 #ifdef ED_FILE_IO_IMPLEMENTATION
 
 #if defined(__unix__)
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <assert.h>
 
-unsigned long get_file_size(const char *filePath) {
-    FILE *file = fopen(filePath, "r");
+unsigned long get_file_size(string file_path) {
+    char *file_path_with_sentinel = malloc(file_path.len + 1);
+    memcpy(file_path_with_sentinel, file_path.data, file_path.len + 1);
+    file_path_with_sentinel[file_path.len] = 0;
+
+    FILE *file = fopen(file_path_with_sentinel, "r");
     assert(file && "get_file_size: failed to open file");
 
     fseek(file, 0, SEEK_END);
@@ -25,21 +29,22 @@ unsigned long get_file_size(const char *filePath) {
 
     fclose(file);
 
+    free(file_path_with_sentinel);
     return fsize;
 }
 
-bool load_file(const char *filePath, unsigned long size, void *buffer) {
-    FILE *file = fopen(filePath, "r");
+bool load_file(string file_path, size_t size, void *buffer) {
+    char *file_path_with_sentinel = malloc(file_path.len + 1);
+    memcpy(file_path_with_sentinel, file_path.data, file_path.len + 1);
+    file_path_with_sentinel[file_path.len] = 0;
+
+    FILE *file = fopen(file_path_with_sentinel, "r");
     assert(file && "load_file: failed to open file");
 
-    fseek(file, 0, SEEK_END);
-    long fsize = ftell(file);
-    fseek(file, 0, SEEK_SET);
-
-    fread(buffer, fsize, 1, file);
-
+    fread(buffer, size, 1, file);
     fclose(file);
 
+    free(file_path_with_sentinel);
     return true;
 }
 
@@ -47,49 +52,41 @@ bool load_file(const char *filePath, unsigned long size, void *buffer) {
 #include <windows.h>
 #define assertm(exp, msg) assert(((void)msg, exp))
 
-VOID CALLBACK FileIOCompletionRoutine(
-        __in  DWORD dwErrorCode,
-        __in  DWORD dwNumberOfBytesTransfered,
-        __in  LPOVERLAPPED lpOverlapped )
-{
+VOID CALLBACK FileIOCompletionRoutine(__in DWORD dwErrorCode,
+                                      __in DWORD dwNumberOfBytesTransfered,
+                                      __in LPOVERLAPPED lpOverlapped) {
     printf("Error code: %li", dwErrorCode);
     printf("Number of bytes: %li", dwNumberOfBytesTransfered);
 }
 
 unsigned long get_file_size(const char *filePath) {
-    HANDLE hFile = CreateFile(filePath,
-            GENERIC_READ,
-            FILE_SHARE_READ,
-            NULL,
-            OPEN_EXISTING,
-            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
-            NULL);
+    HANDLE hFile =
+        CreateFile(filePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
+                   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
 
     LARGE_INTEGER size;
-    assert(GetFileSizeEx(hFile, &size) && "get_file_size: failed to get file size");
+    assert(GetFileSizeEx(hFile, &size) &&
+           "get_file_size: failed to get file size");
 
     return size.LowPart;
 }
 
 bool load_file(const char *filePath, unsigned long size, void *buffer) {
-    HANDLE hFile = CreateFile(filePath,
-            GENERIC_READ,
-            FILE_SHARE_READ,
-            NULL,
-            OPEN_EXISTING,
-            FILE_ATTRIBUTE_NORMAL,
-            NULL);
+    HANDLE hFile = CreateFile(filePath, GENERIC_READ, FILE_SHARE_READ, NULL,
+                              OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
     OVERLAPPED ol = {0};
     unsigned long bytesRead = 0;
     if (!ReadFile(hFile, buffer, size, &bytesRead, NULL)) {
         unsigned long error = GetLastError();
-        unsigned long msg = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, error, 0, buffer, size, NULL);
+        unsigned long msg = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
+                                          error, 0, buffer, size, NULL);
 
         printf("failed to load file: %s\n", (char *)buffer);
         assert(false && "failed to read file");
     }
-    assert(bytesRead == size && "load_file: didn't one-shot read the whole file");
+    assert(bytesRead == size &&
+           "load_file: didn't one-shot read the whole file");
 
     return true;
 }
@@ -97,11 +94,14 @@ bool load_file(const char *filePath, unsigned long size, void *buffer) {
 #include <Foundation/Foundation.h>
 
 uint64_t get_file_size(string file_path) {
-    NSFileManager* file_manager = [NSFileManager defaultManager];
-    NSString *path = [file_manager stringWithFileSystemRepresentation:(const char *)file_path.data length:file_path.len]; 
+    NSFileManager *file_manager = [NSFileManager defaultManager];
+    NSString *path = [file_manager
+        stringWithFileSystemRepresentation:(const char *)file_path.data
+                                    length:file_path.len];
 
     NSError *error = NULL;
-    NSDictionary<NSFileAttributeKey, id> *attributes = [file_manager attributesOfItemAtPath:path error:&error];
+    NSDictionary<NSFileAttributeKey, id> *attributes =
+        [file_manager attributesOfItemAtPath:path error:&error];
 
     if (error) {
         NSLog(@"error getting file attributes: %@\n", error.description);
@@ -109,22 +109,26 @@ uint64_t get_file_size(string file_path) {
     }
 
     NSNumber *file_size = [attributes objectForKey:NSFileSize];
-    
+
     return file_size.unsignedLongLongValue;
 }
 
 bool load_file(string file_path, size_t size, void *buffer) {
-    NSFileManager* file_manager = [NSFileManager defaultManager];
-    NSString *path = [file_manager stringWithFileSystemRepresentation:(const char *)file_path.data length:file_path.len]; 
+    NSFileManager *file_manager = [NSFileManager defaultManager];
+    NSString *path = [file_manager
+        stringWithFileSystemRepresentation:(const char *)file_path.data
+                                    length:file_path.len];
 
     NSData *data = [file_manager contentsAtPath:path];
     if (data == NULL) {
-        fprintf(stderr, "failed to load file: %.*s\n", (int)file_path.len, file_path.data);
+        fprintf(stderr, "failed to load file: %.*s\n", (int)file_path.len,
+                file_path.data);
         return false;
     }
 
     if (data.length > size) {
-        fprintf(stderr, "buffer not large enough for file: %.*s\n", (int)file_path.len, file_path.data);
+        fprintf(stderr, "buffer not large enough for file: %.*s\n",
+                (int)file_path.len, file_path.data);
     }
 
     memcpy(buffer, data.bytes, data.length);

src/gfx.h

@@ -2,12 +2,6 @@
 
 #ifndef ED_GFX_INCLUDED
 #define ED_GFX_INCLUDED
-#include <AppKit/AppKit.h>
-#include <CoreGraphics/CoreGraphics.h>
-#include <Foundation/Foundation.h>
-#include <Metal/Metal.h>
-#include <QuartzCore/CoreAnimation.h>
-#include <QuartzCore/QuartzCore.h>
 #include <stdint.h>
 
 #include "ed_array.h"
@@ -15,6 +9,13 @@
 
 bool keep_running = true;
 
+#if defined(__APPLE__)
+#include <AppKit/AppKit.h>
+#include <CoreGraphics/CoreGraphics.h>
+#include <Foundation/Foundation.h>
+#include <Metal/Metal.h>
+#include <QuartzCore/CoreAnimation.h>
+#include <QuartzCore/QuartzCore.h>
 @interface EDGFXView : NSView
 @property NSTrackingArea *tracking_area;
 @end
@@ -30,6 +31,7 @@ bool keep_running = true;
 wrapIdArray(MTLRenderPipelineState);
 wrapIdArray(MTLBuffer);
 wrapIdArray(MTLTexture);
+#endif
 
 typedef struct {
     float position[4];
@@ -72,6 +74,63 @@ typedef struct {
     array(_MTLBuffer) buffers;
     array(_MTLTexture) textures;
 } _metal_gfx_context;
+#elif __linux__
+#include "wayland-crap/xdg-shell.h"
+#include <EGL/egl.h>
+#include <GL/gl.h>
+#include <X11/Xlib.h>
+#include <sys/mman.h>
+#include <syscall.h>
+#include <unistd.h>
+#include <wayland-client.h>
+#include <wayland-egl.h>
+
+#include "file_io.h"
+
+// And I thought MacOS needed a lot of state to create a window
+arrayTemplate(GLuint);
+typedef struct {
+    struct wl_display *display;
+    struct wl_registry *registry;
+    struct wl_surface *surface;
+    struct wl_compositor *compositor;
+    struct wl_shm *shared_memory;
+    struct wl_shm_pool *shared_memory_pool;
+    struct xdg_wm_base *wm_base;
+    struct wl_buffer *buffer;
+    struct xdg_surface *xdg_surface;
+    struct xdg_toplevel *xdg_toplevel;
+    struct wl_seat *seat;
+    struct wl_pointer *pointer;
+    uint8_t *pixels;
+
+    EGLDisplay egl_display;
+    EGLConfig egl_config;
+    EGLSurface egl_surface;
+    EGLContext egl_context;
+    struct wl_egl_window *egl_window;
+
+    int mouse_x, mouse_y;
+    int mouse_left_down, mouse_right_down;
+
+    GLuint ui_rect_vertex_shader;
+    GLuint ui_rect_fragment_shader;
+    GLuint text_atlas_vertex_shader;
+    GLuint text_atlas_fragment_shader;
+    GLuint ui_rect_shader_program;
+    GLuint text_atlas_shader_program;
+
+    array(GLuint) buffers;
+    array(GLuint) textures;
+} _opengl_gfx_context_wayland;
+
+static void _opengl_gfx_present_wayland(_opengl_gfx_context_wayland *cx);
+
+typedef struct {
+    Display *display;
+    Window window;
+    int screen;
+} _opengl_gfx_context_x11;
 #endif
 
 typedef void (*_gfx_frame_func)(int mouse_x, int mouse_y, bool mouse_left_down,
@@ -79,6 +138,9 @@ typedef void (*_gfx_frame_func)(int mouse_x, int mouse_y, bool mouse_left_down,
 typedef struct {
 #if defined(__APPLE__)
     _metal_gfx_context backend;
+#elif __linux__
+    // TODO: be able to use X11 or Wayland at runtime
+    _opengl_gfx_context_wayland backend;
 #else
 #error "Unsupported platform"
 #endif
@@ -205,8 +267,8 @@ void gfx_update_buffer(gfx_context_t *cx, size_t buffer_index, const void *data,
 
 - (void)mouseMoved:(NSEvent *)event {
     // NSPoint location = NSEvent.mouseLocation;
-    NSPoint location = [self convertPoint:[event locationInWindow]
-                                 fromView:nil];
+    NSPoint location =
+        [self convertPoint:[event locationInWindow] fromView:nil];
 
     _gfx_context.backend.mouse_x = location.x;
     _gfx_context.backend.mouse_y = location.y;
@@ -302,8 +364,8 @@ static _metal_gfx_context _metal_gfx_init_context(uint32_t width,
         exit(1);
     }
 
-    id<MTLLibrary> library = [device newLibraryWithURL:libraryURL
-                                                 error:&libraryError];
+    id<MTLLibrary> library =
+        [device newLibraryWithURL:libraryURL error:&libraryError];
 
     if (library == NULL) {
         if (libraryError.description != NULL) {
@@ -573,11 +635,514 @@ static void _metal_gfx_update_buffer(_metal_gfx_context *cx,
     // FIXME: actually check to see if this will fit in the buffer
     memcpy(buffer_contents, data, len);
 }
+#elif __linux__
+#include <linux/input-event-codes.h>
+
+static void _wayland_pointer_enter(void *data, struct wl_pointer *pointer,
+                                   uint32_t serial, struct wl_surface *surface,
+                                   wl_fixed_t x, wl_fixed_t y) {
+    fprintf(stderr, "pointer enter: %d, %d\n", x, y);
+}
+static void _wayland_pointer_leave(void *data, struct wl_pointer *pointer,
+                                   uint32_t serial,
+                                   struct wl_surface *surface) {
+    fprintf(stderr, "pointer leave\n");
+}
+static void _wayland_pointer_button(void *data, struct wl_pointer *pointer,
+                                    uint32_t serial, uint32_t time,
+                                    uint32_t button, uint32_t state) {
+    _opengl_gfx_context_wayland *cx = data;
+
+    if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
+        if (button == BTN_LEFT) {
+            cx->mouse_left_down = true;
+        } else if (button == BTN_RIGHT) {
+            cx->mouse_right_down = true;
+        }
+    } else if (state == WL_POINTER_BUTTON_STATE_RELEASED) {
+        if (button == BTN_LEFT) {
+            cx->mouse_left_down = false;
+        } else if (button == BTN_RIGHT) {
+            cx->mouse_right_down = false;
+        }
+    }
+}
+static void _wayland_pointer_axis(void *data, struct wl_pointer *pointer,
+                                  uint32_t time, uint32_t axis,
+                                  wl_fixed_t value) {}
+static void _wayland_pointer_motion(void *data, struct wl_pointer *pointer,
+                                    uint32_t time, wl_fixed_t x, wl_fixed_t y) {
+    _opengl_gfx_context_wayland *cx = data;
+    cx->mouse_x = wl_fixed_to_int(x);
+    cx->mouse_y = wl_fixed_to_int(y);
+}
+
+static const struct wl_pointer_listener pointer_listener = {
+    .enter = _wayland_pointer_enter,
+    .leave = _wayland_pointer_leave,
+    .motion = _wayland_pointer_motion,
+    .button = _wayland_pointer_button,
+    .axis = _wayland_pointer_axis,
+};
+
+static void _wayland_xdg_toplevel_configure(void *data,
+                                            struct xdg_toplevel *xdg_toplevel,
+                                            int32_t width, int32_t height,
+                                            struct wl_array *states) {}
+
+static void _wayland_xdg_toplevel_close(void *data,
+                                        struct xdg_toplevel *xdg_toplevel) {
+    keep_running = false;
+}
+
+static const struct xdg_toplevel_listener xdg_toplevel_listener = {
+    _wayland_xdg_toplevel_configure,
+    _wayland_xdg_toplevel_close,
+};
+
+static void _wayland_xdg_surface_configure(void *data,
+                                           struct xdg_surface *xdg_surface,
+                                           uint32_t serial) {
+    xdg_surface_ack_configure(xdg_surface, serial);
+}
+
+static const struct xdg_surface_listener xdg_surface_listener = {
+    _wayland_xdg_surface_configure,
+};
+
+static void _wayland_xdg_wm_base_ping(void *data, struct xdg_wm_base *shell,
+                                      uint32_t serial) {
+    xdg_wm_base_pong(shell, serial);
+}
+static const struct xdg_wm_base_listener xdg_wm_base_listener = {
+    _wayland_xdg_wm_base_ping,
+};
+
+static void _wayland_registry_handle_global(void *data,
+                                            struct wl_registry *registry,
+                                            uint32_t name,
+                                            const char *interface,
+                                            uint32_t version) {
+    _opengl_gfx_context_wayland *d = data;
+
+    fprintf(stderr, "global: %s\n", interface);
+
+    if (strcmp(interface, "wl_compositor") == 0) {
+        d->compositor =
+            wl_registry_bind(registry, name, &wl_compositor_interface, 3);
+    } else if (strcmp(interface, "wl_shm") == 0) {
+        d->shared_memory =
+            wl_registry_bind(registry, name, &wl_shm_interface, 1);
+    } else if (strcmp(interface, "xdg_wm_base") == 0) {
+        d->wm_base =
+            wl_registry_bind(registry, name, &xdg_wm_base_interface, 1);
+    } else if (strcmp(interface, "wl_seat") == 0) {
+        d->seat = wl_registry_bind(registry, name, &wl_seat_interface, 1);
+    }
+}
+
+static void _wayland_registry_handle_global_remove(void *data,
+                                                   struct wl_registry *registry,
+                                                   uint32_t name) {}
+
+static const struct wl_registry_listener registry_listener = {
+    _wayland_registry_handle_global,
+    _wayland_registry_handle_global_remove,
+};
+
+static void _opengl_gfx_message_callback(GLenum source, GLenum type, GLenum id,
+                                         GLenum severity, GLsizei length,
+                                         const GLchar *message,
+                                         const void *user_param) {
+    fprintf(stderr,
+            "GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
+            type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : "", type, severity,
+            message);
+}
+
+static void _opengl_gfx_check_shader_error(string msg, GLuint shader,
+                                           GLuint status) {
+    GLint good = 0;
+    glGetShaderiv(shader, status, &good);
+    if (good == GL_FALSE) {
+        GLint max_length = 0;
+        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &max_length);
+
+        uint8_t *log_buffer = malloc(max_length + 1);
+        glGetShaderInfoLog(shader, max_length, &max_length, log_buffer);
+        glDeleteShader(shader);
+
+        fprintf(stderr, "%.*s: %.*s\n", msg.len, msg.data, max_length,
+                log_buffer);
+        exit(1);
+    }
+}
+
+static void _opengl_gfx_check_shader_program_error(string msg,
+                                                   GLuint shader_program,
+                                                   GLuint status) {
+    GLint good = 0;
+    glGetProgramiv(shader_program, status, &good);
+    if (good == GL_FALSE) {
+        GLint max_length = 0;
+        glGetProgramiv(shader_program, GL_INFO_LOG_LENGTH, &max_length);
+
+        uint8_t *log_buffer = malloc(max_length + 1);
+        glGetProgramInfoLog(shader_program, max_length, &max_length,
+                            log_buffer);
+        glDeleteProgram(shader_program);
+
+        fprintf(stderr, "%.*s: %.*s\n", msg.len, msg.data, max_length,
+                log_buffer);
+        exit(1);
+    }
+}
+
+static GLuint _opengl_gfx_compile_shader(string file_path, GLuint shader_type) {
+    GLuint shader = glCreateShader(shader_type);
+    size_t shader_file_size = get_file_size(file_path);
+    uint8_t *shader_file_data = malloc(shader_file_size + 1);
+    load_file(file_path, shader_file_size, shader_file_data);
+    shader_file_data[shader_file_size] = 0;
+    // fprintf(stderr, "%s\n", shader_file_data);
+
+    glShaderSource(shader, 1, &shader_file_data, NULL);
+    glCompileShader(shader);
+
+    _opengl_gfx_check_shader_error(_String("failed to compile shader"), shader,
+                                   GL_COMPILE_STATUS);
+
+    return shader;
+}
+
+static _opengl_gfx_context_wayland
+_opengl_gfx_init_context_wayland(uint32_t width, uint32_t height) {
+    _opengl_gfx_context_wayland cx = {0};
+
+    cx.display = wl_display_connect(NULL);
+    if (!cx.display) {
+        fprintf(stderr, "Failed to connect to Wayland display\n");
+        exit(1);
+    }
+    struct wl_registry *registry = wl_display_get_registry(cx.display);
+    wl_registry_add_listener(registry, &registry_listener, &cx);
+
+    // wait for all the globals to be registered
+    wl_display_roundtrip(cx.display);
+    xdg_wm_base_add_listener(cx.wm_base, &xdg_wm_base_listener,
+                             &_gfx_context.backend);
+
+    cx.pointer = wl_seat_get_pointer(cx.seat);
+    wl_pointer_add_listener(cx.pointer, &pointer_listener,
+                            &_gfx_context.backend);
+
+    cx.surface = wl_compositor_create_surface(cx.compositor);
+    cx.xdg_surface = xdg_wm_base_get_xdg_surface(cx.wm_base, cx.surface);
+    xdg_surface_add_listener(cx.xdg_surface, &xdg_surface_listener,
+                             &_gfx_context.backend);
+
+    cx.xdg_toplevel = xdg_surface_get_toplevel(cx.xdg_surface);
+    xdg_toplevel_add_listener(cx.xdg_toplevel, &xdg_toplevel_listener,
+                              &_gfx_context.backend);
+    xdg_toplevel_set_title(cx.xdg_toplevel, "chat - [Slack sux]");
+    xdg_toplevel_set_app_id(cx.xdg_toplevel, "nl.spacegirl.a_chat_client");
+
+    wl_surface_commit(cx.surface);
+    wl_display_roundtrip(cx.display);
+
+    int buffer_size = width * height * 4;
+    int fd = syscall(SYS_memfd_create, "buffer", 0);
+    ftruncate(fd, buffer_size);
+
+    cx.pixels =
+        mmap(NULL, buffer_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+    for (int i = 0; i < buffer_size; i++) {
+        cx.pixels[i] = 0;
+    }
+
+    cx.shared_memory_pool =
+        wl_shm_create_pool(cx.shared_memory, fd, buffer_size);
+    cx.buffer =
+        wl_shm_pool_create_buffer(cx.shared_memory_pool, 0, width, height,
+                                  width * 4, WL_SHM_FORMAT_ARGB8888);
+
+    wl_surface_attach(cx.surface, cx.buffer, 0, 0);
+    wl_surface_commit(cx.surface);
+
+    /* Init EGL */
+    EGLint major, minor, count, n, size;
+    EGLConfig *configs;
+    EGLint config_attribs[] = {
+        EGL_SURFACE_TYPE,
+        EGL_WINDOW_BIT,
+        //
+        EGL_RED_SIZE,
+        8,
+        //
+        EGL_BLUE_SIZE,
+        8,
+        //
+        EGL_GREEN_SIZE,
+        8,
+        //
+        EGL_RENDERABLE_TYPE,
+        EGL_OPENGL_BIT,
+        //
+        EGL_NONE,
+    };
+
+    static const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2,
+                                             EGL_NONE};
+
+    cx.egl_display = eglGetDisplay(cx.display);
+    if (cx.egl_display == EGL_NO_DISPLAY) {
+        fprintf(stderr, "Failed to create EGL display\n");
+        exit(1);
+    }
+    fprintf(stderr, "Created EGL display\n");
+
+    if (eglInitialize(cx.egl_display, &major, &minor) != EGL_TRUE) {
+        fprintf(stderr, "Failed to initialize EGL display\n");
+        exit(1);
+    }
+    fprintf(stderr, "EGL major: %d, minor: %d\n", major, minor);
+
+    eglGetConfigs(cx.egl_display, NULL, 0, &count);
+    configs = calloc(count, sizeof(EGLConfig));
+
+    eglChooseConfig(cx.egl_display, config_attribs, configs, count, &n);
+
+    for (int i = 0; i < n; ++i) {
+        eglGetConfigAttrib(cx.egl_display, configs[i], EGL_BUFFER_SIZE, &size);
+        fprintf(stderr, "EGL Buffer size: %d\n", size);
+
+        eglGetConfigAttrib(cx.egl_display, configs[i], EGL_RED_SIZE, &size);
+        fprintf(stderr, "EGL Red size: %d\n", size);
+
+        cx.egl_config = configs[i];
+        break;
+    }
+
+    eglBindAPI(EGL_OPENGL_API);
+    cx.egl_context = eglCreateContext(cx.egl_display, cx.egl_config,
+                                      EGL_NO_CONTEXT, context_attribs);
+
+    cx.egl_window = wl_egl_window_create(cx.surface, width, height);
+    if (cx.egl_window == EGL_NO_SURFACE) {
+        fprintf(stderr, "Failed to create EGL window\n");
+        exit(1);
+    }
+    fprintf(stderr, "Created EGL window\n");
+
+    cx.egl_surface = eglCreateWindowSurface(cx.egl_display, cx.egl_config,
+                                            cx.egl_window, NULL);
+    if (eglMakeCurrent(cx.egl_display, cx.egl_surface, cx.egl_surface,
+                       cx.egl_context) != EGL_TRUE) {
+        fprintf(stderr, "eglMakeCurrent() failed\n");
+    }
+
+    glEnable(GL_DEBUG_OUTPUT);
+    glDebugMessageCallback(_opengl_gfx_message_callback, NULL);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    cx.ui_rect_vertex_shader = _opengl_gfx_compile_shader(
+        _String("shaders/ui_rect_vertex.glsl"), GL_VERTEX_SHADER);
+    cx.ui_rect_fragment_shader = _opengl_gfx_compile_shader(
+        _String("shaders/ui_rect_fragment.glsl"), GL_FRAGMENT_SHADER);
+    cx.ui_rect_shader_program = glCreateProgram();
+    glAttachShader(cx.ui_rect_shader_program, cx.ui_rect_vertex_shader);
+    glAttachShader(cx.ui_rect_shader_program, cx.ui_rect_fragment_shader);
+    glLinkProgram(cx.ui_rect_shader_program);
+    _opengl_gfx_check_shader_program_error(
+        _String("failed to link ui_rect shader program"),
+        cx.ui_rect_shader_program, GL_LINK_STATUS);
+
+    cx.text_atlas_vertex_shader = _opengl_gfx_compile_shader(
+        _String("shaders/text_atlas_vertex.glsl"), GL_VERTEX_SHADER);
+    cx.text_atlas_fragment_shader = _opengl_gfx_compile_shader(
+        _String("shaders/text_atlas_fragment.glsl"), GL_FRAGMENT_SHADER);
+    cx.text_atlas_shader_program = glCreateProgram();
+    glAttachShader(cx.text_atlas_shader_program, cx.text_atlas_vertex_shader);
+    glAttachShader(cx.text_atlas_shader_program, cx.text_atlas_fragment_shader);
+    glLinkProgram(cx.text_atlas_shader_program);
+    _opengl_gfx_check_shader_program_error(
+        _String("failed to link text_atlas shader program"),
+        cx.text_atlas_shader_program, GL_LINK_STATUS);
+
+    cx.buffers = newArray(GLuint, 8);
+    cx.textures = newArray(GLuint, 8);
+    /* ******** */
+
+    return cx;
+}
+
+static _opengl_gfx_context_x11 _opengl_gfx_init_context_11(uint32_t width,
+                                                           uint32_t height) {
+    Display *display = XOpenDisplay(NULL);
+    if (display == NULL) {
+        fprintf(stderr, "Failed to open X display\n");
+        exit(1);
+    }
+
+    int screen = DefaultScreen(display);
+    Window window = XCreateSimpleWindow(
+        display, RootWindow(display, screen), 0, 0, width, height, 1,
+        BlackPixel(display, screen), WhitePixel(display, screen));
+    XSelectInput(display, window,
+                 ExposureMask | KeyPressMask | ButtonPressMask |
+                     ButtonReleaseMask);
+    XMapWindow(display, window);
+
+    return (_opengl_gfx_context_x11){
+        .display = display,
+        .window = window,
+        .screen = screen,
+    };
+}
+
+static void _opengl_gfx_send_events_wayland(_opengl_gfx_context_wayland *cx) {
+    wl_display_dispatch(cx->display);
+
+    // TODO: don't just render like crazy, limit framerate
+    _opengl_gfx_present_wayland(cx);
+}
+
+static void _opengl_gfx_send_events_x11(_opengl_gfx_context_x11 *cx) {
+    XEvent e;
+    XNextEvent(cx->display, &e);
+    if (e.type == Expose) {
+        XFillRectangle(cx->display, cx->window,
+                       DefaultGC(cx->display, cx->screen), 20, 20, 10, 10);
+    }
+
+    if (e.type == KeyPress) {
+        keep_running = false;
+
+        XCloseDisplay(cx->display);
+    }
+}
+
+static void _opengl_gfx_present_wayland(_opengl_gfx_context_wayland *cx) {
+    _gfx_context.gpu_glyphs.size = 0;
+    _gfx_context.gpu_ui_rects.size = 0;
+    _gfx_context.frame_func(cx->mouse_x, cx->mouse_y, cx->mouse_left_down,
+                            cx->mouse_right_down);
+
+    if (_gfx_context.gpu_glyphs.size > 0) {
+        gfx_update_buffer(&_gfx_context, 2, _gfx_context.gpu_glyphs.data,
+                          _gfx_context.gpu_glyphs.size * sizeof(GpuGlyph));
+    }
+    if (_gfx_context.gpu_ui_rects.size > 0) {
+        gfx_update_buffer(&_gfx_context, 4, _gfx_context.gpu_ui_rects.data,
+                          _gfx_context.gpu_ui_rects.size * sizeof(GpuUiRect));
+    }
+
+    GpuUniformParams gpu_uniform_params = {
+        .screen_size =
+            {
+                (float)_gfx_context.frame_width,
+                (float)_gfx_context.frame_height,
+            },
+    };
+
+    gfx_update_buffer(&_gfx_context, 3, &gpu_uniform_params,
+                      sizeof(GpuUniformParams));
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glViewport(0, 0, _gfx_context.frame_width, _gfx_context.frame_height);
+
+    if (_gfx_context.gpu_ui_rects.size > 0) {
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, cx->buffers.data[0]);
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, cx->buffers.data[4]);
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, cx->buffers.data[3]);
+        glUseProgram(cx->ui_rect_shader_program);
+
+        const uint16_t indices[] = {0, 1, 2, 0, 2, 3};
+        glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices,
+                                _gfx_context.gpu_ui_rects.size);
+    }
+
+    if (_gfx_context.gpu_glyphs.size > 0) {
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, cx->buffers.data[0]);
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, cx->buffers.data[2]);
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, cx->buffers.data[3]);
+        glUseProgram(cx->text_atlas_shader_program);
+
+        const uint16_t indices[] = {0, 1, 2, 0, 2, 3};
+        glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices,
+                                _gfx_context.gpu_glyphs.size);
+    }
+
+    glFlush();
+
+    if (eglSwapBuffers(cx->egl_display, cx->egl_surface) != EGL_TRUE) {
+        fprintf(stderr, "eglSwapBuffers() failed\n");
+    }
+}
+
+static size_t
+_opengl_gfx_push_texture_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                        uint32_t width, uint32_t height,
+                                        const void *data, size_t len) {
+    pushArray(GLuint, &cx->textures, 0);
+    glCreateTextures(GL_TEXTURE_2D, 1,
+                     &cx->textures.data[cx->textures.size - 1]);
+    glTextureParameteri(cx->textures.data[cx->textures.size - 1],
+                        GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTextureParameteri(cx->textures.data[cx->textures.size - 1],
+                        GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTextureStorage2D(cx->textures.data[cx->textures.size - 1], 1, GL_RGBA8,
+                       width, height);
+    glTextureSubImage2D(cx->textures.data[cx->textures.size - 1], 0, 0, 0,
+                        width, height, GL_RED, GL_UNSIGNED_BYTE, data);
+    glBindTextureUnit(cx->textures.size - 1,
+                      cx->textures.data[cx->textures.size - 1]);
+
+    return cx->textures.size - 1;
+}
+
+static void
+_opengl_gfx_resize_texture_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                          uint32_t width, size_t texture_index,
+                                          uint32_t height) {
+    // TODO
+    assert(false && "_opengl_gfx_resize_texture_buffer_wayland unimplemented");
+}
+
+size_t _opengl_gfx_push_vertex_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                              const void *data, size_t len) {
+    pushArray(GLuint, &cx->buffers, 0);
+    glCreateBuffers(1, &cx->buffers.data[cx->buffers.size - 1]);
+    glNamedBufferStorage(cx->buffers.data[cx->buffers.size - 1], len, data,
+                         GL_DYNAMIC_STORAGE_BIT);
+
+    return cx->buffers.size - 1;
+}
+static size_t
+_opengl_gfx_allocate_vertex_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                           size_t len) {
+    pushArray(GLuint, &cx->buffers, 0);
+    glCreateBuffers(1, &cx->buffers.data[cx->buffers.size - 1]);
+    glNamedBufferStorage(cx->buffers.data[cx->buffers.size - 1], len, (void *)0,
+                         GL_DYNAMIC_STORAGE_BIT);
+
+    return cx->buffers.size - 1;
+}
+static void _opengl_gfx_update_buffer_wayland(_opengl_gfx_context_wayland *cx,
+                                              size_t buffer_index,
+                                              const void *data, size_t len) {
+    glNamedBufferSubData(cx->buffers.data[buffer_index], 0, len, data);
+}
 #endif
 
 void gfx_run_events(gfx_context_t *cx) {
 #if defined(__APPLE__)
     return _metal_gfx_send_events(&cx->backend);
+#elif __linux__
+    return _opengl_gfx_send_events_wayland(&cx->backend);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -588,6 +1153,9 @@ size_t gfx_push_texture_buffer(gfx_context_t *cx, uint32_t width,
 #if defined(__APPLE__)
     return _metal_gfx_push_texture_buffer(&cx->backend, width, height, data,
                                           len);
+#elif __linux__
+    return _opengl_gfx_push_texture_buffer_wayland(&cx->backend, width, height,
+                                                   data, len);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -596,6 +1164,8 @@ size_t gfx_push_texture_buffer(gfx_context_t *cx, uint32_t width,
 size_t gfx_push_vertex_buffer(gfx_context_t *cx, const void *data, size_t len) {
 #if defined(__APPLE__)
     return _metal_gfx_push_vertex_buffer(&cx->backend, data, len);
+#elif __linux__
+    return _opengl_gfx_push_vertex_buffer_wayland(&cx->backend, data, len);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -604,6 +1174,8 @@ size_t gfx_push_vertex_buffer(gfx_context_t *cx, const void *data, size_t len) {
 size_t gfx_allocate_vertex_buffer(gfx_context_t *cx, size_t len) {
 #if defined(__APPLE__)
     return _metal_gfx_allocate_vertex_buffer(&cx->backend, len);
+#elif __linux__
+    return _opengl_gfx_allocate_vertex_buffer_wayland(&cx->backend, len);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -614,6 +1186,9 @@ void gfx_update_buffer(gfx_context_t *cx, size_t buffer_index, const void *data,
                        size_t len) {
 #if defined(__APPLE__)
     return _metal_gfx_update_buffer(&cx->backend, buffer_index, data, len);
+#elif __linux__
+    return _opengl_gfx_update_buffer_wayland(&cx->backend, buffer_index, data,
+                                             len);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -661,6 +1236,8 @@ void *gfx_init_context(_gfx_frame_func frame_func, uint32_t width,
     __auto_type backend =
 #if defined(__APPLE__)
         _metal_gfx_init_context(width, height);
+#elif __linux__
+        _opengl_gfx_init_context_wayland(width, height);
 #else
 #error "Unsupported graphics backend"
 #endif
@@ -674,7 +1251,7 @@ void *gfx_init_context(_gfx_frame_func frame_func, uint32_t width,
     _gfx_context.gpu_glyphs = newArray(GpuGlyph, 8192 * 32);
     _gfx_context.glyph_cache = newArray(GpuGlyph, 97);
 
-    float vertices[] = {
+    const float vertices[] = {
         // positions       texture coords
         -1.0f, 1.0f,  0.0f, 0.0f, 1.0f,  1.0f,  1.0f, 0.0f,
         1.0f,  -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f,

src/main.c

@@ -42,7 +42,7 @@ static struct {
     gfx_context_t *gfx_cx;
 } state;
 
-void ed_init(_gfx_frame_func frame_func) {
+void init(_gfx_frame_func frame_func) {
     state.gfx_cx = gfx_init_context(frame_func, 640, 480);
     state.ui_cx = ui_init_context();
 
@@ -145,6 +145,34 @@ void ed_frame(int mouse_x, int mouse_y, bool mouse_left_down,
                                       .mouse_right_down = mouse_right_down,
                                   });
 
+    // TODO: make having custom title bar configurable
+    {
+        size_t title_bar_elm =
+            ui_element(&state.ui_cx, _String("chat - [slack sux]"),
+                       UI_AXIS_HORIZONTAL, ui_make_size(ui_fill, ui_exact(32)),
+                       UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT |
+                           UI_FLAG_CENTERED_TEXT);
+
+        ui_interaction title_bar_interaction =
+            _ui_test_interaction(&state.ui_cx, title_bar_elm);
+
+        if (title_bar_interaction.dragging) {
+            // TODO: drag the window around
+        }
+
+        ui_push_parent(&state.ui_cx);
+        {
+            ui_element(&state.ui_cx, _String("title bar spacer"),
+                       UI_AXIS_HORIZONTAL, ui_make_size(ui_fill, ui_exact(32)),
+                       0);
+
+            if (ui_button_centered(&state.ui_cx, _String("X")).clicked) {
+                keep_running = false;
+            }
+        }
+        ui_pop_parent(&state.ui_cx);
+    }
+
     ui_element(&state.ui_cx, _String("channel sidebar"), UI_AXIS_VERTICAL,
                ui_make_size(ui_children_sum, ui_fill), UI_FLAG_DRAW_BACKGROUND);
     ui_push_parent(&state.ui_cx);
@@ -201,15 +229,17 @@ void ed_frame(int mouse_x, int mouse_y, bool mouse_left_down,
 }
 
 int main(int argc, char *argv[]) {
-    curl_global_init(CURL_GLOBAL_ALL);
+    /* curl_global_init(CURL_GLOBAL_ALL);
 
-    slack_client client = slack_init_client();
-    _slack_debug_print_auth_test(&client);
+    slack_client client = slack_init_client(_String("test token"),
+    _String("Cookie: test_cookie=hello")); _slack_debug_print_auth_test(&client,
+    _String("test token"), _String("Cookie: test_cookie=hello"));
 
     curl_global_cleanup();
     return 0;
+    */
 
-    ed_init(ed_frame);
+    init(ed_frame);
 
     while (keep_running) {
         gfx_run_events(state.gfx_cx);

src/slack_api.h

@@ -11,7 +11,7 @@ typedef struct {
     CURL *curl;
 } slack_client;
 
-void _slack_debug_print_auth_test(slack_client *client);
+void _slack_debug_print_auth_test(slack_client *client, string token, string cookie);
 
 slack_client slack_init_client();
 

src/ui.h

@@ -61,6 +61,9 @@ typedef struct {
     ((ui_semantic_size){.type = UI_SEMANTIC_SIZE_CHILDREN_SUM})
 #define ui_exact(value)                                                        \
     ((ui_semantic_size){.type = UI_SEMANTIC_SIZE_EXACT, .integer = value})
+#define ui_percent_of_parent(value)                                            \
+    ((ui_semantic_size){.type = UI_SEMANTIC_SIZE_PERCENT_OF_PARENT,            \
+                        .integer = value})
 
 typedef struct {
     ui_axis axis;
@@ -83,15 +86,16 @@ typedef struct {
 } ui_element_cache_data;
 
 typedef enum {
-    UI_FLAG_CLICKABLE = 0b000000001,
-    UI_FLAG_HOVERABLE = 0b000000010,
-    UI_FLAG_SCROLLABLE = 0b000000100,
-    UI_FLAG_DRAW_TEXT = 0b000001000,
-    UI_FLAG_DRAW_BORDER = 0b000010000,
-    UI_FLAG_DRAW_BACKGROUND = 0b000100000,
-    UI_FLAG_ROUNDED_BORDER = 0b001000000,
-    UI_FLAG_FLOATING = 0b010000000,
-    UI_FLAG_CUSTOM_DRAW_FUNC = 0b100000000,
+    UI_FLAG_CLICKABLE = 0b0000000001,
+    UI_FLAG_HOVERABLE = 0b0000000010,
+    UI_FLAG_SCROLLABLE = 0b0000000100,
+    UI_FLAG_DRAW_TEXT = 0b0000001000,
+    UI_FLAG_CENTERED_TEXT = 0b1000000000,
+    UI_FLAG_DRAW_BORDER = 0b0000010000,
+    UI_FLAG_DRAW_BACKGROUND = 0b0000100000,
+    UI_FLAG_ROUNDED_BORDER = 0b0001000000,
+    UI_FLAG_FLOATING = 0b0010000000,
+    UI_FLAG_CUSTOM_DRAW_FUNC = 0b0100000000,
 } ui_flags;
 
 // Ephemeral frame only UI Element data
@@ -161,7 +165,8 @@ ui_context ui_init_context() {
         .prev = -1,
         .parent = -1,
         .size = {
-            .axis = UI_AXIS_HORIZONTAL,
+            // TODO: make this configurable
+            .axis = UI_AXIS_VERTICAL,
             .computed_size = {640, 480},
         }};
     pushArray(ui_element_frame_data, &frame_elements, frame_data);
@@ -267,6 +272,15 @@ ui_interaction ui_button(ui_context *cx, string label) {
     return _ui_test_interaction(cx, id);
 }
 
+ui_interaction ui_button_centered(ui_context *cx, string label) {
+    size_t id = ui_element(
+        cx, label, UI_AXIS_HORIZONTAL, ui_make_size(ui_fit_text, ui_fit_text),
+        UI_FLAG_DRAW_BACKGROUND | UI_FLAG_DRAW_TEXT | UI_FLAG_CENTERED_TEXT |
+            UI_FLAG_HOVERABLE | UI_FLAG_CLICKABLE);
+
+    return _ui_test_interaction(cx, id);
+}
+
 static uint32_t _ui_ancestor_size(ui_context *cx, size_t element_index,
                                   ui_axis axis) {
     if (element_index == SIZE_MAX || _parent(element_index) == SIZE_MAX) {
@@ -293,9 +307,9 @@ static void _ui_compute_simple_layout(ui_context *cx,
     switch (elm->size.semantic_size[axis].type) {
     case UI_SEMANTIC_SIZE_FIT_TEXT:
         if (axis == UI_AXIS_HORIZONTAL) {
-            elm->size.computed_size[axis] = elm->label.len * _FONT_WIDTH;
+            elm->size.computed_size[axis] = (elm->label.len + 2) * _FONT_WIDTH;
         } else if (axis == UI_AXIS_VERTICAL) {
-            elm->size.computed_size[axis] = _FONT_HEIGHT;
+            elm->size.computed_size[axis] = _FONT_HEIGHT + (_FONT_HEIGHT / 4);
         }
         break;
 
@@ -504,7 +518,16 @@ void ui_render(ui_context *cx, _ui_render_text_func text_func,
         ui_element_frame_data *elm = &cx->frame_elements.data[i];
 
         if (_flags(i, UI_FLAG_DRAW_TEXT)) {
-            text_func(text, (float[]){(float)elm->size.computed_pos[0],
+            uint32_t x_offset = 0;
+
+            if (_flags(i, UI_FLAG_CENTERED_TEXT)) {
+                uint32_t half_width = elm->size.computed_size[0] / 2;
+                uint32_t half_text_width = (text.len / 2) * _FONT_WIDTH;
+                x_offset = half_width - half_text_width;
+            }
+
+            text_func(text, (float[]){(float)elm->size.computed_pos[0] +
+                                          (float)x_offset,
                                       (float)elm->size.computed_pos[1]});
         }
 

src/wayland-crap/xdg-shell.c

@@ -0,0 +1,173 @@
+/* Generated by wayland-scanner 1.22.0 */
+
+/*
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ * Copyright © 2015-2017 Samsung Electronics Co., Ltd
+ * Copyright © 2015-2017 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface wl_seat_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface xdg_popup_interface;
+extern const struct wl_interface xdg_positioner_interface;
+extern const struct wl_interface xdg_surface_interface;
+extern const struct wl_interface xdg_toplevel_interface;
+
+static const struct wl_interface *xdg_shell_types[] = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&xdg_positioner_interface,
+	&xdg_surface_interface,
+	&wl_surface_interface,
+	&xdg_toplevel_interface,
+	&xdg_popup_interface,
+	&xdg_surface_interface,
+	&xdg_positioner_interface,
+	&xdg_toplevel_interface,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	&wl_output_interface,
+	&wl_seat_interface,
+	NULL,
+	&xdg_positioner_interface,
+	NULL,
+};
+
+static const struct wl_message xdg_wm_base_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "create_positioner", "n", xdg_shell_types + 4 },
+	{ "get_xdg_surface", "no", xdg_shell_types + 5 },
+	{ "pong", "u", xdg_shell_types + 0 },
+};
+
+static const struct wl_message xdg_wm_base_events[] = {
+	{ "ping", "u", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_wm_base_interface = {
+	"xdg_wm_base", 6,
+	4, xdg_wm_base_requests,
+	1, xdg_wm_base_events,
+};
+
+static const struct wl_message xdg_positioner_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "set_size", "ii", xdg_shell_types + 0 },
+	{ "set_anchor_rect", "iiii", xdg_shell_types + 0 },
+	{ "set_anchor", "u", xdg_shell_types + 0 },
+	{ "set_gravity", "u", xdg_shell_types + 0 },
+	{ "set_constraint_adjustment", "u", xdg_shell_types + 0 },
+	{ "set_offset", "ii", xdg_shell_types + 0 },
+	{ "set_reactive", "3", xdg_shell_types + 0 },
+	{ "set_parent_size", "3ii", xdg_shell_types + 0 },
+	{ "set_parent_configure", "3u", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_positioner_interface = {
+	"xdg_positioner", 6,
+	10, xdg_positioner_requests,
+	0, NULL,
+};
+
+static const struct wl_message xdg_surface_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "get_toplevel", "n", xdg_shell_types + 7 },
+	{ "get_popup", "n?oo", xdg_shell_types + 8 },
+	{ "set_window_geometry", "iiii", xdg_shell_types + 0 },
+	{ "ack_configure", "u", xdg_shell_types + 0 },
+};
+
+static const struct wl_message xdg_surface_events[] = {
+	{ "configure", "u", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_surface_interface = {
+	"xdg_surface", 6,
+	5, xdg_surface_requests,
+	1, xdg_surface_events,
+};
+
+static const struct wl_message xdg_toplevel_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "set_parent", "?o", xdg_shell_types + 11 },
+	{ "set_title", "s", xdg_shell_types + 0 },
+	{ "set_app_id", "s", xdg_shell_types + 0 },
+	{ "show_window_menu", "ouii", xdg_shell_types + 12 },
+	{ "move", "ou", xdg_shell_types + 16 },
+	{ "resize", "ouu", xdg_shell_types + 18 },
+	{ "set_max_size", "ii", xdg_shell_types + 0 },
+	{ "set_min_size", "ii", xdg_shell_types + 0 },
+	{ "set_maximized", "", xdg_shell_types + 0 },
+	{ "unset_maximized", "", xdg_shell_types + 0 },
+	{ "set_fullscreen", "?o", xdg_shell_types + 21 },
+	{ "unset_fullscreen", "", xdg_shell_types + 0 },
+	{ "set_minimized", "", xdg_shell_types + 0 },
+};
+
+static const struct wl_message xdg_toplevel_events[] = {
+	{ "configure", "iia", xdg_shell_types + 0 },
+	{ "close", "", xdg_shell_types + 0 },
+	{ "configure_bounds", "4ii", xdg_shell_types + 0 },
+	{ "wm_capabilities", "5a", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_toplevel_interface = {
+	"xdg_toplevel", 6,
+	14, xdg_toplevel_requests,
+	4, xdg_toplevel_events,
+};
+
+static const struct wl_message xdg_popup_requests[] = {
+	{ "destroy", "", xdg_shell_types + 0 },
+	{ "grab", "ou", xdg_shell_types + 22 },
+	{ "reposition", "3ou", xdg_shell_types + 24 },
+};
+
+static const struct wl_message xdg_popup_events[] = {
+	{ "configure", "iiii", xdg_shell_types + 0 },
+	{ "popup_done", "", xdg_shell_types + 0 },
+	{ "repositioned", "3u", xdg_shell_types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_popup_interface = {
+	"xdg_popup", 6,
+	3, xdg_popup_requests,
+	3, xdg_popup_events,
+};
+