diff --git a/caca/caca.c b/caca/caca.c
index b3beb66..08400c7 100644
--- a/caca/caca.c
+++ b/caca/caca.c
@@ -30,7 +30,6 @@
 #include "caca_internals.h"
 
 static int caca_init_driver(caca_t *kk);
-static void caca_check_terminal(caca_t *kk);
 
 /** \brief Attach a caca graphical context to a cucul backend context.
  *
@@ -54,10 +53,7 @@ caca_t * caca_attach(cucul_t * qq)
         return NULL;
     }
 
-    /* Only needed for slang and ncurses */
-    caca_check_terminal(kk);
-
-    if(kk->driver.init_graphics(kk))
+    if(kk->drv.init_graphics(kk))
     {
         free(kk);
         return NULL;
@@ -102,7 +98,7 @@ caca_t * caca_attach(cucul_t * qq)
  */
 void caca_detach(caca_t *kk)
 {
-    kk->driver.end_graphics(kk);
+    kk->drv.end_graphics(kk);
     kk->qq->refcount--;
     free(kk);
 }
@@ -193,63 +189,3 @@ static int caca_init_driver(caca_t *kk)
     return -1;
 }
 
-static void caca_check_terminal(caca_t *kk)
-{
-#if defined(HAVE_GETENV) && defined(HAVE_PUTENV) && \
-     (defined(USE_SLANG) || defined(USE_NCURSES))
-    char *term, *colorterm, *other;
-#endif
-
-#if defined(USE_SLANG)
-    if(kk->driver.driver != CACA_DRIVER_SLANG)
-#endif
-#if defined(USE_NCURSES)
-    if(kk->driver.driver != CACA_DRIVER_NCURSES)
-#endif
-    return;
-
-#if defined(HAVE_GETENV) && defined(HAVE_PUTENV) && \
-     (defined(USE_SLANG) || defined(USE_NCURSES))
-    term = getenv("TERM");
-    colorterm = getenv("COLORTERM");
-
-    if(term && !strcmp(term, "xterm"))
-    {
-        /* If we are using gnome-terminal, it's really a 16 colour terminal */
-        if(colorterm && !strcmp(colorterm, "gnome-terminal"))
-        {
-#if defined(USE_NCURSES)
-            if(kk->driver.driver == CACA_DRIVER_NCURSES)
-            {
-                SCREEN *screen;
-                screen = newterm("xterm-16color", stdout, stdin);
-                if(screen == NULL)
-                    return;
-                endwin();
-            }
-#endif
-            (void)putenv("TERM=xterm-16color");
-            return;
-        }
-
-        /* Ditto if we are using Konsole */
-        other = getenv("KONSOLE_DCOP_SESSION");
-        if(other)
-        {
-#if defined(USE_NCURSES)
-            if(kk->driver.driver == CACA_DRIVER_NCURSES)
-            {
-                SCREEN *screen;
-                screen = newterm("xterm-16color", stdout, stdin);
-                if(screen == NULL)
-                    return;
-                endwin();
-            }
-#endif
-            (void)putenv("TERM=xterm-16color");
-            return;
-        }
-    }
-#endif
-}
-
diff --git a/caca/caca_internals.h b/caca/caca_internals.h
index 9c197b8..b288b4d 100644
--- a/caca/caca_internals.h
+++ b/caca/caca_internals.h
@@ -29,26 +29,6 @@ typedef unsigned short uint16_t;
 typedef unsigned int uint32_t;
 #endif
 
-#if defined(USE_CONIO)
-#   include <conio.h>
-#endif
-#if defined(USE_GL)
-#   include <GL/glut.h>
-#endif
-#if defined(USE_NCURSES)
-#   if defined(HAVE_NCURSES_H)
-#       include <ncurses.h>
-#   else
-#       include <curses.h>
-#   endif
-#endif
-#if defined(USE_WIN32)
-#   include <windows.h>
-#endif
-#if defined(USE_X11)
-#   include <X11/Xlib.h>
-#endif
-
 #if !defined(_DOXYGEN_SKIP_ME)
 #   define EVENTBUF_LEN 10
 #endif
@@ -108,9 +88,10 @@ struct caca_context
 {
     cucul_t *qq;
 
-    struct driver
+    struct drv
     {
         enum caca_driver driver;
+        struct driver_private *p;
 
         int (* init_graphics) (caca_t *);
         int (* end_graphics) (caca_t *);
@@ -120,7 +101,7 @@ struct caca_context
         void (* display) (caca_t *);
         void (* handle_resize) (caca_t *, unsigned int *, unsigned int *);
         unsigned int (* get_event) (caca_t *);
-    } driver;
+    } drv;
 
     //unsigned int width, height;
     unsigned int mouse_x, mouse_y;
@@ -145,71 +126,6 @@ struct caca_context
         unsigned int last_key;
 #endif
     } events;
-
-    /* FIXME: maybe this should go away */
-#if defined(USE_X11) && !defined(_DOXYGEN_SKIP_ME)
-    struct x11
-    {
-        Display *dpy;
-        Window window;
-        Pixmap pixmap;
-        GC gc;
-        long int event_mask;
-        int font_width, font_height;
-        unsigned int new_width, new_height;
-        int colors[16];
-        Font font;
-        XFontStruct *font_struct;
-        int font_offset;
-#if defined(HAVE_X11_XKBLIB_H)
-        Bool autorepeat;
-#endif
-    } x11;
-#endif
-#if defined(USE_NCURSES)
-    struct ncurses
-    {
-        int attr[16*16];
-        mmask_t oldmask;
-    } ncurses;
-#endif
-#if defined(USE_CONIO)
-    struct conio
-    {
-        struct text_info ti;
-        char *screen;
-    } conio;
-#endif
-#if defined(USE_WIN32)
-    struct win32
-    {
-        HANDLE hin, hout;
-        HANDLE front, back;
-        CHAR_INFO *buffer;
-        CONSOLE_CURSOR_INFO cci;
-    } win32;
-#endif
-#if defined(USE_GL)
-    struct gl
-    {
-        int window;
-        unsigned int width, height;
-        float font_width, font_height;
-        float incx, incy;
-        int id[94];
-        unsigned char resized, bit;
-        unsigned char mouse_changed, mouse_clicked;
-        unsigned int mouse_x, mouse_y;
-        unsigned int mouse_button, mouse_state;
-
-        unsigned char key;
-        int special_key;
-        int new_width;
-        int new_height;
-
-        float sw, sh;
-    } gl;
-#endif
 };
 
 /* Timer functions */
diff --git a/caca/driver_conio.c b/caca/driver_conio.c
index 90441c0..7342597 100644
--- a/caca/driver_conio.c
+++ b/caca/driver_conio.c
@@ -27,29 +27,39 @@
 #   include <pc.h>
 #endif
 
+#include <stdlib.h>
+
 #include "caca.h"
 #include "caca_internals.h"
 #include "cucul.h"
 #include "cucul_internals.h"
 
+struct driver_private
+{
+    struct text_info ti;
+    char *screen;
+};
+
 static int conio_init_graphics(caca_t *kk)
 {
+    kk->drv.p = malloc(sizeof(struct driver_private));
+
     _wscroll = 0;
     _setcursortype(_NOCURSOR);
     clrscr();
 
-    gettextinfo(&kk->conio.ti);
-    kk->conio.screen = malloc(2 * kk->conio.ti.screenwidth
-                                * kk->conio.ti.screenheight * sizeof(char));
-    if(kk->conio.screen == NULL)
+    gettextinfo(&kk->drv.p->ti);
+    kk->drv.p->screen = malloc(2 * kk->drv.p->ti.screenwidth
+                                 * kk->drv.p->ti.screenheight * sizeof(char));
+    if(kk->drv.p->screen == NULL)
         return -1;
 #   if defined(SCREENUPDATE_IN_PC_H)
-    ScreenRetrieve(kk->conio.screen);
+    ScreenRetrieve(kk->drv.p->screen);
 #   else
     /* FIXME */
 #   endif
-    cucul_set_size(kk->qq, kk->conio.ti.screenwidth,
-                           kk->conio.ti.screenheight);
+    cucul_set_size(kk->qq, kk->drv.p->ti.screenwidth,
+                           kk->drv.p->ti.screenheight);
     return 0;
 }
 
@@ -62,7 +72,8 @@ static int conio_end_graphics(caca_t *kk)
     cputs("\r\n");
     _setcursortype(_NORMALCURSOR);
 
-    free(kk->conio.screen);
+    free(kk->drv.p->screen);
+    free(kk->drv.p);
 
     return 0;
 }
@@ -87,7 +98,7 @@ static unsigned int conio_get_window_height(caca_t *kk)
 static void conio_display(caca_t *kk)
 {
     int n;
-    char *screen = kk->conio.screen;
+    char *screen = kk->drv.p->screen;
     uint8_t *attr = kk->qq->attr;
     uint32_t *chars = kk->qq->chars;
     for(n = kk->qq->height * kk->qq->width; n--; )
@@ -96,7 +107,7 @@ static void conio_display(caca_t *kk)
         *screen++ = *attr++;
     }
 #   if defined(SCREENUPDATE_IN_PC_H)
-    ScreenUpdate(kk->conio.screen);
+    ScreenUpdate(kk->drv.p->screen);
 #   else
     /* FIXME */
 #   endif
@@ -127,16 +138,16 @@ static unsigned int conio_get_event(caca_t *kk)
 
 void conio_init_driver(caca_t *kk)
 {
-    kk->driver.driver = CACA_DRIVER_CONIO;
-
-    kk->driver.init_graphics = conio_init_graphics;
-    kk->driver.end_graphics = conio_end_graphics;
-    kk->driver.set_window_title = conio_set_window_title;
-    kk->driver.get_window_width = conio_get_window_width;
-    kk->driver.get_window_height = conio_get_window_height;
-    kk->driver.display = conio_display;
-    kk->driver.handle_resize = conio_handle_resize;
-    kk->driver.get_event = conio_get_event;
+    kk->drv.driver = CACA_DRIVER_CONIO;
+
+    kk->drv.init_graphics = conio_init_graphics;
+    kk->drv.end_graphics = conio_end_graphics;
+    kk->drv.set_window_title = conio_set_window_title;
+    kk->drv.get_window_width = conio_get_window_width;
+    kk->drv.get_window_height = conio_get_window_height;
+    kk->drv.display = conio_display;
+    kk->drv.handle_resize = conio_handle_resize;
+    kk->drv.get_event = conio_get_event;
 }
 
 #endif /* USE_CONIO */
diff --git a/caca/driver_gl.c b/caca/driver_gl.c
index 74241f3..c556261 100644
--- a/caca/driver_gl.c
+++ b/caca/driver_gl.c
@@ -27,6 +27,7 @@
 
 #include <string.h>
 #include <stdlib.h>
+#include <stdio.h>
 
 #include "caca.h"
 #include "caca_internals.h"
@@ -70,6 +71,26 @@ static void gl_handle_reshape(int, int);
 static void gl_handle_mouse(int, int, int, int);
 static void gl_handle_mouse_motion(int, int);
 
+struct driver_private
+{
+    int window;
+    unsigned int width, height;
+    float font_width, font_height;
+    float incx, incy;
+    int id[94];
+    unsigned char resized, bit;
+    unsigned char mouse_changed, mouse_clicked;
+    unsigned int mouse_x, mouse_y;
+    unsigned int mouse_button, mouse_state;
+
+    unsigned char key;
+    int special_key;
+    int new_width;
+    int new_height;
+
+    float sw, sh;
+};
+
 static int gl_init_graphics(caca_t *kk)
 {
     char *empty_texture;
@@ -79,6 +100,8 @@ static int gl_init_graphics(caca_t *kk)
     int argc = 1;
     int i;
 
+    kk->drv.p = malloc(sizeof(struct driver_private));
+
     gl_kk = kk;
 
     geometry = getenv("CACA_GEOMETRY");
@@ -88,31 +111,31 @@ static int gl_init_graphics(caca_t *kk)
     if(width && height)
         cucul_set_size(kk->qq, width, height);
 
-    kk->gl.font_width = 9;
-    kk->gl.font_height = 15;
+    kk->drv.p->font_width = 9;
+    kk->drv.p->font_height = 15;
 
-    kk->gl.width = kk->qq->width * kk->gl.font_width;
-    kk->gl.height = kk->qq->height * kk->gl.font_height;
+    kk->drv.p->width = kk->qq->width * kk->drv.p->font_width;
+    kk->drv.p->height = kk->qq->height * kk->drv.p->font_height;
 
-    kk->gl.resized = 0;
-    kk->gl.bit = 0;
+    kk->drv.p->resized = 0;
+    kk->drv.p->bit = 0;
 
-    kk->gl.mouse_changed = kk->gl.mouse_clicked = 0;
-    kk->gl.mouse_button = kk->gl.mouse_state = 0;
+    kk->drv.p->mouse_changed = kk->drv.p->mouse_clicked = 0;
+    kk->drv.p->mouse_button = kk->drv.p->mouse_state = 0;
 
-    kk->gl.key = 0;
-    kk->gl.special_key = 0;
+    kk->drv.p->key = 0;
+    kk->drv.p->special_key = 0;
 
-    kk->gl.sw = 9.0f / 16.0f;
-    kk->gl.sh = 15.0f / 16.0f;
+    kk->drv.p->sw = 9.0f / 16.0f;
+    kk->drv.p->sh = 15.0f / 16.0f;
 
     glutInit(&argc, argv);
 
     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
-    glutInitWindowSize(kk->gl.width, kk->gl.height);
-    kk->gl.window = glutCreateWindow("caca for GL");
+    glutInitWindowSize(kk->drv.p->width, kk->drv.p->height);
+    kk->drv.p->window = glutCreateWindow("caca for GL");
 
-    gluOrtho2D(0, kk->gl.width, kk->gl.height, 0);
+    gluOrtho2D(0, kk->drv.p->width, kk->drv.p->height, 0);
 
     glDisable(GL_CULL_FACE);
     glDisable(GL_DEPTH_TEST);
@@ -130,7 +153,7 @@ static int gl_init_graphics(caca_t *kk)
     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
     glLoadIdentity();
-    gluOrtho2D(0, kk->gl.width, kk->gl.height, 0);
+    gluOrtho2D(0, kk->drv.p->width, kk->drv.p->height, 0);
 
     glMatrixMode(GL_MODELVIEW);
 
@@ -145,8 +168,8 @@ static int gl_init_graphics(caca_t *kk)
 
     for(i = 0; i < 94; i++)
     {
-        glGenTextures(1, (GLuint*)&kk->gl.id[i]);
-        glBindTexture(GL_TEXTURE_2D, kk->gl.id[i]);
+        glGenTextures(1, (GLuint*)&kk->drv.p->id[i]);
+        glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[i]);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
@@ -163,9 +186,9 @@ static int gl_init_graphics(caca_t *kk)
         glutBitmapCharacter(GLUT_BITMAP_9_BY_15, i + 32);
 
         glEnable(GL_TEXTURE_2D);
-        glBindTexture(GL_TEXTURE_2D, kk->gl.id[i]);
+        glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[i]);
         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
-                         0, kk->gl.height - 16, 16, 16, 0);
+                         0, kk->drv.p->height - 16, 16, 16, 0);
 
         glutMainLoopEvent();
         glutPostRedisplay();
@@ -176,7 +199,8 @@ static int gl_init_graphics(caca_t *kk)
 
 static int gl_end_graphics(caca_t *kk)
 {
-    glutDestroyWindow(kk->gl.window);
+    glutDestroyWindow(kk->drv.p->window);
+    free(kk->drv.p);
     return 0;
 }
 
@@ -188,12 +212,12 @@ static int gl_set_window_title(caca_t *kk, char const *title)
 
 static unsigned int gl_get_window_width(caca_t *kk)
 {
-    return kk->gl.width;
+    return kk->drv.p->width;
 }
 
 static unsigned int gl_get_window_height(caca_t *kk)
 {
-    return kk->gl.height;
+    return kk->drv.p->height;
 }
 
 static void gl_display(caca_t *kk)
@@ -203,19 +227,19 @@ static void gl_display(caca_t *kk)
     glClear(GL_COLOR_BUFFER_BIT);
 
     line = 0;
-    for(y = 0; y < kk->gl.height; y += kk->gl.font_height)
+    for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
     {
         uint8_t *attr = kk->qq->attr + line * kk->qq->width;
 
-        for(x = 0; x < kk->gl.width; x += kk->gl.font_width)
+        for(x = 0; x < kk->drv.p->width; x += kk->drv.p->font_width)
         {
             glDisable(GL_TEXTURE_2D);
             glColor4bv(gl_bgpal[attr[0] >> 4]);
             glBegin(GL_QUADS);
                 glVertex2f(x, y);
-                glVertex2f(x + kk->gl.font_width, y);
-                glVertex2f(x + kk->gl.font_width, y + kk->gl.font_height);
-                glVertex2f(x, y + kk->gl.font_height);
+                glVertex2f(x + kk->drv.p->font_width, y);
+                glVertex2f(x + kk->drv.p->font_width, y + kk->drv.p->font_height);
+                glVertex2f(x, y + kk->drv.p->font_height);
             glEnd();
 
             attr++;
@@ -230,29 +254,29 @@ static void gl_display(caca_t *kk)
     glBlendFunc(GL_ONE, GL_ONE);
 
     line = 0;
-    for(y = 0; y < kk->gl.height; y += kk->gl.font_height)
+    for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
     {
         uint8_t *attr = kk->qq->attr + line * kk->qq->width;
         uint32_t *chars = kk->qq->chars + line * kk->qq->width;
 
-        for(x = 0; x < kk->gl.width; x += kk->gl.font_width)
+        for(x = 0; x < kk->drv.p->width; x += kk->drv.p->font_width)
         {
             if(*chars != (uint32_t)' ')
             {
                 char ch = *chars & 0x7f;
 
                 /* FIXME: check ch bounds */
-                glBindTexture(GL_TEXTURE_2D, kk->gl.id[ch - 32]);
+                glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[ch - 32]);
                 glColor4bv(gl_bgpal[attr[0] & 0xf]);
                 glBegin(GL_QUADS);
-                    glTexCoord2f(0, kk->gl.sh);
+                    glTexCoord2f(0, kk->drv.p->sh);
                     glVertex2f(x, y);
-                    glTexCoord2f(kk->gl.sw, kk->gl.sh);
-                    glVertex2f(x + kk->gl.font_width, y);
-                    glTexCoord2f(kk->gl.sw, 0);
-                    glVertex2f(x + kk->gl.font_width, y + kk->gl.font_height);
+                    glTexCoord2f(kk->drv.p->sw, kk->drv.p->sh);
+                    glVertex2f(x + kk->drv.p->font_width, y);
+                    glTexCoord2f(kk->drv.p->sw, 0);
+                    glVertex2f(x + kk->drv.p->font_width, y + kk->drv.p->font_height);
                     glTexCoord2f(0, 0);
-                    glVertex2f(x, y + kk->gl.font_height);
+                    glVertex2f(x, y + kk->drv.p->font_height);
                 glEnd();
             }
 
@@ -272,18 +296,18 @@ static void gl_display(caca_t *kk)
 static void gl_handle_resize(caca_t *kk, unsigned int *new_width,
                                          unsigned int *new_height)
 {
-    kk->gl.width = kk->gl.new_width;
-    kk->gl.height = kk->gl.new_height;
+    kk->drv.p->width = kk->drv.p->new_width;
+    kk->drv.p->height = kk->drv.p->new_height;
 
-    *new_width = kk->gl.width / kk->gl.font_width;
-    *new_height = (kk->gl.height / kk->gl.font_height) + 1;
+    *new_width = kk->drv.p->width / kk->drv.p->font_width;
+    *new_height = (kk->drv.p->height / kk->drv.p->font_height) + 1;
 
     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
     glLoadIdentity();
 
-    glViewport(0, 0, kk->gl.width, kk->gl.height);
-    gluOrtho2D(0, kk->gl.width, kk->gl.height, 0);
+    glViewport(0, 0, kk->drv.p->width, kk->drv.p->height);
+    gluOrtho2D(0, kk->drv.p->width, kk->drv.p->height, 0);
     glMatrixMode(GL_MODELVIEW);
 }
 
@@ -293,56 +317,56 @@ static unsigned int gl_get_event(caca_t *kk)
 
     glutMainLoopEvent();
 
-    if(kk->gl.resized && !kk->resize)
+    if(kk->drv.p->resized && !kk->resize)
     {
         kk->resize = 1;
-        kk->gl.resized = 0;
+        kk->drv.p->resized = 0;
         return CACA_EVENT_RESIZE;
     }
 
-    if(kk->gl.mouse_changed)
+    if(kk->drv.p->mouse_changed)
     {
-        if(kk->gl.mouse_clicked)
+        if(kk->drv.p->mouse_clicked)
         {
-            event |= CACA_EVENT_MOUSE_PRESS | kk->gl.mouse_button;
-            kk->gl.mouse_clicked = 0;
+            event |= CACA_EVENT_MOUSE_PRESS | kk->drv.p->mouse_button;
+            kk->drv.p->mouse_clicked = 0;
         }
-        kk->mouse_x = kk->gl.mouse_x;
-        kk->mouse_y = kk->gl.mouse_y;
+        kk->mouse_x = kk->drv.p->mouse_x;
+        kk->mouse_y = kk->drv.p->mouse_y;
         event |= CACA_EVENT_MOUSE_MOTION | (kk->mouse_x << 12) | kk->mouse_y;
-        kk->gl.mouse_changed = 0;
+        kk->drv.p->mouse_changed = 0;
     }
 
-    if(kk->gl.key != 0)
+    if(kk->drv.p->key != 0)
     {
         event |= CACA_EVENT_KEY_PRESS;
-        event |= kk->gl.key;
-        kk->gl.key = 0;
+        event |= kk->drv.p->key;
+        kk->drv.p->key = 0;
         return event;
     }
 
-    if(kk->gl.special_key != 0)
+    if(kk->drv.p->special_key != 0)
     {
         event |= CACA_EVENT_KEY_PRESS;
 
-        switch(kk->gl.special_key)
+        switch(kk->drv.p->special_key)
         {
-            case GLUT_KEY_F1 : kk->gl.special_key = 0; return event | CACA_KEY_F1;
-            case GLUT_KEY_F2 : kk->gl.special_key = 0; return event | CACA_KEY_F2;
-            case GLUT_KEY_F3 : kk->gl.special_key = 0; return event | CACA_KEY_F3;
-            case GLUT_KEY_F4 : kk->gl.special_key = 0; return event | CACA_KEY_F4;
-            case GLUT_KEY_F5 : kk->gl.special_key = 0; return event | CACA_KEY_F5;
-            case GLUT_KEY_F6 : kk->gl.special_key = 0; return event | CACA_KEY_F6;
-            case GLUT_KEY_F7 : kk->gl.special_key = 0; return event | CACA_KEY_F7;
-            case GLUT_KEY_F8 : kk->gl.special_key = 0; return event | CACA_KEY_F8;
-            case GLUT_KEY_F9 : kk->gl.special_key = 0; return event | CACA_KEY_F9;
-            case GLUT_KEY_F10: kk->gl.special_key = 0; return event | CACA_KEY_F10;
-            case GLUT_KEY_F11: kk->gl.special_key = 0; return event | CACA_KEY_F11;
-            case GLUT_KEY_F12: kk->gl.special_key = 0; return event | CACA_KEY_F12;
-            case GLUT_KEY_LEFT : kk->gl.special_key = 0; return event | CACA_KEY_LEFT;
-            case GLUT_KEY_RIGHT: kk->gl.special_key = 0; return event | CACA_KEY_RIGHT;
-            case GLUT_KEY_UP   : kk->gl.special_key = 0; return event | CACA_KEY_UP;
-            case GLUT_KEY_DOWN : kk->gl.special_key = 0; return event | CACA_KEY_DOWN;
+            case GLUT_KEY_F1 : kk->drv.p->special_key = 0; return event | CACA_KEY_F1;
+            case GLUT_KEY_F2 : kk->drv.p->special_key = 0; return event | CACA_KEY_F2;
+            case GLUT_KEY_F3 : kk->drv.p->special_key = 0; return event | CACA_KEY_F3;
+            case GLUT_KEY_F4 : kk->drv.p->special_key = 0; return event | CACA_KEY_F4;
+            case GLUT_KEY_F5 : kk->drv.p->special_key = 0; return event | CACA_KEY_F5;
+            case GLUT_KEY_F6 : kk->drv.p->special_key = 0; return event | CACA_KEY_F6;
+            case GLUT_KEY_F7 : kk->drv.p->special_key = 0; return event | CACA_KEY_F7;
+            case GLUT_KEY_F8 : kk->drv.p->special_key = 0; return event | CACA_KEY_F8;
+            case GLUT_KEY_F9 : kk->drv.p->special_key = 0; return event | CACA_KEY_F9;
+            case GLUT_KEY_F10: kk->drv.p->special_key = 0; return event | CACA_KEY_F10;
+            case GLUT_KEY_F11: kk->drv.p->special_key = 0; return event | CACA_KEY_F11;
+            case GLUT_KEY_F12: kk->drv.p->special_key = 0; return event | CACA_KEY_F12;
+            case GLUT_KEY_LEFT : kk->drv.p->special_key = 0; return event | CACA_KEY_LEFT;
+            case GLUT_KEY_RIGHT: kk->drv.p->special_key = 0; return event | CACA_KEY_RIGHT;
+            case GLUT_KEY_UP   : kk->drv.p->special_key = 0; return event | CACA_KEY_UP;
+            case GLUT_KEY_DOWN : kk->drv.p->special_key = 0; return event | CACA_KEY_DOWN;
             default: return CACA_EVENT_NONE;
         }
     }
@@ -357,50 +381,50 @@ static void gl_handle_keyboard(unsigned char key, int x, int y)
 {
     caca_t *kk = gl_kk;
 
-    kk->gl.key = key;
+    kk->drv.p->key = key;
 }
 
 static void gl_handle_special_key(int key, int x, int y)
 {
     caca_t *kk = gl_kk;
 
-    kk->gl.special_key = key;
+    kk->drv.p->special_key = key;
 }
 
 static void gl_handle_reshape(int w, int h)
 {
     caca_t *kk = gl_kk;
 
-    if(kk->gl.bit) /* Do not handle reshaping at the first time */
+    if(kk->drv.p->bit) /* Do not handle reshaping at the first time */
     {
-        kk->gl.new_width = w;
-        kk->gl.new_height = h;
+        kk->drv.p->new_width = w;
+        kk->drv.p->new_height = h;
 
-        kk->gl.resized = 1;
+        kk->drv.p->resized = 1;
     }
     else
-        kk->gl.bit = 1;
+        kk->drv.p->bit = 1;
 }
 
 static void gl_handle_mouse(int button, int state, int x, int y)
 {
     caca_t *kk = gl_kk;
 
-    kk->gl.mouse_clicked = 1;
-    kk->gl.mouse_button = button;
-    kk->gl.mouse_state = state;
-    kk->gl.mouse_x = x / kk->gl.font_width;
-    kk->gl.mouse_y = y / kk->gl.font_height;
-    kk->gl.mouse_changed = 1;
+    kk->drv.p->mouse_clicked = 1;
+    kk->drv.p->mouse_button = button;
+    kk->drv.p->mouse_state = state;
+    kk->drv.p->mouse_x = x / kk->drv.p->font_width;
+    kk->drv.p->mouse_y = y / kk->drv.p->font_height;
+    kk->drv.p->mouse_changed = 1;
 }
 
 static void gl_handle_mouse_motion(int x, int y)
 {
     caca_t *kk = gl_kk;
 
-    kk->gl.mouse_x = x / kk->gl.font_width;
-    kk->gl.mouse_y = y / kk->gl.font_height;
-    kk->gl.mouse_changed = 1;
+    kk->drv.p->mouse_x = x / kk->drv.p->font_width;
+    kk->drv.p->mouse_y = y / kk->drv.p->font_height;
+    kk->drv.p->mouse_changed = 1;
 }
 
 /*
@@ -409,16 +433,16 @@ static void gl_handle_mouse_motion(int x, int y)
 
 void gl_init_driver(caca_t *kk)
 {
-    kk->driver.driver = CACA_DRIVER_GL;
-
-    kk->driver.init_graphics = gl_init_graphics;
-    kk->driver.end_graphics = gl_end_graphics;
-    kk->driver.set_window_title = gl_set_window_title;
-    kk->driver.get_window_width = gl_get_window_width;
-    kk->driver.get_window_height = gl_get_window_height;
-    kk->driver.display = gl_display;
-    kk->driver.handle_resize = gl_handle_resize;
-    kk->driver.get_event = gl_get_event;
+    kk->drv.driver = CACA_DRIVER_GL;
+
+    kk->drv.init_graphics = gl_init_graphics;
+    kk->drv.end_graphics = gl_end_graphics;
+    kk->drv.set_window_title = gl_set_window_title;
+    kk->drv.get_window_width = gl_get_window_width;
+    kk->drv.get_window_height = gl_get_window_height;
+    kk->drv.display = gl_display;
+    kk->drv.handle_resize = gl_handle_resize;
+    kk->drv.get_event = gl_get_event;
 }
 
 #endif /* USE_GL */
diff --git a/caca/driver_ncurses.c b/caca/driver_ncurses.c
index 22bfa1a..7c83c79 100644
--- a/caca/driver_ncurses.c
+++ b/caca/driver_ncurses.c
@@ -27,6 +27,9 @@
 #   include <curses.h>
 #endif
 
+#include <stdlib.h>
+#include <string.h>
+
 #if defined(HAVE_SIGNAL_H)
 #   include <signal.h>
 #endif
@@ -47,6 +50,15 @@
 static RETSIGTYPE sigwinch_handler(int);
 static caca_t *sigwinch_kk; /* FIXME: we ought to get rid of this */
 #endif
+#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
+static void ncurses_check_terminal(void);
+#endif
+
+struct driver_private
+{
+    int attr[16*16];
+    mmask_t oldmask;
+};
 
 static int ncurses_init_graphics(caca_t *kk)
 {
@@ -75,6 +87,12 @@ static int ncurses_init_graphics(caca_t *kk)
     mmask_t newmask;
     int fg, bg, max;
 
+    kk->drv.p = malloc(sizeof(struct driver_private));
+
+#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
+    ncurses_check_terminal();
+#endif
+
 #if defined(HAVE_SIGNAL)
     sigwinch_kk = kk;
     signal(SIGWINCH, sigwinch_handler);
@@ -90,7 +108,7 @@ static int ncurses_init_graphics(caca_t *kk)
 
     /* Activate mouse */
     newmask = REPORT_MOUSE_POSITION | ALL_MOUSE_EVENTS;
-    mousemask(newmask, &kk->ncurses.oldmask);
+    mousemask(newmask, &kk->drv.p->oldmask);
     mouseinterval(-1); /* No click emulation */
 
     /* Set the escape delay to a ridiculously low value */
@@ -115,17 +133,17 @@ static int ncurses_init_graphics(caca_t *kk)
              * colour pair to be redefined. */
             int col = ((max + 7 - fg) % max) + max * bg;
             init_pair(col, curses_colors[fg], curses_colors[bg]);
-            kk->ncurses.attr[fg + 16 * bg] = COLOR_PAIR(col);
+            kk->drv.p->attr[fg + 16 * bg] = COLOR_PAIR(col);
 
             if(max == 8)
             {
                 /* Bright fg on simple bg */
-                kk->ncurses.attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);
+                kk->drv.p->attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);
                 /* Simple fg on bright bg */
-                kk->ncurses.attr[fg + 16 * (bg + 8)] = A_BLINK
+                kk->drv.p->attr[fg + 16 * (bg + 8)] = A_BLINK
                                                     | COLOR_PAIR(col);
                 /* Bright fg on bright bg */
-                kk->ncurses.attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD
+                kk->drv.p->attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD
                                                         | COLOR_PAIR(col);
             }
         }
@@ -137,11 +155,13 @@ static int ncurses_init_graphics(caca_t *kk)
 
 static int ncurses_end_graphics(caca_t *kk)
 {
-    mousemask(kk->ncurses.oldmask, NULL);
+    mousemask(kk->drv.p->oldmask, NULL);
     curs_set(1);
     noraw();
     endwin();
 
+    free(kk->drv.p);
+
     return 0;
 }
 
@@ -172,7 +192,7 @@ static void ncurses_display(caca_t *kk)
         move(y, 0);
         for(x = kk->qq->width; x--; )
         {
-            attrset(kk->ncurses.attr[*attr++]);
+            attrset(kk->drv.p->attr[*attr++]);
             addch(*chars++ & 0x7f);
         }
     }
@@ -396,22 +416,60 @@ static RETSIGTYPE sigwinch_handler(int sig)
 }
 #endif
 
+#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
+static void ncurses_check_terminal(void)
+{
+    char *term, *colorterm, *other;
+
+    term = getenv("TERM");
+    colorterm = getenv("COLORTERM");
+
+    if(term && !strcmp(term, "xterm"))
+    {
+        /* If we are using gnome-terminal, it's really a 16 colour terminal */
+        if(colorterm && !strcmp(colorterm, "gnome-terminal"))
+        {
+            SCREEN *screen;
+            screen = newterm("xterm-16color", stdout, stdin);
+            if(screen == NULL)
+                return;
+            endwin();
+            (void)putenv("TERM=xterm-16color");
+            return;
+        }
+
+        /* Ditto if we are using Konsole */
+        other = getenv("KONSOLE_DCOP_SESSION");
+        if(other)
+        {
+            SCREEN *screen;
+            screen = newterm("xterm-16color", stdout, stdin);
+            if(screen == NULL)
+                return;
+            endwin();
+            (void)putenv("TERM=xterm-16color");
+            return;
+        }
+    }
+}
+#endif
+
 /*
  * Driver initialisation
  */
 
 void ncurses_init_driver(caca_t *kk)
 {
-    kk->driver.driver = CACA_DRIVER_NCURSES;
-
-    kk->driver.init_graphics = ncurses_init_graphics;
-    kk->driver.end_graphics = ncurses_end_graphics;
-    kk->driver.set_window_title = ncurses_set_window_title;
-    kk->driver.get_window_width = ncurses_get_window_width;
-    kk->driver.get_window_height = ncurses_get_window_height;
-    kk->driver.display = ncurses_display;
-    kk->driver.handle_resize = ncurses_handle_resize;
-    kk->driver.get_event = ncurses_get_event;
+    kk->drv.driver = CACA_DRIVER_NCURSES;
+
+    kk->drv.init_graphics = ncurses_init_graphics;
+    kk->drv.end_graphics = ncurses_end_graphics;
+    kk->drv.set_window_title = ncurses_set_window_title;
+    kk->drv.get_window_width = ncurses_get_window_width;
+    kk->drv.get_window_height = ncurses_get_window_height;
+    kk->drv.display = ncurses_display;
+    kk->drv.handle_resize = ncurses_handle_resize;
+    kk->drv.get_event = ncurses_get_event;
 }
 
 #endif /* USE_NCURSES */
diff --git a/caca/driver_slang.c b/caca/driver_slang.c
index 3196768..8453cc1 100644
--- a/caca/driver_slang.c
+++ b/caca/driver_slang.c
@@ -27,6 +27,9 @@
 #   include <slang.h>
 #endif
 
+#include <stdlib.h>
+#include <string.h>
+
 #if defined(HAVE_SIGNAL_H)
 #   include <signal.h>
 #endif
@@ -106,9 +109,16 @@ static void slang_init_palette(void);
 static RETSIGTYPE sigwinch_handler(int);
 static caca_t *sigwinch_kk; /* FIXME: we ought to get rid of this */
 #endif
+#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
+static void slang_check_terminal(void);
+#endif
 
 static int slang_init_graphics(caca_t *kk)
 {
+#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
+    slang_check_terminal();
+#endif
+
 #if defined(HAVE_SIGNAL)
     sigwinch_kk = kk;
     signal(SIGWINCH, sigwinch_handler);
@@ -375,22 +385,50 @@ static RETSIGTYPE sigwinch_handler(int sig)
 }
 #endif
 
+#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
+static void slang_check_terminal(void)
+{
+    char *term, *colorterm, *other;
+
+    term = getenv("TERM");
+    colorterm = getenv("COLORTERM");
+
+    if(term && !strcmp(term, "xterm"))
+    {
+        /* If we are using gnome-terminal, it's really a 16 colour terminal */
+        if(colorterm && !strcmp(colorterm, "gnome-terminal"))
+        {
+            (void)putenv("TERM=xterm-16color");
+            return;
+        }
+
+        /* Ditto if we are using Konsole */
+        other = getenv("KONSOLE_DCOP_SESSION");
+        if(other)
+        {
+            (void)putenv("TERM=xterm-16color");
+            return;
+        }
+    }
+}
+#endif
+
 /*
  * Driver initialisation
  */
 
 void slang_init_driver(caca_t *kk)
 {
-    kk->driver.driver = CACA_DRIVER_SLANG;
-
-    kk->driver.init_graphics = slang_init_graphics;
-    kk->driver.end_graphics = slang_end_graphics;
-    kk->driver.set_window_title = slang_set_window_title;
-    kk->driver.get_window_width = slang_get_window_width;
-    kk->driver.get_window_height = slang_get_window_height;
-    kk->driver.display = slang_display;
-    kk->driver.handle_resize = slang_handle_resize;
-    kk->driver.get_event = slang_get_event;
+    kk->drv.driver = CACA_DRIVER_SLANG;
+
+    kk->drv.init_graphics = slang_init_graphics;
+    kk->drv.end_graphics = slang_end_graphics;
+    kk->drv.set_window_title = slang_set_window_title;
+    kk->drv.get_window_width = slang_get_window_width;
+    kk->drv.get_window_height = slang_get_window_height;
+    kk->drv.display = slang_display;
+    kk->drv.handle_resize = slang_handle_resize;
+    kk->drv.get_event = slang_get_event;
 }
 
 #endif /* USE_SLANG */
diff --git a/caca/driver_win32.c b/caca/driver_win32.c
index 57f6cb5..e12599d 100644
--- a/caca/driver_win32.c
+++ b/caca/driver_win32.c
@@ -23,6 +23,8 @@
 
 #include <windows.h>
 
+#include <stdlib.h>
+
 #include "caca.h"
 #include "caca_internals.h"
 #include "cucul.h"
@@ -72,65 +74,75 @@ static int const win32_bg_palette[] =
     BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE
 };
 
+struct driver_private
+{
+    HANDLE hin, hout;
+    HANDLE front, back;
+    CHAR_INFO *buffer;
+    CONSOLE_CURSOR_INFO cci;
+};
+
 static int win32_init_graphics(caca_t *kk)
 {
     CONSOLE_SCREEN_BUFFER_INFO csbi;
     COORD size;
 
+    kk->drv.p = malloc(sizeof(struct driver_private));
+
     /* This call is allowed to fail in case we already have a console */
     AllocConsole();
 
-    kk->win32.hin = GetStdHandle(STD_INPUT_HANDLE);
-    kk->win32.hout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
-                                OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-    if(kk->win32.hout == INVALID_HANDLE_VALUE)
+    kk->drv.p->hin = GetStdHandle(STD_INPUT_HANDLE);
+    kk->drv.p->hout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
+                                 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if(kk->drv.p->hout == INVALID_HANDLE_VALUE)
         return -1;
 
-    GetConsoleCursorInfo(kk->win32.hout, &kk->win32.cci);
-    kk->win32.cci.bVisible = FALSE;
-    SetConsoleCursorInfo(kk->win32.hout, &kk->win32.cci);
+    GetConsoleCursorInfo(kk->drv.p->hout, &kk->drv.p->cci);
+    kk->drv.p->cci.bVisible = FALSE;
+    SetConsoleCursorInfo(kk->drv.p->hout, &kk->drv.p->cci);
 
-    SetConsoleMode(kk->win32.hout, ENABLE_MOUSE_INPUT);
+    SetConsoleMode(kk->drv.p->hout, ENABLE_MOUSE_INPUT);
 
-    kk->win32.front =
+    kk->drv.p->front =
         CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
                                   0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
-    if(!kk->win32.front || kk->win32.front == INVALID_HANDLE_VALUE)
+    if(!kk->drv.p->front || kk->drv.p->front == INVALID_HANDLE_VALUE)
         return -1;
 
-    kk->win32.back =
+    kk->drv.p->back =
         CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
                                   0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
-    if(!kk->win32.back || kk->win32.back == INVALID_HANDLE_VALUE)
+    if(!kk->drv.p->back || kk->drv.p->back == INVALID_HANDLE_VALUE)
         return -1;
 
-    if(!GetConsoleScreenBufferInfo(kk->win32.hout, &csbi))
+    if(!GetConsoleScreenBufferInfo(kk->drv.p->hout, &csbi))
         return -1;
 
     /* Sample code to get the biggest possible window */
-    //size = GetLargestConsoleWindowSize(kk->win32.hout);
+    //size = GetLargestConsoleWindowSize(kk->drv.p->hout);
     cucul_set_size(kk->qq, csbi.srWindow.Right - csbi.srWindow.Left + 1,
                            csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
     size.X = kk->qq->width;
     size.Y = kk->qq->height;
-    SetConsoleScreenBufferSize(kk->win32.front, size);
-    SetConsoleScreenBufferSize(kk->win32.back, size);
+    SetConsoleScreenBufferSize(kk->drv.p->front, size);
+    SetConsoleScreenBufferSize(kk->drv.p->back, size);
 
-    SetConsoleMode(kk->win32.front, 0);
-    SetConsoleMode(kk->win32.back, 0);
+    SetConsoleMode(kk->drv.p->front, 0);
+    SetConsoleMode(kk->drv.p->back, 0);
 
-    GetConsoleCursorInfo(kk->win32.front, &kk->win32.cci);
-    kk->win32.cci.dwSize = 0;
-    kk->win32.cci.bVisible = FALSE;
-    SetConsoleCursorInfo(kk->win32.front, &kk->win32.cci);
-    SetConsoleCursorInfo(kk->win32.back, &kk->win32.cci);
+    GetConsoleCursorInfo(kk->drv.p->front, &kk->drv.p->cci);
+    kk->drv.p->cci.dwSize = 0;
+    kk->drv.p->cci.bVisible = FALSE;
+    SetConsoleCursorInfo(kk->drv.p->front, &kk->drv.p->cci);
+    SetConsoleCursorInfo(kk->drv.p->back, &kk->drv.p->cci);
 
-    SetConsoleActiveScreenBuffer(kk->win32.front);
+    SetConsoleActiveScreenBuffer(kk->drv.p->front);
 
-    kk->win32.buffer = malloc(kk->qq->width * kk->qq->height
+    kk->drv.p->buffer = malloc(kk->qq->width * kk->qq->height
                                * sizeof(CHAR_INFO));
-    if(kk->win32.buffer == NULL)
+    if(kk->drv.p->buffer == NULL)
         return -1;
 
     return 0;
@@ -138,17 +150,19 @@ static int win32_init_graphics(caca_t *kk)
 
 static int win32_end_graphics(caca_t *kk)
 {
-    SetConsoleActiveScreenBuffer(kk->win32.hout);
-    CloseHandle(kk->win32.back);
-    CloseHandle(kk->win32.front);
+    SetConsoleActiveScreenBuffer(kk->drv.p->hout);
+    CloseHandle(kk->drv.p->back);
+    CloseHandle(kk->drv.p->front);
 
-    SetConsoleTextAttribute(kk->win32.hout, FOREGROUND_INTENSITY
+    SetConsoleTextAttribute(kk->drv.p->hout, FOREGROUND_INTENSITY
                                              | FOREGROUND_RED
                                              | FOREGROUND_GREEN
                                              | FOREGROUND_BLUE);
-    kk->win32.cci.bVisible = TRUE;
-    SetConsoleCursorInfo(kk->win32.hout, &kk->win32.cci);
-    CloseHandle(kk->win32.hout);
+    kk->drv.p->cci.bVisible = TRUE;
+    SetConsoleCursorInfo(kk->drv.p->hout, &kk->drv.p->cci);
+    CloseHandle(kk->drv.p->hout);
+
+    free(kk->drv.p);
 
     return 0;
 }
@@ -184,8 +198,8 @@ static void win32_display(caca_t *kk)
     /* Render everything to our back buffer */
     for(i = 0; i < kk->qq->width * kk->qq->height; i++)
     {
-        kk->win32.buffer[i].Char.AsciiChar = kk->qq->chars[i] & 0x7f;
-        kk->win32.buffer[i].Attributes =
+        kk->drv.p->buffer[i].Char.AsciiChar = kk->qq->chars[i] & 0x7f;
+        kk->drv.p->buffer[i].Attributes =
                 win32_fg_palette[kk->qq->attr[i] & 0xf]
                  | win32_bg_palette[kk->qq->attr[i] >> 4];
     }
@@ -197,7 +211,7 @@ static void win32_display(caca_t *kk)
     rect.Left = rect.Top = 0;
     rect.Right = kk->qq->width - 1;
     rect.Bottom = kk->qq->height - 1;
-    WriteConsoleOutput(kk->win32.front, kk->win32.buffer, size, pos, &rect);
+    WriteConsoleOutput(kk->drv.p->front, kk->drv.p->buffer, size, pos, &rect);
 }
 
 static void win32_handle_resize(caca_t *kk, unsigned int *new_width,
@@ -215,11 +229,11 @@ static unsigned int win32_get_event(caca_t *kk)
 
     for( ; ; )
     {
-        GetNumberOfConsoleInputEvents(kk->win32.hin, &num);
+        GetNumberOfConsoleInputEvents(kk->drv.p->hin, &num);
         if(num == 0)
             break;
 
-        ReadConsoleInput(kk->win32.hin, &rec, 1, &num);
+        ReadConsoleInput(kk->drv.p->hin, &rec, 1, &num);
         if(rec.EventType == KEY_EVENT)
         {
             unsigned int event;
@@ -288,16 +302,16 @@ static unsigned int win32_get_event(caca_t *kk)
 
 void win32_init_driver(caca_t *kk)
 {
-    kk->driver.driver = CACA_DRIVER_WIN32;
-
-    kk->driver.init_graphics = win32_init_graphics;
-    kk->driver.end_graphics = win32_end_graphics;
-    kk->driver.set_window_title = win32_set_window_title;
-    kk->driver.get_window_width = win32_get_window_width;
-    kk->driver.get_window_height = win32_get_window_height;
-    kk->driver.display = win32_display;
-    kk->driver.handle_resize = win32_handle_resize;
-    kk->driver.get_event = win32_get_event;
+    kk->drv.driver = CACA_DRIVER_WIN32;
+
+    kk->drv.init_graphics = win32_init_graphics;
+    kk->drv.end_graphics = win32_end_graphics;
+    kk->drv.set_window_title = win32_set_window_title;
+    kk->drv.get_window_width = win32_get_window_width;
+    kk->drv.get_window_height = win32_get_window_height;
+    kk->drv.display = win32_display;
+    kk->drv.handle_resize = win32_handle_resize;
+    kk->drv.get_event = win32_get_event;
 }
 
 #endif /* USE_WIN32 */
diff --git a/caca/driver_x11.c b/caca/driver_x11.c
index c2e3496..bc46333 100644
--- a/caca/driver_x11.c
+++ b/caca/driver_x11.c
@@ -41,6 +41,24 @@
  */
 static int x11_error_handler(Display *, XErrorEvent *);
 
+struct driver_private
+{
+    Display *dpy;
+    Window window;
+    Pixmap pixmap;
+    GC gc;
+    long int event_mask;
+    int font_width, font_height;
+    unsigned int new_width, new_height;
+    int colors[16];
+    Font font;
+    XFontStruct *font_struct;
+    int font_offset;
+#if defined(HAVE_X11_XKBLIB_H)
+    Bool autorepeat;
+#endif
+};
+
 static int x11_init_graphics(caca_t *kk)
 {
     static int const x11_palette[] =
@@ -73,6 +91,8 @@ static int x11_init_graphics(caca_t *kk)
     unsigned int width = 0, height = 0;
     int i;
 
+    kk->drv.p = malloc(sizeof(struct driver_private));
+
     geometry = getenv("CACA_GEOMETRY");
     if(geometry && *(geometry))
         sscanf(geometry, "%ux%u", &width, &height);
@@ -80,8 +100,8 @@ static int x11_init_graphics(caca_t *kk)
     if(width && height)
         cucul_set_size(kk->qq, width, height);
 
-    kk->x11.dpy = XOpenDisplay(NULL);
-    if(kk->x11.dpy == NULL)
+    kk->drv.p->dpy = XOpenDisplay(NULL);
+    if(kk->drv.p->dpy == NULL)
         return -1;
 
     fonts[0] = getenv("CACA_FONT");
@@ -99,18 +119,18 @@ static int x11_init_graphics(caca_t *kk)
         if(!*parser)
         {
             XSetErrorHandler(old_error_handler);
-            XCloseDisplay(kk->x11.dpy);
+            XCloseDisplay(kk->drv.p->dpy);
             return -1;
         }
 
-        kk->x11.font = XLoadFont(kk->x11.dpy, *parser);
-        if(!kk->x11.font)
+        kk->drv.p->font = XLoadFont(kk->drv.p->dpy, *parser);
+        if(!kk->drv.p->font)
             continue;
 
-        kk->x11.font_struct = XQueryFont(kk->x11.dpy, kk->x11.font);
-        if(!kk->x11.font_struct)
+        kk->drv.p->font_struct = XQueryFont(kk->drv.p->dpy, kk->drv.p->font);
+        if(!kk->drv.p->font_struct)
         {
-            XUnloadFont(kk->x11.dpy, kk->x11.font);
+            XUnloadFont(kk->drv.p->dpy, kk->drv.p->font);
             continue;
         }
 
@@ -120,108 +140,110 @@ static int x11_init_graphics(caca_t *kk)
     /* Reset the default X11 error handler */
     XSetErrorHandler(old_error_handler);
 
-    kk->x11.font_width = kk->x11.font_struct->max_bounds.width;
-    kk->x11.font_height = kk->x11.font_struct->max_bounds.ascent
-                         + kk->x11.font_struct->max_bounds.descent;
-    kk->x11.font_offset = kk->x11.font_struct->max_bounds.descent;
+    kk->drv.p->font_width = kk->drv.p->font_struct->max_bounds.width;
+    kk->drv.p->font_height = kk->drv.p->font_struct->max_bounds.ascent
+                         + kk->drv.p->font_struct->max_bounds.descent;
+    kk->drv.p->font_offset = kk->drv.p->font_struct->max_bounds.descent;
 
-    colormap = DefaultColormap(kk->x11.dpy, DefaultScreen(kk->x11.dpy));
+    colormap = DefaultColormap(kk->drv.p->dpy, DefaultScreen(kk->drv.p->dpy));
     for(i = 0; i < 16; i++)
     {
         XColor color;
         color.red = x11_palette[i * 3];
         color.green = x11_palette[i * 3 + 1];
         color.blue = x11_palette[i * 3 + 2];
-        XAllocColor(kk->x11.dpy, colormap, &color);
-        kk->x11.colors[i] = color.pixel;
+        XAllocColor(kk->drv.p->dpy, colormap, &color);
+        kk->drv.p->colors[i] = color.pixel;
     }
 
     x11_winattr.backing_store = Always;
-    x11_winattr.background_pixel = kk->x11.colors[0];
+    x11_winattr.background_pixel = kk->drv.p->colors[0];
     x11_winattr.event_mask = ExposureMask | StructureNotifyMask;
 
-    kk->x11.window =
-        XCreateWindow(kk->x11.dpy, DefaultRootWindow(kk->x11.dpy), 0, 0,
-                      kk->qq->width * kk->x11.font_width,
-                      kk->qq->height * kk->x11.font_height,
+    kk->drv.p->window =
+        XCreateWindow(kk->drv.p->dpy, DefaultRootWindow(kk->drv.p->dpy), 0, 0,
+                      kk->qq->width * kk->drv.p->font_width,
+                      kk->qq->height * kk->drv.p->font_height,
                       0, 0, InputOutput, 0,
                       CWBackingStore | CWBackPixel | CWEventMask,
                       &x11_winattr);
 
-    XStoreName(kk->x11.dpy, kk->x11.window, "caca for X");
+    XStoreName(kk->drv.p->dpy, kk->drv.p->window, "caca for X");
 
-    XSelectInput(kk->x11.dpy, kk->x11.window, StructureNotifyMask);
-    XMapWindow(kk->x11.dpy, kk->x11.window);
+    XSelectInput(kk->drv.p->dpy, kk->drv.p->window, StructureNotifyMask);
+    XMapWindow(kk->drv.p->dpy, kk->drv.p->window);
 
-    kk->x11.gc = XCreateGC(kk->x11.dpy, kk->x11.window, 0, NULL);
-    XSetForeground(kk->x11.dpy, kk->x11.gc, kk->x11.colors[15]);
-    XSetFont(kk->x11.dpy, kk->x11.gc, kk->x11.font);
+    kk->drv.p->gc = XCreateGC(kk->drv.p->dpy, kk->drv.p->window, 0, NULL);
+    XSetForeground(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->colors[15]);
+    XSetFont(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->font);
 
     for(;;)
     {
         XEvent xevent;
-        XNextEvent(kk->x11.dpy, &xevent);
+        XNextEvent(kk->drv.p->dpy, &xevent);
         if (xevent.type == MapNotify)
             break;
     }
 
 #if defined(HAVE_X11_XKBLIB_H)
     /* Disable autorepeat */
-    XkbSetDetectableAutoRepeat(kk->x11.dpy, True, &kk->x11.autorepeat);
-    if(!kk->x11.autorepeat)
-        XAutoRepeatOff(kk->x11.dpy);
+    XkbSetDetectableAutoRepeat(kk->drv.p->dpy, True, &kk->drv.p->autorepeat);
+    if(!kk->drv.p->autorepeat)
+        XAutoRepeatOff(kk->drv.p->dpy);
 #endif
 
-    kk->x11.event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask
+    kk->drv.p->event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask
           | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask
           | ExposureMask;
 
-    XSelectInput(kk->x11.dpy, kk->x11.window, kk->x11.event_mask);
+    XSelectInput(kk->drv.p->dpy, kk->drv.p->window, kk->drv.p->event_mask);
 
-    XSync(kk->x11.dpy, False);
+    XSync(kk->drv.p->dpy, False);
 
-    kk->x11.pixmap = XCreatePixmap(kk->x11.dpy, kk->x11.window,
-                                   kk->qq->width * kk->x11.font_width,
-                                   kk->qq->height * kk->x11.font_height,
-                                   DefaultDepth(kk->x11.dpy,
-                                            DefaultScreen(kk->x11.dpy)));
+    kk->drv.p->pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,
+                                   kk->qq->width * kk->drv.p->font_width,
+                                   kk->qq->height * kk->drv.p->font_height,
+                                   DefaultDepth(kk->drv.p->dpy,
+                                            DefaultScreen(kk->drv.p->dpy)));
 
-    kk->x11.new_width = kk->x11.new_height = 0;
+    kk->drv.p->new_width = kk->drv.p->new_height = 0;
 
     return 0;
 }
 
 static int x11_end_graphics(caca_t *kk)
 {
-    XSync(kk->x11.dpy, False);
+    XSync(kk->drv.p->dpy, False);
 #if defined(HAVE_X11_XKBLIB_H)
-    if(!kk->x11.autorepeat)
-        XAutoRepeatOn(kk->x11.dpy);
+    if(!kk->drv.p->autorepeat)
+        XAutoRepeatOn(kk->drv.p->dpy);
 #endif
-    XFreePixmap(kk->x11.dpy, kk->x11.pixmap);
-    XFreeFont(kk->x11.dpy, kk->x11.font_struct);
-    XFreeGC(kk->x11.dpy, kk->x11.gc);
-    XUnmapWindow(kk->x11.dpy, kk->x11.window);
-    XDestroyWindow(kk->x11.dpy, kk->x11.window);
-    XCloseDisplay(kk->x11.dpy);
+    XFreePixmap(kk->drv.p->dpy, kk->drv.p->pixmap);
+    XFreeFont(kk->drv.p->dpy, kk->drv.p->font_struct);
+    XFreeGC(kk->drv.p->dpy, kk->drv.p->gc);
+    XUnmapWindow(kk->drv.p->dpy, kk->drv.p->window);
+    XDestroyWindow(kk->drv.p->dpy, kk->drv.p->window);
+    XCloseDisplay(kk->drv.p->dpy);
+
+    free(kk->drv.p);
 
     return 0;
 }
 
 static int x11_set_window_title(caca_t *kk, char const *title)
 {
-    XStoreName(kk->x11.dpy, kk->x11.window, title);
+    XStoreName(kk->drv.p->dpy, kk->drv.p->window, title);
     return 0;
 }
 
 static unsigned int x11_get_window_width(caca_t *kk)
 {
-    return kk->qq->width * kk->x11.font_width;
+    return kk->qq->width * kk->drv.p->font_width;
 }
 
 static unsigned int x11_get_window_height(caca_t *kk)
 {
-    return kk->qq->height * kk->x11.font_height;
+    return kk->qq->height * kk->drv.p->font_height;
 }
 
 static void x11_display(caca_t *kk)
@@ -241,11 +263,11 @@ static void x11_display(caca_t *kk)
                    && (attr[len] >> 4) == (attr[0] >> 4))
                 len++;
 
-            XSetForeground(kk->x11.dpy, kk->x11.gc,
-                           kk->x11.colors[attr[0] >> 4]);
-            XFillRectangle(kk->x11.dpy, kk->x11.pixmap, kk->x11.gc,
-                           x * kk->x11.font_width, y * kk->x11.font_height,
-                           len * kk->x11.font_width, kk->x11.font_height);
+            XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,
+                           kk->drv.p->colors[attr[0] >> 4]);
+            XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->gc,
+                           x * kk->drv.p->font_width, y * kk->drv.p->font_height,
+                           len * kk->drv.p->font_width, kk->drv.p->font_height);
         }
     }
 
@@ -273,19 +295,19 @@ static void x11_display(caca_t *kk)
                 len++;
             }
 
-            XSetForeground(kk->x11.dpy, kk->x11.gc, kk->x11.colors[attr[0] & 0xf]);
-            XDrawString(kk->x11.dpy, kk->x11.pixmap, kk->x11.gc,
-                        x * kk->x11.font_width,
-                        (y + 1) * kk->x11.font_height - kk->x11.font_offset,
+            XSetForeground(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->colors[attr[0] & 0xf]);
+            XDrawString(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->gc,
+                        x * kk->drv.p->font_width,
+                        (y + 1) * kk->drv.p->font_height - kk->drv.p->font_offset,
                         buffer, len);
         }
     }
 
-    XCopyArea(kk->x11.dpy, kk->x11.pixmap, kk->x11.window, kk->x11.gc, 0, 0,
-              kk->qq->width * kk->x11.font_width,
-              kk->qq->height * kk->x11.font_height,
+    XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->window, kk->drv.p->gc, 0, 0,
+              kk->qq->width * kk->drv.p->font_width,
+              kk->qq->height * kk->drv.p->font_height,
               0, 0);
-    XFlush(kk->x11.dpy);
+    XFlush(kk->drv.p->dpy);
 }
 
 static void x11_handle_resize(caca_t *kk, unsigned int *new_width,
@@ -293,19 +315,19 @@ static void x11_handle_resize(caca_t *kk, unsigned int *new_width,
 {
     Pixmap new_pixmap;
 
-    *new_width = kk->x11.new_width;
-    *new_height = kk->x11.new_height;
-
-    new_pixmap = XCreatePixmap(kk->x11.dpy, kk->x11.window,
-                               kk->qq->width * kk->x11.font_width,
-                               kk->qq->height * kk->x11.font_height,
-                               DefaultDepth(kk->x11.dpy,
-                                            DefaultScreen(kk->x11.dpy)));
-    XCopyArea(kk->x11.dpy, kk->x11.pixmap, new_pixmap, kk->x11.gc, 0, 0,
-              kk->qq->width * kk->x11.font_width,
-              kk->qq->height * kk->x11.font_height, 0, 0);
-    XFreePixmap(kk->x11.dpy, kk->x11.pixmap);
-    kk->x11.pixmap = new_pixmap;
+    *new_width = kk->drv.p->new_width;
+    *new_height = kk->drv.p->new_height;
+
+    new_pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,
+                               kk->qq->width * kk->drv.p->font_width,
+                               kk->qq->height * kk->drv.p->font_height,
+                               DefaultDepth(kk->drv.p->dpy,
+                                            DefaultScreen(kk->drv.p->dpy)));
+    XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, new_pixmap, kk->drv.p->gc, 0, 0,
+              kk->qq->width * kk->drv.p->font_width,
+              kk->qq->height * kk->drv.p->font_height, 0, 0);
+    XFreePixmap(kk->drv.p->dpy, kk->drv.p->pixmap);
+    kk->drv.p->pixmap = new_pixmap;
 }
 
 static unsigned int x11_get_event(caca_t *kk)
@@ -314,18 +336,18 @@ static unsigned int x11_get_event(caca_t *kk)
     XEvent xevent;
     char key;
 
-    while(XCheckWindowEvent(kk->x11.dpy, kk->x11.window,
-                            kk->x11.event_mask, &xevent) == True)
+    while(XCheckWindowEvent(kk->drv.p->dpy, kk->drv.p->window,
+                            kk->drv.p->event_mask, &xevent) == True)
     {
         KeySym keysym;
 
         /* Expose event */
         if(xevent.type == Expose)
         {
-            XCopyArea(kk->x11.dpy, kk->x11.pixmap,
-                      kk->x11.window, kk->x11.gc, 0, 0,
-                      kk->qq->width * kk->x11.font_width,
-                      kk->qq->height * kk->x11.font_height, 0, 0);
+            XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap,
+                      kk->drv.p->window, kk->drv.p->gc, 0, 0,
+                      kk->qq->width * kk->drv.p->font_width,
+                      kk->qq->height * kk->drv.p->font_height, 0, 0);
             continue;
         }
 
@@ -334,16 +356,16 @@ static unsigned int x11_get_event(caca_t *kk)
         {
             unsigned int w, h;
 
-            w = (xevent.xconfigure.width + kk->x11.font_width / 3)
-                  / kk->x11.font_width;
-            h = (xevent.xconfigure.height + kk->x11.font_height / 3)
-                  / kk->x11.font_height;
+            w = (xevent.xconfigure.width + kk->drv.p->font_width / 3)
+                  / kk->drv.p->font_width;
+            h = (xevent.xconfigure.height + kk->drv.p->font_height / 3)
+                  / kk->drv.p->font_height;
 
             if(!w || !h || (w == kk->qq->width && h == kk->qq->height))
                 continue;
 
-            kk->x11.new_width = w;
-            kk->x11.new_height = h;
+            kk->drv.p->new_width = w;
+            kk->drv.p->new_height = h;
 
             /* If we are already resizing, ignore the new signal */
             if(kk->resize)
@@ -357,8 +379,8 @@ static unsigned int x11_get_event(caca_t *kk)
         /* Check for mouse motion events */
         if(xevent.type == MotionNotify)
         {
-            unsigned int newx = xevent.xmotion.x / kk->x11.font_width;
-            unsigned int newy = xevent.xmotion.y / kk->x11.font_height;
+            unsigned int newx = xevent.xmotion.x / kk->drv.p->font_width;
+            unsigned int newy = xevent.xmotion.y / kk->drv.p->font_height;
 
             if(newx >= kk->qq->width)
                 newx = kk->qq->width - 1;
@@ -394,7 +416,7 @@ static unsigned int x11_get_event(caca_t *kk)
         if(XLookupString(&xevent.xkey, &key, 1, NULL, NULL))
             return event | key;
 
-        keysym = XKeycodeToKeysym(kk->x11.dpy, xevent.xkey.keycode, 0);
+        keysym = XKeycodeToKeysym(kk->drv.p->dpy, xevent.xkey.keycode, 0);
         switch(keysym)
         {
         case XK_F1:    return event | CACA_KEY_F1;
@@ -439,16 +461,16 @@ static int x11_error_handler(Display *dpy, XErrorEvent *xevent)
 
 void x11_init_driver(caca_t *kk)
 {
-    kk->driver.driver = CACA_DRIVER_X11;
-
-    kk->driver.init_graphics = x11_init_graphics;
-    kk->driver.end_graphics = x11_end_graphics;
-    kk->driver.set_window_title = x11_set_window_title;
-    kk->driver.get_window_width = x11_get_window_width;
-    kk->driver.get_window_height = x11_get_window_height;
-    kk->driver.display = x11_display;
-    kk->driver.handle_resize = x11_handle_resize;
-    kk->driver.get_event = x11_get_event;
+    kk->drv.driver = CACA_DRIVER_X11;
+
+    kk->drv.init_graphics = x11_init_graphics;
+    kk->drv.end_graphics = x11_end_graphics;
+    kk->drv.set_window_title = x11_set_window_title;
+    kk->drv.get_window_width = x11_get_window_width;
+    kk->drv.get_window_height = x11_get_window_height;
+    kk->drv.display = x11_display;
+    kk->drv.handle_resize = x11_handle_resize;
+    kk->drv.get_event = x11_get_event;
 }
 
 #endif /* USE_X11 */
diff --git a/caca/event.c b/caca/event.c
index ea5820e..5fe655b 100644
--- a/caca/event.c
+++ b/caca/event.c
@@ -140,10 +140,10 @@ static unsigned int _get_next_event(caca_t *kk)
     event = _lowlevel_event(kk);
 
 #if defined(USE_SLANG)
-    if(kk->driver.driver != CACA_DRIVER_SLANG)
+    if(kk->drv.driver != CACA_DRIVER_SLANG)
 #endif
 #if defined(USE_NCURSES)
-    if(kk->driver.driver != CACA_DRIVER_NCURSES)
+    if(kk->drv.driver != CACA_DRIVER_NCURSES)
 #endif
     return event;
 
@@ -205,7 +205,7 @@ static unsigned int _lowlevel_event(caca_t *kk)
         return event;
 #endif
 
-    return kk->driver.get_event(kk);
+    return kk->drv.get_event(kk);
 }
 
 #if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
diff --git a/caca/graphics.c b/caca/graphics.c
index 2f56db8..af3b7b6 100644
--- a/caca/graphics.c
+++ b/caca/graphics.c
@@ -47,7 +47,7 @@ static void caca_handle_resize(caca_t *kk);
  */
 int caca_set_window_title(caca_t *kk, char const *title)
 {
-    return kk->driver.set_window_title(kk, title);
+    return kk->drv.set_window_title(kk, title);
 }
 
 /** \brief Get the window width.
@@ -61,7 +61,7 @@ int caca_set_window_title(caca_t *kk, char const *title)
  */
 unsigned int caca_get_window_width(caca_t *kk)
 {
-    return kk->driver.get_window_width(kk);
+    return kk->drv.get_window_width(kk);
 }
 
 /** \brief Get the window height.
@@ -75,7 +75,7 @@ unsigned int caca_get_window_width(caca_t *kk)
  */
 unsigned int caca_get_window_height(caca_t *kk)
 {
-    return kk->driver.get_window_height(kk);
+    return kk->drv.get_window_height(kk);
 }
 
 /** \brief Set the refresh delay.
@@ -128,7 +128,7 @@ void caca_display(caca_t *kk)
 #endif
     int ticks = kk->lastticks + _caca_getticks(&kk->timer);
 
-    kk->driver.display(kk);
+    kk->drv.display(kk);
 
     /* FIXME handle this somewhere else */
     if(kk->resize)
@@ -164,7 +164,7 @@ static void caca_handle_resize(caca_t *kk)
 {
     unsigned int new_width, new_height;
 
-    kk->driver.handle_resize(kk, &new_width, &new_height);
+    kk->drv.handle_resize(kk, &new_width, &new_height);
 
     /* Tell libcucul we changed size */
     if(new_width != kk->qq->width || new_height != kk->qq->height)