diff --git a/glava-cli/cli.c b/glava-cli/cli.c
index f80d038..02cf79f 100644
--- a/glava-cli/cli.c
+++ b/glava-cli/cli.c
@@ -3,7 +3,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-static renderer_handle handle;
+static glava_handle handle;
 
 static void handle_term  (int _) {
     printf("Interrupt recieved, closing...\n");
diff --git a/glava/glava.c b/glava/glava.c
index b302c28..8d38bba 100644
--- a/glava/glava.c
+++ b/glava/glava.c
@@ -234,7 +234,7 @@ static struct option p_opts[] = {
     {0,             0,                 0,  0 }
 };
 
-static renderer* rd = NULL;
+static glava_renderer* rd = NULL;
 
 #define append_buf(buf, sz_store, ...)                      \
     ({                                                      \
@@ -242,8 +242,8 @@ static renderer* rd = NULL;
         buf[*sz_store - 1] = __VA_ARGS__;                   \
     })
 
-/* Wait for renderer target texture to be initialized and valid */
-__attribute__((visibility("default"))) void glava_wait(renderer_handle* ref) {
+/* Wait for glava_renderer target texture to be initialized and valid */
+__attribute__((visibility("default"))) void glava_wait(glava_handle* ref) {
     while(__atomic_load_n(ref, __ATOMIC_SEQ_CST) == NULL) {
         /* Edge case: handle has not been assigned */
         struct timespec tv = {
@@ -257,27 +257,27 @@ __attribute__((visibility("default"))) void glava_wait(renderer_handle* ref) {
 }
 
 /* Atomic size request */
-__attribute__((visibility("default"))) void glava_sizereq(renderer_handle r, int x, int y, int w, int h) {
+__attribute__((visibility("default"))) void glava_sizereq(glava_handle r, int x, int y, int w, int h) {
     r->sizereq = (typeof(r->sizereq)) { .x = x, .y = y, .w = w, .h = h };
     __atomic_store_n(&r->sizereq_flag, GLAVA_REQ_RESIZE, __ATOMIC_SEQ_CST);
 }
 
 /* Atomic terminate request */
-__attribute__((visibility("default"))) void glava_terminate(renderer_handle* ref) {
-    renderer_handle store = __atomic_exchange_n(ref, NULL, __ATOMIC_SEQ_CST);
+__attribute__((visibility("default"))) void glava_terminate(glava_handle* ref) {
+    glava_handle store = __atomic_exchange_n(ref, NULL, __ATOMIC_SEQ_CST);
     __atomic_store_n(&store->alive, false, __ATOMIC_SEQ_CST);
 }
 
 /* Atomic reload request */
-__attribute__((visibility("default"))) void glava_reload(renderer_handle* ref) {
-    renderer_handle store = __atomic_exchange_n(ref, NULL, __ATOMIC_SEQ_CST);
+__attribute__((visibility("default"))) void glava_reload(glava_handle* ref) {
+    glava_handle store = __atomic_exchange_n(ref, NULL, __ATOMIC_SEQ_CST);
     __atomic_store_n(&reload,       true,  __ATOMIC_SEQ_CST);
     __atomic_store_n(&store->alive, false, __ATOMIC_SEQ_CST);
 }
 
 
 /* Main entry */
-__attribute__((visibility("default"))) void glava_entry(int argc, char** argv, renderer_handle* ret) {
+__attribute__((visibility("default"))) void glava_entry(int argc, char** argv, glava_handle* ret) {
 
     /* Evaluate these macros only once, since they allocate */
     const char
diff --git a/glava/glava.h b/glava/glava.h
index 9ab6b05..dbcf875 100644
--- a/glava/glava.h
+++ b/glava/glava.h
@@ -10,7 +10,7 @@
 
 struct gl_data;
 
-typedef struct renderer {
+typedef struct glava_renderer {
     volatile bool alive;
     bool    mirror_input;
     size_t  bufsize_request, rate_request, samplesize_request;
@@ -23,18 +23,18 @@ typedef struct renderer {
     } sizereq;
     volatile int sizereq_flag;
     struct gl_data* gl;
-} renderer;
+} glava_renderer;
 
 /* External API */
 
-typedef struct renderer* volatile renderer_handle;
+typedef struct glava_renderer* volatile glava_handle;
 __attribute__((noreturn, visibility("default"))) void (*glava_abort)            (void);
 __attribute__((noreturn, visibility("default"))) void (*glava_return)           (void);
 __attribute__((visibility("default")))           void glava_assign_external_ctx (void* ctx);
-__attribute__((visibility("default")))           void glava_entry               (int argc, char** argv, renderer_handle* ret);
-__attribute__((visibility("default")))           void glava_terminate           (renderer_handle* ref);
-__attribute__((visibility("default")))           void glava_reload              (renderer_handle* ref);
-__attribute__((visibility("default")))           void glava_sizereq             (renderer_handle r, int x, int y, int w, int h);
-__attribute__((visibility("default")))           void glava_wait                (renderer_handle* ref);
+__attribute__((visibility("default")))           void glava_entry               (int argc, char** argv, glava_handle* ret);
+__attribute__((visibility("default")))           void glava_terminate           (glava_handle* ref);
+__attribute__((visibility("default")))           void glava_reload              (glava_handle* ref);
+__attribute__((visibility("default")))           void glava_sizereq             (glava_handle r, int x, int y, int w, int h);
+__attribute__((visibility("default")))           void glava_wait                (glava_handle* ref);
 
 #endif /* _GLAVA_H */
diff --git a/glava/render.c b/glava/render.c
index b09e48d..1a26352 100644
--- a/glava/render.c
+++ b/glava/render.c
@@ -159,7 +159,7 @@ struct gl_data {
     #endif
 };
 
-bool rd_get_test_mode(struct renderer* r) {
+bool rd_get_test_mode(struct glava_renderer* r) {
     struct gl_data* gl = r->gl;
     return gl->test_mode;
 }
@@ -801,7 +801,7 @@ static struct gl_bind_src* lookup_bind_src(const char* str) {
     return NULL;
 }
 
-struct renderer* rd_new(const char**    paths,        const char* entry,
+struct glava_renderer* rd_new(const char**    paths,        const char* entry,
                         const char**    requests,     const char* force_backend,
                         struct rd_bind* bindings,     int         stdin_type,
                         bool            auto_desktop, bool        verbose,
@@ -809,8 +809,8 @@ struct renderer* rd_new(const char**    paths,        const char* entry,
     
     xwin_wait_for_wm();
     
-    renderer* r = malloc(sizeof(struct renderer));
-    *r = (struct renderer) {
+    glava_renderer* r = malloc(sizeof(struct glava_renderer));
+    *r = (struct glava_renderer) {
         .alive                = true,
         .mirror_input         = false,
         .gl                   = malloc(sizeof(struct gl_data)),
@@ -1568,13 +1568,13 @@ struct renderer* rd_new(const char**    paths,        const char* entry,
     return r;
 }
 
-void rd_time(struct renderer* r) {
+void rd_time(struct glava_renderer* r) {
     struct gl_data* gl = r->gl;
     
     gl->wcb->set_time(gl->w, 0.0D); /* reset time for measuring this frame */
 }
 
-bool rd_update(struct renderer* r, float* lb, float* rb, size_t bsz, bool modified) {
+bool rd_update(struct glava_renderer* r, float* lb, float* rb, size_t bsz, bool modified) {
     struct gl_data* gl = r->gl;
     size_t t, a, fbsz = bsz * sizeof(float);
     
@@ -2145,7 +2145,7 @@ bool rd_update(struct renderer* r, float* lb, float* rb, size_t bsz, bool modifi
 }
 
 #ifdef GLAVA_DEBUG
-bool rd_test_evaluate(struct renderer* r) {
+bool rd_test_evaluate(struct glava_renderer* r) {
     int w, h;
     struct gl_data* gl = r->gl;
     gl->wcb->get_fbsize(gl->w, &w, &h);
@@ -2181,10 +2181,10 @@ end_test:
 }
 #endif
 
-void*          rd_get_impl_window (struct renderer* r)  { return r->gl->w;   }
-struct gl_wcb* rd_get_wcb         (struct renderer* r)  { return r->gl->wcb; }
+void*          rd_get_impl_window (struct glava_renderer* r)  { return r->gl->w;   }
+struct gl_wcb* rd_get_wcb         (struct glava_renderer* r)  { return r->gl->wcb; }
 
-void rd_destroy(struct renderer* r) {
+void rd_destroy(struct glava_renderer* r) {
     r->gl->wcb->destroy(r->gl->w);
     if (r->gl->interpolate) free(r->gl->interpolate_buf[0]);
     size_t t, b;
diff --git a/glava/render.h b/glava/render.h
index 242edaa..25c7805 100644
--- a/glava/render.h
+++ b/glava/render.h
@@ -30,21 +30,21 @@ struct rd_bind {
 };
 
 #ifdef GLAVA_DEBUG
-bool rd_get_test_mode   (struct renderer*);
-bool rd_test_evaluate   (struct renderer*);
+bool rd_get_test_mode   (struct glava_renderer*);
+bool rd_test_evaluate   (struct glava_renderer*);
 #endif
 
-struct renderer* rd_new            (const char**    paths,        const char* entry,
+struct glava_renderer* rd_new            (const char**    paths,        const char* entry,
                                     const char**    requests,     const char* force_backend,
                                     struct rd_bind* bindings,     int         stdin_type,
                                     bool            auto_desktop, bool        verbose,
                                     bool            test_mode);
-bool             rd_update         (struct renderer*, float* lb, float* rb,
+bool             rd_update         (struct glava_renderer*, float* lb, float* rb,
                                     size_t bsz, bool modified);
-void             rd_destroy        (struct renderer*);
-void             rd_time           (struct renderer*);
-void*            rd_get_impl_window(struct renderer*);
-struct gl_wcb*   rd_get_wcb        (struct renderer*);
+void             rd_destroy        (struct glava_renderer*);
+void             rd_time           (struct glava_renderer*);
+void*            rd_get_impl_window(struct glava_renderer*);
+struct gl_wcb*   rd_get_wcb        (struct glava_renderer*);
 
 /* gl_wcb - OpenGL Window Creation Backend interface */
 struct gl_wcb {
diff --git a/glava/xwin.c b/glava/xwin.c
index 5332a43..1b7bcd7 100644
--- a/glava/xwin.c
+++ b/glava/xwin.c
@@ -265,7 +265,7 @@ static Drawable get_drawable(Display* d, Window w) {
     return p;
 }
 
-unsigned int xwin_copyglbg(struct renderer* rd, unsigned int tex) {
+unsigned int xwin_copyglbg(struct glava_renderer* rd, unsigned int tex) {
     GLuint texture = (GLuint) tex;
     if (!texture)
         glGenTextures(1, &texture);
diff --git a/glava/xwin.h b/glava/xwin.h
index a79048c..ddce088 100644
--- a/glava/xwin.h
+++ b/glava/xwin.h
@@ -11,7 +11,7 @@ void xwin_wait_for_wm(void);
 bool xwin_settype(struct gl_wcb* wcb, void* impl, const char* type);
 void xwin_setdesktop(struct gl_wcb* wcb, void* impl, unsigned long desktop);
 void xwin_addstate(struct gl_wcb* wcb, void* impl, const char* state);
-unsigned int xwin_copyglbg(struct renderer* rd, unsigned int texture);
+unsigned int xwin_copyglbg(struct glava_renderer* rd, unsigned int texture);
 Window* xwin_get_desktop_layer(struct gl_wcb* wcb);
 const char* xwin_detect_wm(struct gl_wcb* wcb);