diff --git a/Android.bp b/Android.bp
index 33d3b75..2a97539 100644
--- a/Android.bp
+++ b/Android.bp
@@ -4,14 +4,15 @@
     export_include_dirs: ["include"],
 
     srcs: [
-        "src/input.c",
-        "src/vterm.c",
         "src/encoding.c",
+        "src/input.c",
+        "src/keyboard.c",
         "src/parser.c",
-        "src/unicode.c",
         "src/pen.c",
         "src/screen.c",
         "src/state.c",
+        "src/unicode.c",
+        "src/vterm.c",
     ],
 
     cflags: [
diff --git a/include/vterm.h b/include/vterm.h
index d43add7..51dc970 100644
--- a/include/vterm.h
+++ b/include/vterm.h
@@ -7,8 +7,9 @@
 
 #include <stdint.h>
 #include <stdlib.h>
+#include <stdbool.h>
 
-#include "vterm_input.h"
+#include "vterm_keycodes.h"
 
 typedef struct VTerm VTerm;
 typedef struct VTermState VTermState;
@@ -48,16 +49,160 @@
   rect->start_col += col_delta; rect->end_col += col_delta;
 }
 
-typedef struct {
-  uint8_t red, green, blue;
+/**
+ * Bit-field describing the content of the tagged union `VTermColor`.
+ */
+typedef enum {
+  /**
+   * If the lower bit of `type` is not set, the colour is 24-bit RGB.
+   */
+  VTERM_COLOR_RGB = 0x00,
+
+  /**
+   * The colour is an index into a palette of 256 colours.
+   */
+  VTERM_COLOR_INDEXED = 0x01,
+
+  /**
+   * Mask that can be used to extract the RGB/Indexed bit.
+   */
+  VTERM_COLOR_TYPE_MASK = 0x01,
+
+  /**
+   * If set, indicates that this colour should be the default foreground
+   * color, i.e. there was no SGR request for another colour. When
+   * rendering this colour it is possible to ignore "idx" and just use a
+   * colour that is not in the palette.
+   */
+  VTERM_COLOR_DEFAULT_FG = 0x02,
+
+  /**
+   * If set, indicates that this colour should be the default background
+   * color, i.e. there was no SGR request for another colour. A common
+   * option when rendering this colour is to not render a background at
+   * all, for example by rendering the window transparently at this spot.
+   */
+  VTERM_COLOR_DEFAULT_BG = 0x04,
+
+  /**
+   * Mask that can be used to extract the default foreground/background bit.
+   */
+  VTERM_COLOR_DEFAULT_MASK = 0x06
+} VTermColorType;
+
+/**
+ * Returns true if the VTERM_COLOR_RGB `type` flag is set, indicating that the
+ * given VTermColor instance is an indexed colour.
+ */
+#define VTERM_COLOR_IS_INDEXED(col) \
+  (((col)->type & VTERM_COLOR_TYPE_MASK) == VTERM_COLOR_INDEXED)
+
+/**
+ * Returns true if the VTERM_COLOR_INDEXED `type` flag is set, indicating that
+ * the given VTermColor instance is an rgb colour.
+ */
+#define VTERM_COLOR_IS_RGB(col) \
+  (((col)->type & VTERM_COLOR_TYPE_MASK) == VTERM_COLOR_RGB)
+
+/**
+ * Returns true if the VTERM_COLOR_DEFAULT_FG `type` flag is set, indicating
+ * that the given VTermColor instance corresponds to the default foreground
+ * color.
+ */
+#define VTERM_COLOR_IS_DEFAULT_FG(col) \
+  (!!((col)->type & VTERM_COLOR_DEFAULT_FG))
+
+/**
+ * Returns true if the VTERM_COLOR_DEFAULT_BG `type` flag is set, indicating
+ * that the given VTermColor instance corresponds to the default background
+ * color.
+ */
+#define VTERM_COLOR_IS_DEFAULT_BG(col) \
+  (!!((col)->type & VTERM_COLOR_DEFAULT_BG))
+
+/**
+ * Tagged union storing either an RGB color or an index into a colour palette.
+ * In order to convert indexed colours to RGB, you may use the
+ * vterm_state_convert_color_to_rgb() or vterm_screen_convert_color_to_rgb()
+ * functions which lookup the RGB colour from the palette maintained by a
+ * VTermState or VTermScreen instance.
+ */
+typedef union {
+  /**
+   * Tag indicating which union member is actually valid. This variable
+   * coincides with the `type` member of the `rgb` and the `indexed` struct
+   * in memory. Please use the `VTERM_COLOR_IS_*` test macros to check whether
+   * a particular type flag is set.
+   */
+  uint8_t type;
+
+  /**
+   * Valid if `VTERM_COLOR_IS_RGB(type)` is true. Holds the RGB colour values.
+   */
+  struct {
+    /**
+     * Same as the top-level `type` member stored in VTermColor.
+     */
+    uint8_t type;
+
+    /**
+     * The actual 8-bit red, green, blue colour values.
+     */
+    uint8_t red, green, blue;
+  } rgb;
+
+  /**
+   * If `VTERM_COLOR_IS_INDEXED(type)` is true, this member holds the index into
+   * the colour palette.
+   */
+  struct {
+    /**
+     * Same as the top-level `type` member stored in VTermColor.
+     */
+    uint8_t type;
+
+    /**
+     * Index into the colour map.
+     */
+    uint8_t idx;
+  } indexed;
 } VTermColor;
 
+/**
+ * Constructs a new VTermColor instance representing the given RGB values.
+ */
+static inline void vterm_color_rgb(VTermColor *col, uint8_t red, uint8_t green,
+                                   uint8_t blue)
+{
+  col->type = VTERM_COLOR_RGB;
+  col->rgb.red   = red;
+  col->rgb.green = green;
+  col->rgb.blue  = blue;
+}
+
+/**
+ * Construct a new VTermColor instance representing an indexed color with the
+ * given index.
+ */
+static inline void vterm_color_indexed(VTermColor *col, uint8_t idx)
+{
+  col->type = VTERM_COLOR_INDEXED;
+  col->indexed.idx = idx;
+}
+
+/**
+ * Compares two colours. Returns true if the colors are equal, false otherwise.
+ */
+int vterm_color_is_equal(const VTermColor *a, const VTermColor *b);
+
 typedef enum {
   /* VTERM_VALUETYPE_NONE = 0 */
   VTERM_VALUETYPE_BOOL = 1,
   VTERM_VALUETYPE_INT,
   VTERM_VALUETYPE_STRING,
   VTERM_VALUETYPE_COLOR,
+
+  VTERM_N_VALUETYPES
 } VTermValueType;
 
 typedef union {
@@ -78,6 +223,8 @@
   VTERM_ATTR_FONT,       // number: 10-19
   VTERM_ATTR_FOREGROUND, // color:  30-39 90-97
   VTERM_ATTR_BACKGROUND, // color:  40-49 100-107
+
+  VTERM_N_ATTRS
 } VTermAttr;
 
 typedef enum {
@@ -89,15 +236,27 @@
   VTERM_PROP_ICONNAME,          // string
   VTERM_PROP_REVERSE,           // bool
   VTERM_PROP_CURSORSHAPE,       // number
+  VTERM_PROP_MOUSE,             // number
+
+  VTERM_N_PROPS
 } VTermProp;
 
 enum {
   VTERM_PROP_CURSORSHAPE_BLOCK = 1,
   VTERM_PROP_CURSORSHAPE_UNDERLINE,
   VTERM_PROP_CURSORSHAPE_BAR_LEFT,
+
+  VTERM_N_PROP_CURSORSHAPES
 };
 
-typedef void (*VTermMouseFunc)(int x, int y, int button, int pressed, int modifiers, void *data);
+enum {
+  VTERM_PROP_MOUSE_NONE = 0,
+  VTERM_PROP_MOUSE_CLICK,
+  VTERM_PROP_MOUSE_DRAG,
+  VTERM_PROP_MOUSE_MOVE,
+
+  VTERM_N_PROP_MOUSES
+};
 
 typedef struct {
   const uint32_t *chars;
@@ -126,18 +285,25 @@
 void vterm_get_size(const VTerm *vt, int *rowsp, int *colsp);
 void vterm_set_size(VTerm *vt, int rows, int cols);
 
-void vterm_push_bytes(VTerm *vt, const char *bytes, size_t len);
+int  vterm_get_utf8(const VTerm *vt);
+void vterm_set_utf8(VTerm *vt, int is_utf8);
 
-void vterm_input_push_char(VTerm *vt, VTermModifier state, uint32_t c);
-void vterm_input_push_key(VTerm *vt, VTermModifier state, VTermKey key);
-
-size_t vterm_output_bufferlen(VTerm *vt); /* deprecated */
+size_t vterm_input_write(VTerm *vt, const char *bytes, size_t len);
 
 size_t vterm_output_get_buffer_size(const VTerm *vt);
 size_t vterm_output_get_buffer_current(const VTerm *vt);
 size_t vterm_output_get_buffer_remaining(const VTerm *vt);
 
-size_t vterm_output_bufferread(VTerm *vt, char *buffer, size_t len);
+size_t vterm_output_read(VTerm *vt, char *buffer, size_t len);
+
+void vterm_keyboard_unichar(VTerm *vt, uint32_t c, VTermModifier mod);
+void vterm_keyboard_key(VTerm *vt, VTermKey key, VTermModifier mod);
+
+void vterm_keyboard_start_paste(VTerm *vt);
+void vterm_keyboard_end_paste(VTerm *vt);
+
+void vterm_mouse_move(VTerm *vt, int row, int col, VTermModifier mod);
+void vterm_mouse_button(VTerm *vt, int button, bool pressed, VTermModifier mod);
 
 // ------------
 // Parser layer
@@ -151,8 +317,8 @@
  *
  * Don't confuse this with the final byte of the CSI escape; 'a' in this case.
  */
-#define CSI_ARG_FLAG_MORE (1<<31)
-#define CSI_ARG_MASK      (~(1<<31))
+#define CSI_ARG_FLAG_MORE (1U<<31)
+#define CSI_ARG_MASK      (~(1U<<31))
 
 #define CSI_ARG_HAS_MORE(a) ((a) & CSI_ARG_FLAG_MORE)
 #define CSI_ARG(a)          ((a) & CSI_ARG_MASK)
@@ -174,9 +340,8 @@
   int (*resize)(int rows, int cols, void *user);
 } VTermParserCallbacks;
 
-void vterm_set_parser_callbacks(VTerm *vt, const VTermParserCallbacks *callbacks, void *user);
-
-void vterm_parser_set_utf8(VTerm *vt, int is_utf8);
+void  vterm_parser_set_callbacks(VTerm *vt, const VTermParserCallbacks *callbacks, void *user);
+void *vterm_parser_get_cbdata(VTerm *vt);
 
 // -----------
 // State layer
@@ -191,7 +356,6 @@
   int (*initpen)(void *user);
   int (*setpenattr)(VTermAttr attr, VTermValue *val, void *user);
   int (*settermprop)(VTermProp prop, VTermValue *val, void *user);
-  int (*setmousefunc)(VTermMouseFunc func, void *data, void *user);
   int (*bell)(void *user);
   int (*resize)(int rows, int cols, VTermPos *delta, void *user);
   int (*setlineinfo)(int row, const VTermLineInfo *newinfo, const VTermLineInfo *oldinfo, void *user);
@@ -199,8 +363,14 @@
 
 VTermState *vterm_obtain_state(VTerm *vt);
 
+void  vterm_state_set_callbacks(VTermState *state, const VTermStateCallbacks *callbacks, void *user);
+void *vterm_state_get_cbdata(VTermState *state);
+
+// Only invokes control, csi, osc, dcs
+void  vterm_state_set_unrecognised_fallbacks(VTermState *state, const VTermParserCallbacks *fallbacks, void *user);
+void *vterm_state_get_unrecognised_fbdata(VTermState *state);
+
 void vterm_state_reset(VTermState *state, int hard);
-void vterm_state_set_callbacks(VTermState *state, const VTermStateCallbacks *callbacks, void *user);
 void vterm_state_get_cursorpos(const VTermState *state, VTermPos *cursorpos);
 void vterm_state_get_default_colors(const VTermState *state, VTermColor *default_fg, VTermColor *default_bg);
 void vterm_state_get_palette_color(const VTermState *state, int index, VTermColor *col);
@@ -209,17 +379,27 @@
 void vterm_state_set_bold_highbright(VTermState *state, int bold_is_highbright);
 int  vterm_state_get_penattr(const VTermState *state, VTermAttr attr, VTermValue *val);
 int  vterm_state_set_termprop(VTermState *state, VTermProp prop, VTermValue *val);
+void vterm_state_focus_in(VTermState *state);
+void vterm_state_focus_out(VTermState *state);
 const VTermLineInfo *vterm_state_get_lineinfo(const VTermState *state, int row);
 
+/**
+ * Makes sure that the given color `col` is indeed an RGB colour. After this
+ * function returns, VTERM_COLOR_IS_RGB(col) will return true, while all other
+ * flags stored in `col->type` will have been reset.
+ *
+ * @param state is the VTermState instance from which the colour palette should
+ * be extracted.
+ * @param col is a pointer at the VTermColor instance that should be converted
+ * to an RGB colour.
+ */
+void vterm_state_convert_color_to_rgb(const VTermState *state, VTermColor *col);
+
 // ------------
 // Screen layer
 // ------------
 
 typedef struct {
-#define VTERM_MAX_CHARS_PER_CELL 6
-  uint32_t chars[VTERM_MAX_CHARS_PER_CELL];
-  char     width;
-  struct {
     unsigned int bold      : 1;
     unsigned int underline : 2;
     unsigned int italic    : 1;
@@ -229,7 +409,13 @@
     unsigned int font      : 4; /* 0 to 9 */
     unsigned int dwl       : 1; /* On a DECDWL or DECDHL line */
     unsigned int dhl       : 2; /* On a DECDHL line (1=top 2=bottom) */
-  } attrs;
+} VTermScreenCellAttrs;
+
+typedef struct {
+#define VTERM_MAX_CHARS_PER_CELL 6
+  uint32_t chars[VTERM_MAX_CHARS_PER_CELL];
+  char     width;
+  VTermScreenCellAttrs attrs;
   VTermColor fg, bg;
 } VTermScreenCell;
 
@@ -238,7 +424,6 @@
   int (*moverect)(VTermRect dest, VTermRect src, void *user);
   int (*movecursor)(VTermPos pos, VTermPos oldpos, int visible, void *user);
   int (*settermprop)(VTermProp prop, VTermValue *val, void *user);
-  int (*setmousefunc)(VTermMouseFunc func, void *data, void *user);
   int (*bell)(void *user);
   int (*resize)(int rows, int cols, void *user);
   int (*sb_pushline)(int cols, const VTermScreenCell *cells, void *user);
@@ -247,14 +432,22 @@
 
 VTermScreen *vterm_obtain_screen(VTerm *vt);
 
+void  vterm_screen_set_callbacks(VTermScreen *screen, const VTermScreenCallbacks *callbacks, void *user);
+void *vterm_screen_get_cbdata(VTermScreen *screen);
+
+// Only invokes control, csi, osc, dcs
+void  vterm_screen_set_unrecognised_fallbacks(VTermScreen *screen, const VTermParserCallbacks *fallbacks, void *user);
+void *vterm_screen_get_unrecognised_fbdata(VTermScreen *screen);
+
 void vterm_screen_enable_altscreen(VTermScreen *screen, int altscreen);
-void vterm_screen_set_callbacks(VTermScreen *screen, const VTermScreenCallbacks *callbacks, void *user);
 
 typedef enum {
   VTERM_DAMAGE_CELL,    /* every cell */
   VTERM_DAMAGE_ROW,     /* entire rows */
   VTERM_DAMAGE_SCREEN,  /* entire screen */
   VTERM_DAMAGE_SCROLL,  /* entire screen + scrollrect */
+
+  VTERM_N_DAMAGES
 } VTermDamageSize;
 
 void vterm_screen_flush_damage(VTermScreen *screen);
@@ -276,6 +469,8 @@
   VTERM_ATTR_FONT_MASK       = 1 << 6,
   VTERM_ATTR_FOREGROUND_MASK = 1 << 7,
   VTERM_ATTR_BACKGROUND_MASK = 1 << 8,
+
+  VTERM_ALL_ATTRS_MASK = (1 << 9) - 1
 } VTermAttrMask;
 
 int vterm_screen_get_attrs_extent(const VTermScreen *screen, VTermRect *extent, VTermPos pos, VTermAttrMask attrs);
@@ -284,6 +479,12 @@
 
 int vterm_screen_is_eol(const VTermScreen *screen, VTermPos pos);
 
+/**
+ * Same as vterm_state_convert_color_to_rgb(), but takes a `screen` instead of a `state`
+ * instance.
+ */
+void vterm_screen_convert_color_to_rgb(const VTermScreen *screen, VTermColor *col);
+
 // ---------
 // Utilities
 // ---------
diff --git a/include/vterm_input.h b/include/vterm_keycodes.h
similarity index 94%
rename from include/vterm_input.h
rename to include/vterm_keycodes.h
index 165d747..661759f 100644
--- a/include/vterm_input.h
+++ b/include/vterm_keycodes.h
@@ -6,6 +6,8 @@
   VTERM_MOD_SHIFT = 0x01,
   VTERM_MOD_ALT   = 0x02,
   VTERM_MOD_CTRL  = 0x04,
+
+  VTERM_ALL_MODS_MASK = 0x07 
 } VTermModifier;
 
 typedef enum {
@@ -51,6 +53,7 @@
   VTERM_KEY_KP_EQUAL,
 
   VTERM_KEY_MAX, // Must be last
+  VTERM_N_KEYS = VTERM_KEY_MAX
 } VTermKey;
 
 #define VTERM_KEY_FUNCTION(n) (VTERM_KEY_FUNCTION_0+(n))
diff --git a/src/encoding.c b/src/encoding.c
index 1495855..434ac3f 100644
--- a/src/encoding.c
+++ b/src/encoding.c
@@ -42,10 +42,10 @@
     printf(" pos=%zd c=%02x rem=%d\n", *pos, c, data->bytes_remaining);
 #endif
 
-    if(c < 0x20)
+    if(c < 0x20) // C0
       return;
 
-    else if(c >= 0x20 && c < 0x80) {
+    else if(c >= 0x20 && c < 0x7f) {
       if(data->bytes_remaining)
         cp[(*cpi)++] = UNICODE_INVALID;
 
@@ -56,6 +56,9 @@
       data->bytes_remaining = 0;
     }
 
+    else if(c == 0x7f) // DEL
+      return;
+
     else if(c >= 0x80 && c < 0xc0) {
       if(!data->bytes_remaining) {
         cp[(*cpi)++] = UNICODE_INVALID;
@@ -73,15 +76,20 @@
         // Check for overlong sequences
         switch(data->bytes_total) {
         case 2:
-          if(data->this_cp <  0x0080) data->this_cp = UNICODE_INVALID; break;
+          if(data->this_cp <  0x0080) data->this_cp = UNICODE_INVALID;
+          break;
         case 3:
-          if(data->this_cp <  0x0800) data->this_cp = UNICODE_INVALID; break;
+          if(data->this_cp <  0x0800) data->this_cp = UNICODE_INVALID;
+          break;
         case 4:
-          if(data->this_cp < 0x10000) data->this_cp = UNICODE_INVALID; break;
+          if(data->this_cp < 0x10000) data->this_cp = UNICODE_INVALID;
+          break;
         case 5:
-          if(data->this_cp < 0x200000) data->this_cp = UNICODE_INVALID; break;
+          if(data->this_cp < 0x200000) data->this_cp = UNICODE_INVALID;
+          break;
         case 6:
-          if(data->this_cp < 0x4000000) data->this_cp = UNICODE_INVALID; break;
+          if(data->this_cp < 0x4000000) data->this_cp = UNICODE_INVALID;
+          break;
         }
         // Now look for plain invalid ones
         if((data->this_cp >= 0xD800 && data->this_cp <= 0xDFFF) ||
@@ -160,7 +168,7 @@
   for(; *pos < bytelen && *cpi < cplen; (*pos)++) {
     unsigned char c = bytes[*pos] ^ is_gr;
 
-    if(c < 0x20 || c >= 0x80)
+    if(c < 0x20 || c == 0x7f || c >= 0x80)
       return;
 
     cp[(*cpi)++] = c;
@@ -186,7 +194,7 @@
   for(; *pos < bytelen && *cpi < cplen; (*pos)++) {
     unsigned char c = bytes[*pos] ^ is_gr;
 
-    if(c < 0x20 || c >= 0x80)
+    if(c < 0x20 || c == 0x7f || c >= 0x80)
       return;
 
     if(table->chars[c])
diff --git a/src/fullwidth.inc b/src/fullwidth.inc
new file mode 100644
index 0000000..7ff142f
--- /dev/null
+++ b/src/fullwidth.inc
@@ -0,0 +1,104 @@
+  { 0x1100, 0x115f },
+  { 0x231a, 0x231b },
+  { 0x2329, 0x232a },
+  { 0x23e9, 0x23ec },
+  { 0x23f0, 0x23f0 },
+  { 0x23f3, 0x23f3 },
+  { 0x25fd, 0x25fe },
+  { 0x2614, 0x2615 },
+  { 0x2648, 0x2653 },
+  { 0x267f, 0x267f },
+  { 0x2693, 0x2693 },
+  { 0x26a1, 0x26a1 },
+  { 0x26aa, 0x26ab },
+  { 0x26bd, 0x26be },
+  { 0x26c4, 0x26c5 },
+  { 0x26ce, 0x26ce },
+  { 0x26d4, 0x26d4 },
+  { 0x26ea, 0x26ea },
+  { 0x26f2, 0x26f3 },
+  { 0x26f5, 0x26f5 },
+  { 0x26fa, 0x26fa },
+  { 0x26fd, 0x26fd },
+  { 0x2705, 0x2705 },
+  { 0x270a, 0x270b },
+  { 0x2728, 0x2728 },
+  { 0x274c, 0x274c },
+  { 0x274e, 0x274e },
+  { 0x2753, 0x2755 },
+  { 0x2757, 0x2757 },
+  { 0x2795, 0x2797 },
+  { 0x27b0, 0x27b0 },
+  { 0x27bf, 0x27bf },
+  { 0x2b1b, 0x2b1c },
+  { 0x2b50, 0x2b50 },
+  { 0x2b55, 0x2b55 },
+  { 0x2e80, 0x2e99 },
+  { 0x2e9b, 0x2ef3 },
+  { 0x2f00, 0x2fd5 },
+  { 0x2ff0, 0x2ffb },
+  { 0x3000, 0x303e },
+  { 0x3041, 0x3096 },
+  { 0x3099, 0x30ff },
+  { 0x3105, 0x312d },
+  { 0x3131, 0x318e },
+  { 0x3190, 0x31ba },
+  { 0x31c0, 0x31e3 },
+  { 0x31f0, 0x321e },
+  { 0x3220, 0x3247 },
+  { 0x3250, 0x32fe },
+  { 0x3300, 0x4dbf },
+  { 0x4e00, 0xa48c },
+  { 0xa490, 0xa4c6 },
+  { 0xa960, 0xa97c },
+  { 0xac00, 0xd7a3 },
+  { 0xf900, 0xfaff },
+  { 0xfe10, 0xfe19 },
+  { 0xfe30, 0xfe52 },
+  { 0xfe54, 0xfe66 },
+  { 0xfe68, 0xfe6b },
+  { 0xff01, 0xff60 },
+  { 0xffe0, 0xffe6 },
+  { 0x16fe0, 0x16fe0 },
+  { 0x17000, 0x187ec },
+  { 0x18800, 0x18af2 },
+  { 0x1b000, 0x1b001 },
+  { 0x1f004, 0x1f004 },
+  { 0x1f0cf, 0x1f0cf },
+  { 0x1f18e, 0x1f18e },
+  { 0x1f191, 0x1f19a },
+  { 0x1f200, 0x1f202 },
+  { 0x1f210, 0x1f23b },
+  { 0x1f240, 0x1f248 },
+  { 0x1f250, 0x1f251 },
+  { 0x1f300, 0x1f320 },
+  { 0x1f32d, 0x1f335 },
+  { 0x1f337, 0x1f37c },
+  { 0x1f37e, 0x1f393 },
+  { 0x1f3a0, 0x1f3ca },
+  { 0x1f3cf, 0x1f3d3 },
+  { 0x1f3e0, 0x1f3f0 },
+  { 0x1f3f4, 0x1f3f4 },
+  { 0x1f3f8, 0x1f43e },
+  { 0x1f440, 0x1f440 },
+  { 0x1f442, 0x1f4fc },
+  { 0x1f4ff, 0x1f53d },
+  { 0x1f54b, 0x1f54e },
+  { 0x1f550, 0x1f567 },
+  { 0x1f57a, 0x1f57a },
+  { 0x1f595, 0x1f596 },
+  { 0x1f5a4, 0x1f5a4 },
+  { 0x1f5fb, 0x1f64f },
+  { 0x1f680, 0x1f6c5 },
+  { 0x1f6cc, 0x1f6cc },
+  { 0x1f6d0, 0x1f6d2 },
+  { 0x1f6eb, 0x1f6ec },
+  { 0x1f6f4, 0x1f6f6 },
+  { 0x1f910, 0x1f91e },
+  { 0x1f920, 0x1f927 },
+  { 0x1f930, 0x1f930 },
+  { 0x1f933, 0x1f93e },
+  { 0x1f940, 0x1f94b },
+  { 0x1f950, 0x1f95e },
+  { 0x1f980, 0x1f991 },
+  { 0x1f9c0, 0x1f9c0 },
diff --git a/src/keyboard.c b/src/keyboard.c
new file mode 100644
index 0000000..b541fb1
--- /dev/null
+++ b/src/keyboard.c
@@ -0,0 +1,226 @@
+#include "vterm_internal.h"
+
+#include <stdio.h>
+
+#include "utf8.h"
+
+void vterm_keyboard_unichar(VTerm *vt, uint32_t c, VTermModifier mod)
+{
+  /* The shift modifier is never important for Unicode characters
+   * apart from Space
+   */
+  if(c != ' ')
+    mod &= ~VTERM_MOD_SHIFT;
+
+  if(mod == 0) {
+    // Normal text - ignore just shift
+    char str[6];
+    int seqlen = fill_utf8(c, str);
+    vterm_push_output_bytes(vt, str, seqlen);
+    return;
+  }
+
+  int needs_CSIu;
+  switch(c) {
+    /* Special Ctrl- letters that can't be represented elsewise */
+    case 'i': case 'j': case 'm': case '[':
+      needs_CSIu = 1;
+      break;
+    /* Ctrl-\ ] ^ _ don't need CSUu */
+    case '\\': case ']': case '^': case '_':
+      needs_CSIu = 0;
+      break;
+    /* Shift-space needs CSIu */
+    case ' ':
+      needs_CSIu = !!(mod & VTERM_MOD_SHIFT);
+      break;
+    /* All other characters needs CSIu except for letters a-z */
+    default:
+      needs_CSIu = (c < 'a' || c > 'z');
+  }
+
+  /* ALT we can just prefix with ESC; anything else requires CSI u */
+  if(needs_CSIu && (mod & ~VTERM_MOD_ALT)) {
+    vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%du", c, mod+1);
+    return;
+  }
+
+  if(mod & VTERM_MOD_CTRL)
+    c &= 0x1f;
+
+  vterm_push_output_sprintf(vt, "%s%c", mod & VTERM_MOD_ALT ? ESC_S : "", c);
+}
+
+typedef struct {
+  enum {
+    KEYCODE_NONE,
+    KEYCODE_LITERAL,
+    KEYCODE_TAB,
+    KEYCODE_ENTER,
+    KEYCODE_SS3,
+    KEYCODE_CSI,
+    KEYCODE_CSI_CURSOR,
+    KEYCODE_CSINUM,
+    KEYCODE_KEYPAD,
+  } type;
+  char literal;
+  int csinum;
+} keycodes_s;
+
+static keycodes_s keycodes[] = {
+  { KEYCODE_NONE }, // NONE
+
+  { KEYCODE_ENTER,   '\r'   }, // ENTER
+  { KEYCODE_TAB,     '\t'   }, // TAB
+  { KEYCODE_LITERAL, '\x7f' }, // BACKSPACE == ASCII DEL
+  { KEYCODE_LITERAL, '\x1b' }, // ESCAPE
+
+  { KEYCODE_CSI_CURSOR, 'A' }, // UP
+  { KEYCODE_CSI_CURSOR, 'B' }, // DOWN
+  { KEYCODE_CSI_CURSOR, 'D' }, // LEFT
+  { KEYCODE_CSI_CURSOR, 'C' }, // RIGHT
+
+  { KEYCODE_CSINUM, '~', 2 },  // INS
+  { KEYCODE_CSINUM, '~', 3 },  // DEL
+  { KEYCODE_CSI_CURSOR, 'H' }, // HOME
+  { KEYCODE_CSI_CURSOR, 'F' }, // END
+  { KEYCODE_CSINUM, '~', 5 },  // PAGEUP
+  { KEYCODE_CSINUM, '~', 6 },  // PAGEDOWN
+};
+
+static keycodes_s keycodes_fn[] = {
+  { KEYCODE_NONE },            // F0 - shouldn't happen
+  { KEYCODE_CSI_CURSOR, 'P' }, // F1
+  { KEYCODE_CSI_CURSOR, 'Q' }, // F2
+  { KEYCODE_CSI_CURSOR, 'R' }, // F3
+  { KEYCODE_CSI_CURSOR, 'S' }, // F4
+  { KEYCODE_CSINUM, '~', 15 }, // F5
+  { KEYCODE_CSINUM, '~', 17 }, // F6
+  { KEYCODE_CSINUM, '~', 18 }, // F7
+  { KEYCODE_CSINUM, '~', 19 }, // F8
+  { KEYCODE_CSINUM, '~', 20 }, // F9
+  { KEYCODE_CSINUM, '~', 21 }, // F10
+  { KEYCODE_CSINUM, '~', 23 }, // F11
+  { KEYCODE_CSINUM, '~', 24 }, // F12
+};
+
+static keycodes_s keycodes_kp[] = {
+  { KEYCODE_KEYPAD, '0', 'p' }, // KP_0
+  { KEYCODE_KEYPAD, '1', 'q' }, // KP_1
+  { KEYCODE_KEYPAD, '2', 'r' }, // KP_2
+  { KEYCODE_KEYPAD, '3', 's' }, // KP_3
+  { KEYCODE_KEYPAD, '4', 't' }, // KP_4
+  { KEYCODE_KEYPAD, '5', 'u' }, // KP_5
+  { KEYCODE_KEYPAD, '6', 'v' }, // KP_6
+  { KEYCODE_KEYPAD, '7', 'w' }, // KP_7
+  { KEYCODE_KEYPAD, '8', 'x' }, // KP_8
+  { KEYCODE_KEYPAD, '9', 'y' }, // KP_9
+  { KEYCODE_KEYPAD, '*', 'j' }, // KP_MULT
+  { KEYCODE_KEYPAD, '+', 'k' }, // KP_PLUS
+  { KEYCODE_KEYPAD, ',', 'l' }, // KP_COMMA
+  { KEYCODE_KEYPAD, '-', 'm' }, // KP_MINUS
+  { KEYCODE_KEYPAD, '.', 'n' }, // KP_PERIOD
+  { KEYCODE_KEYPAD, '/', 'o' }, // KP_DIVIDE
+  { KEYCODE_KEYPAD, '\n', 'M' }, // KP_ENTER
+  { KEYCODE_KEYPAD, '=', 'X' }, // KP_EQUAL
+};
+
+void vterm_keyboard_key(VTerm *vt, VTermKey key, VTermModifier mod)
+{
+  if(key == VTERM_KEY_NONE)
+    return;
+
+  keycodes_s k;
+  if(key < VTERM_KEY_FUNCTION_0) {
+    if(key >= sizeof(keycodes)/sizeof(keycodes[0]))
+      return;
+    k = keycodes[key];
+  }
+  else if(key >= VTERM_KEY_FUNCTION_0 && key <= VTERM_KEY_FUNCTION_MAX) {
+    if((key - VTERM_KEY_FUNCTION_0) >= sizeof(keycodes_fn)/sizeof(keycodes_fn[0]))
+      return;
+    k = keycodes_fn[key - VTERM_KEY_FUNCTION_0];
+  }
+  else if(key >= VTERM_KEY_KP_0) {
+    if((key - VTERM_KEY_KP_0) >= sizeof(keycodes_kp)/sizeof(keycodes_kp[0]))
+      return;
+    k = keycodes_kp[key - VTERM_KEY_KP_0];
+  }
+
+  switch(k.type) {
+  case KEYCODE_NONE:
+    break;
+
+  case KEYCODE_TAB:
+    /* Shift-Tab is CSI Z but plain Tab is 0x09 */
+    if(mod == VTERM_MOD_SHIFT)
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "Z");
+    else if(mod & VTERM_MOD_SHIFT)
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "1;%dZ", mod+1);
+    else
+      goto case_LITERAL;
+    break;
+
+  case KEYCODE_ENTER:
+    /* Enter is CRLF in newline mode, but just LF in linefeed */
+    if(vt->state->mode.newline)
+      vterm_push_output_sprintf(vt, "\r\n");
+    else
+      goto case_LITERAL;
+    break;
+
+  case KEYCODE_LITERAL: case_LITERAL:
+    if(mod & (VTERM_MOD_SHIFT|VTERM_MOD_CTRL))
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%du", k.literal, mod+1);
+    else
+      vterm_push_output_sprintf(vt, mod & VTERM_MOD_ALT ? ESC_S "%c" : "%c", k.literal);
+    break;
+
+  case KEYCODE_SS3: case_SS3:
+    if(mod == 0)
+      vterm_push_output_sprintf_ctrl(vt, C1_SS3, "%c", k.literal);
+    else
+      goto case_CSI;
+    break;
+
+  case KEYCODE_CSI: case_CSI:
+    if(mod == 0)
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%c", k.literal);
+    else
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "1;%d%c", mod + 1, k.literal);
+    break;
+
+  case KEYCODE_CSINUM:
+    if(mod == 0)
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d%c", k.csinum, k.literal);
+    else
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%d%c", k.csinum, mod + 1, k.literal);
+    break;
+
+  case KEYCODE_CSI_CURSOR:
+    if(vt->state->mode.cursor)
+      goto case_SS3;
+    else
+      goto case_CSI;
+
+  case KEYCODE_KEYPAD:
+    if(vt->state->mode.keypad) {
+      k.literal = k.csinum;
+      goto case_SS3;
+    }
+    else
+      goto case_LITERAL;
+  }
+}
+
+void vterm_keyboard_start_paste(VTerm *vt)
+{
+  if(vt->state->mode.bracketpaste)
+    vterm_push_output_sprintf_ctrl(vt, C1_CSI, "200~");
+}
+
+void vterm_keyboard_end_paste(VTerm *vt)
+{
+  if(vt->state->mode.bracketpaste)
+    vterm_push_output_sprintf_ctrl(vt, C1_CSI, "201~");
+}
diff --git a/src/mouse.c b/src/mouse.c
new file mode 100644
index 0000000..9962e4f
--- /dev/null
+++ b/src/mouse.c
@@ -0,0 +1,96 @@
+#include "vterm_internal.h"
+
+#include "utf8.h"
+
+static void output_mouse(VTermState *state, int code, int pressed, int modifiers, int col, int row)
+{
+  modifiers <<= 2;
+
+  switch(state->mouse_protocol) {
+  case MOUSE_X10:
+    if(col + 0x21 > 0xff)
+      col = 0xff - 0x21;
+    if(row + 0x21 > 0xff)
+      row = 0xff - 0x21;
+
+    if(!pressed)
+      code = 3;
+
+    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%c%c%c",
+        (code | modifiers) + 0x20, col + 0x21, row + 0x21);
+    break;
+
+  case MOUSE_UTF8:
+    {
+      char utf8[18]; size_t len = 0;
+
+      if(!pressed)
+        code = 3;
+
+      len += fill_utf8((code | modifiers) + 0x20, utf8 + len);
+      len += fill_utf8(col + 0x21, utf8 + len);
+      len += fill_utf8(row + 0x21, utf8 + len);
+      utf8[len] = 0;
+
+      vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%s", utf8);
+    }
+    break;
+
+  case MOUSE_SGR:
+    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "<%d;%d;%d%c",
+        code | modifiers, col + 1, row + 1, pressed ? 'M' : 'm');
+    break;
+
+  case MOUSE_RXVT:
+    if(!pressed)
+      code = 3;
+
+    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%d;%d;%dM",
+        code | modifiers, col + 1, row + 1);
+    break;
+  }
+}
+
+void vterm_mouse_move(VTerm *vt, int row, int col, VTermModifier mod)
+{
+  VTermState *state = vt->state;
+
+  if(col == state->mouse_col && row == state->mouse_row)
+    return;
+
+  state->mouse_col = col;
+  state->mouse_row = row;
+
+  if((state->mouse_flags & MOUSE_WANT_DRAG && state->mouse_buttons) ||
+     (state->mouse_flags & MOUSE_WANT_MOVE)) {
+    int button = state->mouse_buttons & 0x01 ? 1 :
+                 state->mouse_buttons & 0x02 ? 2 :
+                 state->mouse_buttons & 0x04 ? 3 : 4;
+    output_mouse(state, button-1 + 0x20, 1, mod, col, row);
+  }
+}
+
+void vterm_mouse_button(VTerm *vt, int button, bool pressed, VTermModifier mod)
+{
+  VTermState *state = vt->state;
+
+  int old_buttons = state->mouse_buttons;
+
+  if(button > 0 && button <= 3) {
+    if(pressed)
+      state->mouse_buttons |= (1 << (button-1));
+    else
+      state->mouse_buttons &= ~(1 << (button-1));
+  }
+
+  /* Most of the time we don't get button releases from 4/5 */
+  if(state->mouse_buttons == old_buttons && button < 4)
+    return;
+
+  if(button < 4) {
+    output_mouse(state, button-1, pressed, mod, state->mouse_col, state->mouse_row);
+  }
+  else if(button < 6) {
+    output_mouse(state, button-4 + 0x40, pressed, mod, state->mouse_col, state->mouse_row);
+  }
+}
diff --git a/src/parser.c b/src/parser.c
index 13bbc21..a01cd71 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -3,218 +3,154 @@
 #include <stdio.h>
 #include <string.h>
 
-#define CSI_ARGS_MAX 16
-#define CSI_LEADER_MAX 16
-#define CSI_INTERMED_MAX 16
+#undef DEBUG_PARSER
+
+static bool is_intermed(unsigned char c)
+{
+  return c >= 0x20 && c <= 0x2f;
+}
 
 static void do_control(VTerm *vt, unsigned char control)
 {
-  if(vt->parser_callbacks && vt->parser_callbacks->control)
-    if((*vt->parser_callbacks->control)(control, vt->cbdata))
+  if(vt->parser.callbacks && vt->parser.callbacks->control)
+    if((*vt->parser.callbacks->control)(control, vt->parser.cbdata))
       return;
 
-  fprintf(stderr, "libvterm: Unhandled control 0x%02x\n", control);
+  DEBUG_LOG("libvterm: Unhandled control 0x%02x\n", control);
 }
 
-static void do_string_csi(VTerm *vt, const char *args, size_t arglen, char command)
+static void do_csi(VTerm *vt, char command)
 {
-  int i = 0;
-
-  int leaderlen = 0;
-  char leader[CSI_LEADER_MAX];
-
-  // Extract leader bytes 0x3c to 0x3f
-  for( ; i < arglen; i++) {
-    if(args[i] < 0x3c || args[i] > 0x3f)
-      break;
-    if(leaderlen < CSI_LEADER_MAX-1)
-      leader[leaderlen++] = args[i];
+#ifdef DEBUG_PARSER
+  printf("Parsed CSI args as:\n", arglen, args);
+  printf(" leader: %s\n", vt->parser.csi_leader);
+  for(int argi = 0; argi < vt->parser.csi_argi; argi++) {
+    printf(" %lu", CSI_ARG(vt->parser.csi_args[argi]));
+    if(!CSI_ARG_HAS_MORE(vt->parser.csi_args[argi]))
+      printf("\n");
+  printf(" intermed: %s\n", vt->parser.intermed);
   }
+#endif
 
-  leader[leaderlen] = 0;
-
-  int argcount = 1; // Always at least 1 arg
-
-  for( ; i < arglen; i++)
-    if(args[i] == 0x3b || args[i] == 0x3a) // ; or :
-      argcount++;
-
-  /* TODO: Consider if these buffers should live in the VTerm struct itself */
-  long csi_args[CSI_ARGS_MAX];
-  if(argcount > CSI_ARGS_MAX)
-    argcount = CSI_ARGS_MAX;
-
-  int argi;
-  for(argi = 0; argi < argcount; argi++)
-    csi_args[argi] = CSI_ARG_MISSING;
-
-  argi = 0;
-  for(i = leaderlen; i < arglen && argi < argcount; i++) {
-    switch(args[i]) {
-    case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
-    case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
-      if(csi_args[argi] == CSI_ARG_MISSING)
-        csi_args[argi] = 0;
-      csi_args[argi] *= 10;
-      csi_args[argi] += args[i] - '0';
-      break;
-    case 0x3a:
-      csi_args[argi] |= CSI_ARG_FLAG_MORE;
-      /* FALLTHROUGH */
-    case 0x3b:
-      argi++;
-      break;
-    default:
-      goto done_leader;
-    }
-  }
-done_leader: ;
-
-  int intermedlen = 0;
-  char intermed[CSI_INTERMED_MAX];
-
-  for( ; i < arglen; i++) {
-    if((args[i] & 0xf0) != 0x20)
-      break;
-
-    if(intermedlen < CSI_INTERMED_MAX-1)
-      intermed[intermedlen++] = args[i];
-  }
-
-  intermed[intermedlen] = 0;
-
-  if(i < arglen) {
-    fprintf(stderr, "libvterm: TODO unhandled CSI bytes \"%.*s\"\n", (int)(arglen - i), args + i);
-  }
-
-  //printf("Parsed CSI args %.*s as:\n", arglen, args);
-  //printf(" leader: %s\n", leader);
-  //for(argi = 0; argi < argcount; argi++) {
-  //  printf(" %lu", CSI_ARG(csi_args[argi]));
-  //  if(!CSI_ARG_HAS_MORE(csi_args[argi]))
-  //    printf("\n");
-  //printf(" intermed: %s\n", intermed);
-  //}
-
-  if(vt->parser_callbacks && vt->parser_callbacks->csi)
-    if((*vt->parser_callbacks->csi)(leaderlen ? leader : NULL, csi_args, argcount, intermedlen ? intermed : NULL, command, vt->cbdata))
+  if(vt->parser.callbacks && vt->parser.callbacks->csi)
+    if((*vt->parser.callbacks->csi)(
+          vt->parser.csi_leaderlen ? vt->parser.csi_leader : NULL, 
+          vt->parser.csi_args,
+          vt->parser.csi_argi,
+          vt->parser.intermedlen ? vt->parser.intermed : NULL,
+          command,
+          vt->parser.cbdata))
       return;
 
-  fprintf(stderr, "libvterm: Unhandled CSI %.*s %c\n", (int)arglen, args, command);
+  DEBUG_LOG("libvterm: Unhandled CSI %c\n", command);
+}
+
+static void do_escape(VTerm *vt, char command)
+{
+  char seq[INTERMED_MAX+1];
+
+  size_t len = vt->parser.intermedlen;
+  strncpy(seq, vt->parser.intermed, len);
+  seq[len++] = command;
+  seq[len]   = 0;
+
+  if(vt->parser.callbacks && vt->parser.callbacks->escape)
+    if((*vt->parser.callbacks->escape)(seq, len, vt->parser.cbdata))
+      return;
+
+  DEBUG_LOG("libvterm: Unhandled escape ESC 0x%02x\n", command);
 }
 
 static void append_strbuffer(VTerm *vt, const char *str, size_t len)
 {
-  if(len > vt->strbuffer_len - vt->strbuffer_cur) {
-    len = vt->strbuffer_len - vt->strbuffer_cur;
-    fprintf(stderr, "Truncating strbuffer preserve to %zd bytes\n", len);
+  if(len > vt->parser.strbuffer_len - vt->parser.strbuffer_cur) {
+    len = vt->parser.strbuffer_len - vt->parser.strbuffer_cur;
+    DEBUG_LOG("Truncating strbuffer preserve to %zd bytes\n", len);
   }
 
   if(len > 0) {
-    strncpy(vt->strbuffer + vt->strbuffer_cur, str, len);
-    vt->strbuffer_cur += len;
+    strncpy(vt->parser.strbuffer + vt->parser.strbuffer_cur, str, len);
+    vt->parser.strbuffer_cur += len;
   }
 }
 
-static size_t do_string(VTerm *vt, const char *str_frag, size_t len)
+static void start_string(VTerm *vt, VTermParserStringType type)
 {
-  if(vt->strbuffer_cur) {
-    if(str_frag)
-      append_strbuffer(vt, str_frag, len);
+  vt->parser.stringtype = type;
 
-    str_frag = vt->strbuffer;
-    len = vt->strbuffer_cur;
+  vt->parser.strbuffer_cur = 0;
+}
+
+static void more_string(VTerm *vt, const char *str, size_t len)
+{
+  append_strbuffer(vt, str, len);
+}
+
+static void done_string(VTerm *vt, const char *str, size_t len)
+{
+  if(vt->parser.strbuffer_cur) {
+    if(str)
+      append_strbuffer(vt, str, len);
+
+    str = vt->parser.strbuffer;
+    len = vt->parser.strbuffer_cur;
   }
-  else if(!str_frag) {
-    fprintf(stderr, "parser.c: TODO: No strbuffer _and_ no final fragment???\n");
+  else if(!str) {
+    DEBUG_LOG("parser.c: TODO: No strbuffer _and_ no final fragment???\n");
     len = 0;
   }
 
-  vt->strbuffer_cur = 0;
+  switch(vt->parser.stringtype) {
+  case VTERM_PARSER_OSC:
+    if(vt->parser.callbacks && vt->parser.callbacks->osc)
+      if((*vt->parser.callbacks->osc)(str, len, vt->parser.cbdata))
+        return;
 
-  size_t eaten;
+    DEBUG_LOG("libvterm: Unhandled OSC %.*s\n", (int)len, str);
+    return;
 
-  switch(vt->parser_state) {
-  case NORMAL:
-    if(vt->parser_callbacks && vt->parser_callbacks->text)
-      if((eaten = (*vt->parser_callbacks->text)(str_frag, len, vt->cbdata)))
-        return eaten;
+  case VTERM_PARSER_DCS:
+    if(vt->parser.callbacks && vt->parser.callbacks->dcs)
+      if((*vt->parser.callbacks->dcs)(str, len, vt->parser.cbdata))
+        return;
 
-    fprintf(stderr, "libvterm: Unhandled text (%zu chars)\n", len);
-    return 0;
+    DEBUG_LOG("libvterm: Unhandled DCS %.*s\n", (int)len, str);
+    return;
 
-  case ESC:
-    if(len == 1 && str_frag[0] >= 0x40 && str_frag[0] < 0x60) {
-      // C1 emulations using 7bit clean
-      // ESC 0x40 == 0x80
-      do_control(vt, str_frag[0] + 0x40);
-      return 0;
-    }
-
-    if(vt->parser_callbacks && vt->parser_callbacks->escape)
-      if((*vt->parser_callbacks->escape)(str_frag, len, vt->cbdata))
-        return 0;
-
-    fprintf(stderr, "libvterm: Unhandled escape ESC 0x%02x\n", str_frag[len-1]);
-    return 0;
-
-  case CSI:
-    do_string_csi(vt, str_frag, len - 1, str_frag[len - 1]);
-    return 0;
-
-  case OSC:
-    if(vt->parser_callbacks && vt->parser_callbacks->osc)
-      if((*vt->parser_callbacks->osc)(str_frag, len, vt->cbdata))
-        return 0;
-
-    fprintf(stderr, "libvterm: Unhandled OSC %.*s\n", (int)len, str_frag);
-    return 0;
-
-  case DCS:
-    if(vt->parser_callbacks && vt->parser_callbacks->dcs)
-      if((*vt->parser_callbacks->dcs)(str_frag, len, vt->cbdata))
-        return 0;
-
-    fprintf(stderr, "libvterm: Unhandled DCS %.*s\n", (int)len, str_frag);
-    return 0;
-
-  case ESC_IN_OSC:
-  case ESC_IN_DCS:
-    fprintf(stderr, "libvterm: ARGH! Should never do_string() in ESC_IN_{OSC,DCS}\n");
-    return 0;
+  case VTERM_N_PARSER_TYPES:
+    return;
   }
-
-  return 0;
 }
 
-void vterm_push_bytes(VTerm *vt, const char *bytes, size_t len)
+size_t vterm_input_write(VTerm *vt, const char *bytes, size_t len)
 {
   size_t pos = 0;
   const char *string_start;
 
-  switch(vt->parser_state) {
+  switch(vt->parser.state) {
   case NORMAL:
+  case CSI_LEADER:
+  case CSI_ARGS:
+  case CSI_INTERMED:
+  case ESC:
     string_start = NULL;
     break;
-  case ESC:
-  case ESC_IN_OSC:
-  case ESC_IN_DCS:
-  case CSI:
-  case OSC:
-  case DCS:
+  case STRING:
+  case ESC_IN_STRING:
     string_start = bytes;
     break;
   }
 
-#define ENTER_STRING_STATE(st) do { vt->parser_state = st; string_start = bytes + pos + 1; } while(0)
-#define ENTER_NORMAL_STATE()   do { vt->parser_state = NORMAL; string_start = NULL; } while(0)
+#define ENTER_STRING_STATE(st) do { vt->parser.state = STRING; string_start = bytes + pos + 1; } while(0)
+#define ENTER_STATE(st)        do { vt->parser.state = st; string_start = NULL; } while(0)
+#define ENTER_NORMAL_STATE()   ENTER_STATE(NORMAL)
 
   for( ; pos < len; pos++) {
     unsigned char c = bytes[pos];
 
     if(c == 0x00 || c == 0x7f) { // NUL, DEL
-      if(vt->parser_state != NORMAL) {
-        append_strbuffer(vt, string_start, bytes + pos - string_start);
+      if(vt->parser.state >= STRING) {
+        more_string(vt, string_start, bytes + pos - string_start);
         string_start = bytes + pos + 1;
       }
       continue;
@@ -224,83 +160,131 @@
       continue;
     }
     else if(c == 0x1b) { // ESC
-      if(vt->parser_state == OSC)
-        vt->parser_state = ESC_IN_OSC;
-      else if(vt->parser_state == DCS)
-        vt->parser_state = ESC_IN_DCS;
+      vt->parser.intermedlen = 0;
+      if(vt->parser.state == STRING)
+        vt->parser.state = ESC_IN_STRING;
       else
-        ENTER_STRING_STATE(ESC);
+        ENTER_STATE(ESC);
       continue;
     }
     else if(c == 0x07 &&  // BEL, can stand for ST in OSC or DCS state
-            (vt->parser_state == OSC || vt->parser_state == DCS)) {
+            vt->parser.state == STRING) {
       // fallthrough
     }
     else if(c < 0x20) { // other C0
-      if(vt->parser_state != NORMAL)
-        append_strbuffer(vt, string_start, bytes + pos - string_start);
+      if(vt->parser.state >= STRING)
+        more_string(vt, string_start, bytes + pos - string_start);
       do_control(vt, c);
-      if(vt->parser_state != NORMAL)
+      if(vt->parser.state >= STRING)
         string_start = bytes + pos + 1;
       continue;
     }
     // else fallthrough
 
-    switch(vt->parser_state) {
-    case ESC_IN_OSC:
-    case ESC_IN_DCS:
+    switch(vt->parser.state) {
+    case ESC_IN_STRING:
       if(c == 0x5c) { // ST
-        switch(vt->parser_state) {
-          case ESC_IN_OSC: vt->parser_state = OSC; break;
-          case ESC_IN_DCS: vt->parser_state = DCS; break;
-          default: break;
-        }
-        do_string(vt, string_start, bytes + pos - string_start - 1);
+        vt->parser.state = STRING;
+        done_string(vt, string_start, bytes + pos - string_start - 1);
         ENTER_NORMAL_STATE();
         break;
       }
-      vt->parser_state = ESC;
-      string_start = bytes + pos;
+      vt->parser.state = ESC;
       // else fallthrough
 
     case ESC:
       switch(c) {
       case 0x50: // DCS
-        ENTER_STRING_STATE(DCS);
+        start_string(vt, VTERM_PARSER_DCS);
+        ENTER_STRING_STATE();
         break;
       case 0x5b: // CSI
-        ENTER_STRING_STATE(CSI);
+        vt->parser.csi_leaderlen = 0;
+        ENTER_STATE(CSI_LEADER);
         break;
       case 0x5d: // OSC
-        ENTER_STRING_STATE(OSC);
+        start_string(vt, VTERM_PARSER_OSC);
+        ENTER_STRING_STATE();
         break;
       default:
-        if(c >= 0x30 && c < 0x7f) {
-          /* +1 to pos because we want to include this command byte as well */
-          do_string(vt, string_start, bytes + pos - string_start + 1);
+        if(is_intermed(c)) {
+          if(vt->parser.intermedlen < INTERMED_MAX-1)
+            vt->parser.intermed[vt->parser.intermedlen++] = c;
+        }
+        else if(!vt->parser.intermedlen && c >= 0x40 && c < 0x60) {
+          do_control(vt, c + 0x40);
           ENTER_NORMAL_STATE();
         }
-        else if(c >= 0x20 && c < 0x30) {
-          /* intermediate byte */
+        else if(c >= 0x30 && c < 0x7f) {
+          do_escape(vt, c);
+          ENTER_NORMAL_STATE();
         }
         else {
-          fprintf(stderr, "TODO: Unhandled byte %02x in Escape\n", c);
+          DEBUG_LOG("TODO: Unhandled byte %02x in Escape\n", c);
         }
       }
       break;
 
-    case CSI:
-      if(c >= 0x40 && c <= 0x7f) {
-        /* +1 to pos because we want to include this command byte as well */
-        do_string(vt, string_start, bytes + pos - string_start + 1);
-        ENTER_NORMAL_STATE();
+    case CSI_LEADER:
+      /* Extract leader bytes 0x3c to 0x3f */
+      if(c >= 0x3c && c <= 0x3f) {
+        if(vt->parser.csi_leaderlen < CSI_LEADER_MAX-1)
+          vt->parser.csi_leader[vt->parser.csi_leaderlen++] = c;
+        break;
       }
+
+      /* else fallthrough */
+      vt->parser.csi_leader[vt->parser.csi_leaderlen] = 0;
+
+      vt->parser.csi_argi = 0;
+      vt->parser.csi_args[0] = CSI_ARG_MISSING;
+      vt->parser.state = CSI_ARGS;
+
+      /* fallthrough */
+    case CSI_ARGS:
+      /* Numerical value of argument */
+      if(c >= '0' && c <= '9') {
+        if(vt->parser.csi_args[vt->parser.csi_argi] == CSI_ARG_MISSING)
+          vt->parser.csi_args[vt->parser.csi_argi] = 0;
+        vt->parser.csi_args[vt->parser.csi_argi] *= 10;
+        vt->parser.csi_args[vt->parser.csi_argi] += c - '0';
+        break;
+      }
+      if(c == ':') {
+        vt->parser.csi_args[vt->parser.csi_argi] |= CSI_ARG_FLAG_MORE;
+        c = ';';
+      }
+      if(c == ';') {
+        vt->parser.csi_argi++;
+        vt->parser.csi_args[vt->parser.csi_argi] = CSI_ARG_MISSING;
+        break;
+      }
+
+      /* else fallthrough */
+      vt->parser.csi_argi++;
+      vt->parser.intermedlen = 0;
+      vt->parser.state = CSI_INTERMED;
+    case CSI_INTERMED:
+      if(is_intermed(c)) {
+        if(vt->parser.intermedlen < INTERMED_MAX-1)
+          vt->parser.intermed[vt->parser.intermedlen++] = c;
+        break;
+      }
+      else if(c == 0x1b) {
+        /* ESC in CSI cancels */
+      }
+      else if(c >= 0x40 && c <= 0x7e) {
+        vt->parser.intermed[vt->parser.intermedlen] = 0;
+        do_csi(vt, c);
+      }
+      /* else was invalid CSI */
+
+      ENTER_NORMAL_STATE();
       break;
 
-    case OSC:
-    case DCS:
+    case STRING:
       if(c == 0x07 || (c == 0x9c && !vt->mode.utf8)) {
-        do_string(vt, string_start, bytes + pos - string_start);
+        done_string(vt, string_start, bytes + pos - string_start);
         ENTER_NORMAL_STATE();
       }
       break;
@@ -309,13 +293,15 @@
       if(c >= 0x80 && c < 0xa0 && !vt->mode.utf8) {
         switch(c) {
         case 0x90: // DCS
-          ENTER_STRING_STATE(DCS);
+          start_string(vt, VTERM_PARSER_DCS);
+          ENTER_STRING_STATE();
           break;
         case 0x9b: // CSI
-          ENTER_STRING_STATE(CSI);
+          ENTER_STATE(CSI_LEADER);
           break;
         case 0x9d: // OSC
-          ENTER_STRING_STATE(OSC);
+          start_string(vt, VTERM_PARSER_OSC);
+          ENTER_STRING_STATE();
           break;
         default:
           do_control(vt, c);
@@ -323,22 +309,32 @@
         }
       }
       else {
-        size_t text_eaten = do_string(vt, bytes + pos, len - pos);
+        size_t eaten = 0;
+        if(vt->parser.callbacks && vt->parser.callbacks->text)
+          eaten = (*vt->parser.callbacks->text)(bytes + pos, len - pos, vt->parser.cbdata);
 
-        if(text_eaten == 0) {
-          string_start = bytes + pos;
-          goto pause;
+        if(!eaten) {
+          DEBUG_LOG("libvterm: Text callback did not consume any input\n");
+          /* force it to make progress */
+          eaten = 1;
         }
 
-        pos += (text_eaten - 1); // we'll ++ it again in a moment
+        pos += (eaten - 1); // we'll ++ it again in a moment
       }
       break;
     }
   }
 
-pause:
-  if(string_start && string_start < len + bytes) {
-    size_t remaining = len - (string_start - bytes);
-    append_strbuffer(vt, string_start, remaining);
-  }
+  return len;
+}
+
+void vterm_parser_set_callbacks(VTerm *vt, const VTermParserCallbacks *callbacks, void *user)
+{
+  vt->parser.callbacks = callbacks;
+  vt->parser.cbdata = user;
+}
+
+void *vterm_parser_get_cbdata(VTerm *vt)
+{
+  return vt->parser.cbdata;
 }
diff --git a/src/pen.c b/src/pen.c
index fb8c8e3..7488203 100644
--- a/src/pen.c
+++ b/src/pen.c
@@ -2,7 +2,15 @@
 
 #include <stdio.h>
 
-static const VTermColor ansi_colors[] = {
+/**
+ * Structure used to store RGB triples without the additional metadata stored in
+ * VTermColor.
+ */
+typedef struct {
+  uint8_t red, green, blue;
+} VTermRGB;
+
+static const VTermRGB ansi_colors[] = {
   /* R    G    B */
   {   0,   0,   0 }, // black
   { 224,   0,   0 }, // red
@@ -33,60 +41,75 @@
   0x85, 0x90, 0x9B, 0xA6, 0xB1, 0xBC, 0xC7, 0xD2, 0xDD, 0xE8, 0xF3, 0xFF,
 };
 
-static void lookup_colour_ansi(const VTermState *state, long index, VTermColor *col)
+static void lookup_default_colour_ansi(long idx, VTermColor *col)
 {
-  if(index >= 0 && index < 16) {
-    *col = state->colors[index];
+  if (idx >= 0 && idx < 16) {
+    vterm_color_rgb(
+        col,
+        ansi_colors[idx].red, ansi_colors[idx].green, ansi_colors[idx].blue);
   }
 }
 
-static void lookup_colour_palette(const VTermState *state, long index, VTermColor *col)
+static bool lookup_colour_ansi(const VTermState *state, long index, VTermColor *col)
+{
+  if(index >= 0 && index < 16) {
+    *col = state->colors[index];
+    return true;
+  }
+
+  return false;
+}
+
+static bool lookup_colour_palette(const VTermState *state, long index, VTermColor *col)
 {
   if(index >= 0 && index < 16) {
     // Normal 8 colours or high intensity - parse as palette 0
-    lookup_colour_ansi(state, index, col);
+    return lookup_colour_ansi(state, index, col);
   }
   else if(index >= 16 && index < 232) {
     // 216-colour cube
     index -= 16;
 
-    col->blue  = ramp6[index     % 6];
-    col->green = ramp6[index/6   % 6];
-    col->red   = ramp6[index/6/6 % 6];
+    vterm_color_rgb(col, ramp6[index/6/6 % 6],
+                         ramp6[index/6   % 6],
+                         ramp6[index     % 6]);
+
+    return true;
   }
   else if(index >= 232 && index < 256) {
     // 24 greyscales
     index -= 232;
 
-    col->red   = ramp24[index];
-    col->green = ramp24[index];
-    col->blue  = ramp24[index];
+    vterm_color_rgb(col, ramp24[index], ramp24[index], ramp24[index]);
+
+    return true;
   }
+
+  return false;
 }
 
-static int lookup_colour(const VTermState *state, int palette, const long args[], int argcount, VTermColor *col, int *index)
+static int lookup_colour(const VTermState *state, int palette, const long args[], int argcount, VTermColor *col)
 {
   switch(palette) {
   case 2: // RGB mode - 3 args contain colour values directly
     if(argcount < 3)
       return argcount;
 
-    col->red   = CSI_ARG(args[0]);
-    col->green = CSI_ARG(args[1]);
-    col->blue  = CSI_ARG(args[2]);
+    vterm_color_rgb(col, CSI_ARG(args[0]), CSI_ARG(args[1]), CSI_ARG(args[2]));
 
     return 3;
 
   case 5: // XTerm 256-colour mode
-    if(index)
-      *index = CSI_ARG_OR(args[0], -1);
+    if (!argcount || CSI_ARG_IS_MISSING(args[0])) {
+      return argcount ? 1 : 0;
+    }
 
-    lookup_colour_palette(state, argcount ? CSI_ARG_OR(args[0], -1) : -1, col);
+    vterm_color_indexed(col, args[0]);
 
     return argcount ? 1 : 0;
 
   default:
-    fprintf(stderr, "Unrecognised colour palette %d\n", palette);
+    DEBUG_LOG("Unrecognised colour palette %d\n", palette);
     return 0;
   }
 }
@@ -97,7 +120,7 @@
 {
 #ifdef DEBUG
   if(type != vterm_get_attr_type(attr)) {
-    fprintf(stderr, "Cannot set attr %d as it has type %d, not type %d\n",
+    DEBUG_LOG("Cannot set attr %d as it has type %d, not type %d\n",
         attr, vterm_get_attr_type(attr), type);
     return;
   }
@@ -128,7 +151,7 @@
 {
   VTermColor *colp = (attr == VTERM_ATTR_BACKGROUND) ? &state->pen.bg : &state->pen.fg;
 
-  lookup_colour_ansi(state, col, colp);
+  vterm_color_indexed(colp, col);
 
   setpenattr_col(state, attr, *colp);
 }
@@ -136,11 +159,12 @@
 INTERNAL void vterm_state_newpen(VTermState *state)
 {
   // 90% grey so that pure white is brighter
-  state->default_fg.red = state->default_fg.green = state->default_fg.blue = 240;
-  state->default_bg.red = state->default_bg.green = state->default_bg.blue = 0;
+  vterm_color_rgb(&state->default_fg, 240, 240, 240);
+  vterm_color_rgb(&state->default_bg, 0, 0, 0);
+  vterm_state_set_default_colors(state, &state->default_fg, &state->default_bg);
 
   for(int col = 0; col < 16; col++)
-    state->colors[col] = ansi_colors[col];
+    lookup_default_colour_ansi(col, &state->colors[col]);
 }
 
 INTERNAL void vterm_state_resetpen(VTermState *state)
@@ -153,8 +177,6 @@
   state->pen.strike = 0;    setpenattr_bool(state, VTERM_ATTR_STRIKE, 0);
   state->pen.font = 0;      setpenattr_int( state, VTERM_ATTR_FONT, 0);
 
-  state->fg_index = -1;
-  state->bg_index = -1;
   state->pen.fg = state->default_fg;  setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->default_fg);
   state->pen.bg = state->default_bg;  setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->default_bg);
 }
@@ -179,6 +201,26 @@
   }
 }
 
+int vterm_color_is_equal(const VTermColor *a, const VTermColor *b)
+{
+  /* First make sure that the two colours are of the same type (RGB/Indexed) */
+  if (a->type != b->type) {
+    return false;
+  }
+
+  /* Depending on the type inspect the corresponding members */
+  if (VTERM_COLOR_IS_INDEXED(a)) {
+    return a->indexed.idx == b->indexed.idx;
+  }
+  else if (VTERM_COLOR_IS_RGB(a)) {
+    return    (a->rgb.red   == b->rgb.red)
+           && (a->rgb.green == b->rgb.green)
+           && (a->rgb.blue  == b->rgb.blue);
+  }
+
+  return 0;
+}
+
 void vterm_state_get_default_colors(const VTermState *state, VTermColor *default_fg, VTermColor *default_bg)
 {
   *default_fg = state->default_fg;
@@ -192,8 +234,15 @@
 
 void vterm_state_set_default_colors(VTermState *state, const VTermColor *default_fg, const VTermColor *default_bg)
 {
+  /* Copy the given colors */
   state->default_fg = *default_fg;
   state->default_bg = *default_bg;
+
+  /* Make sure the correct type flags are set */
+  state->default_fg.type = (state->default_fg.type & ~VTERM_COLOR_DEFAULT_MASK)
+                         | VTERM_COLOR_DEFAULT_FG;
+  state->default_bg.type = (state->default_bg.type & ~VTERM_COLOR_DEFAULT_MASK)
+                         | VTERM_COLOR_DEFAULT_BG;
 }
 
 void vterm_state_set_palette_color(VTermState *state, int index, const VTermColor *col)
@@ -202,6 +251,14 @@
     state->colors[index] = *col;
 }
 
+void vterm_state_convert_color_to_rgb(const VTermState *state, VTermColor *col)
+{
+  if (VTERM_COLOR_IS_INDEXED(col)) { /* Convert indexed colors to RGB */
+    lookup_colour_palette(state, col->indexed.idx, col);
+  }
+  col->type &= VTERM_COLOR_TYPE_MASK; /* Reset any metadata but the type */
+}
+
 void vterm_state_set_bold_highbright(VTermState *state, int bold_is_highbright)
 {
   state->bold_is_highbright = bold_is_highbright;
@@ -226,12 +283,14 @@
       vterm_state_resetpen(state);
       break;
 
-    case 1: // Bold on
+    case 1: { // Bold on
+      const VTermColor *fg = &state->pen.fg;
       state->pen.bold = 1;
       setpenattr_bool(state, VTERM_ATTR_BOLD, 1);
-      if(state->fg_index > -1 && state->fg_index < 8 && state->bold_is_highbright)
-        set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, state->fg_index + (state->pen.bold ? 8 : 0));
+      if(!VTERM_COLOR_IS_DEFAULT_FG(fg) && VTERM_COLOR_IS_INDEXED(fg) && fg->indexed.idx < 8 && state->bold_is_highbright)
+        set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, fg->indexed.idx + (state->pen.bold ? 8 : 0));
       break;
+    }
 
     case 3: // Italic on
       state->pen.italic = 1;
@@ -302,22 +361,19 @@
     case 30: case 31: case 32: case 33:
     case 34: case 35: case 36: case 37: // Foreground colour palette
       value = CSI_ARG(args[argi]) - 30;
-      state->fg_index = value;
       if(state->pen.bold && state->bold_is_highbright)
         value += 8;
       set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value);
       break;
 
     case 38: // Foreground colour alternative palette
-      state->fg_index = -1;
       if(argcount - argi < 1)
         return;
-      argi += 1 + lookup_colour(state, CSI_ARG(args[argi+1]), args+argi+2, argcount-argi-2, &state->pen.fg, &state->fg_index);
+      argi += 1 + lookup_colour(state, CSI_ARG(args[argi+1]), args+argi+2, argcount-argi-2, &state->pen.fg);
       setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
       break;
 
     case 39: // Foreground colour default
-      state->fg_index = -1;
       state->pen.fg = state->default_fg;
       setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
       break;
@@ -325,20 +381,17 @@
     case 40: case 41: case 42: case 43:
     case 44: case 45: case 46: case 47: // Background colour palette
       value = CSI_ARG(args[argi]) - 40;
-      state->bg_index = value;
       set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value);
       break;
 
     case 48: // Background colour alternative palette
-      state->bg_index = -1;
       if(argcount - argi < 1)
         return;
-      argi += 1 + lookup_colour(state, CSI_ARG(args[argi+1]), args+argi+2, argcount-argi-2, &state->pen.bg, &state->bg_index);
+      argi += 1 + lookup_colour(state, CSI_ARG(args[argi+1]), args+argi+2, argcount-argi-2, &state->pen.bg);
       setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
       break;
 
     case 49: // Default background
-      state->bg_index = -1;
       state->pen.bg = state->default_bg;
       setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
       break;
@@ -346,14 +399,12 @@
     case 90: case 91: case 92: case 93:
     case 94: case 95: case 96: case 97: // Foreground colour high-intensity palette
       value = CSI_ARG(args[argi]) - 90 + 8;
-      state->fg_index = value;
       set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value);
       break;
 
     case 100: case 101: case 102: case 103:
     case 104: case 105: case 106: case 107: // Background colour high-intensity palette
       value = CSI_ARG(args[argi]) - 100 + 8;
-      state->bg_index = value;
       set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value);
       break;
 
@@ -363,12 +414,45 @@
     }
 
     if(!done)
-      fprintf(stderr, "libvterm: Unhandled CSI SGR %lu\n", arg);
+      DEBUG_LOG("libvterm: Unhandled CSI SGR %lu\n", arg);
 
     while(CSI_ARG_HAS_MORE(args[argi++]));
   }
 }
 
+static int vterm_state_getpen_color(const VTermColor *col, int argi, long args[], int fg)
+{
+    /* Do nothing if the given color is the default color */
+    if (( fg && VTERM_COLOR_IS_DEFAULT_FG(col)) ||
+        (!fg && VTERM_COLOR_IS_DEFAULT_BG(col))) {
+        return argi;
+    }
+
+    /* Decide whether to send an indexed color or an RGB color */
+    if (VTERM_COLOR_IS_INDEXED(col)) {
+        const uint8_t idx = col->indexed.idx;
+        if (idx < 8) {
+            args[argi++] = (idx + (fg ? 30 : 40));
+        }
+        else if (idx < 16) {
+            args[argi++] = (idx - 8 + (fg ? 90 : 100));
+        }
+        else {
+            args[argi++] = CSI_ARG_FLAG_MORE | (fg ? 38 : 48);
+            args[argi++] = CSI_ARG_FLAG_MORE | 5;
+            args[argi++] = idx;
+        }
+    }
+    else if (VTERM_COLOR_IS_RGB(col)) {
+        args[argi++] = CSI_ARG_FLAG_MORE | (fg ? 38 : 48);
+        args[argi++] = CSI_ARG_FLAG_MORE | 2;
+        args[argi++] = CSI_ARG_FLAG_MORE | col->rgb.red;
+        args[argi++] = CSI_ARG_FLAG_MORE | col->rgb.green;
+        args[argi++] = col->rgb.blue;
+    }
+    return argi;
+}
+
 INTERNAL int vterm_state_getpen(VTermState *state, long args[], int argcount)
 {
   int argi = 0;
@@ -397,25 +481,9 @@
   if(state->pen.underline == 2)
     args[argi++] = 21;
 
-  if(state->fg_index >= 0 && state->fg_index < 8)
-    args[argi++] = 30 + state->fg_index;
-  else if(state->fg_index >= 8 && state->fg_index < 16)
-    args[argi++] = 90 + state->fg_index - 8;
-  else if(state->fg_index >= 16 && state->fg_index < 256) {
-    args[argi++] = CSI_ARG_FLAG_MORE|38;
-    args[argi++] = CSI_ARG_FLAG_MORE|5;
-    args[argi++] = state->fg_index;
-  }
+  argi = vterm_state_getpen_color(&state->pen.fg, argi, args, true);
 
-  if(state->bg_index >= 0 && state->bg_index < 8)
-    args[argi++] = 40 + state->bg_index;
-  else if(state->bg_index >= 8 && state->bg_index < 16)
-    args[argi++] = 100 + state->bg_index - 8;
-  else if(state->bg_index >= 16 && state->bg_index < 256) {
-    args[argi++] = CSI_ARG_FLAG_MORE|48;
-    args[argi++] = CSI_ARG_FLAG_MORE|5;
-    args[argi++] = state->bg_index;
-  }
+  argi = vterm_state_getpen_color(&state->pen.bg, argi, args, false);
 
   return argi;
 }
@@ -458,6 +526,9 @@
   case VTERM_ATTR_BACKGROUND:
     val->color = state->pen.bg;
     return 1;
+
+  case VTERM_N_ATTRS:
+    return 0;
   }
 
   return 0;
diff --git a/src/screen.c b/src/screen.c
index c4de59e..1d4d86c 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -149,7 +149,7 @@
     return;
 
   default:
-    fprintf(stderr, "TODO: Maybe merge damage for level %d\n", screen->damage_merge);
+    DEBUG_LOG("TODO: Maybe merge damage for level %d\n", screen->damage_merge);
     return;
   }
 
@@ -266,7 +266,7 @@
 {
   VTermScreen *screen = user;
 
-  for(int row = rect.start_row; row < rect.end_row; row++) {
+  for(int row = rect.start_row; row < screen->state->rows && row < rect.end_row; row++) {
     const VTermLineInfo *info = vterm_state_get_lineinfo(screen->state, row);
 
     for(int col = rect.start_col; col < rect.end_col; col++) {
@@ -304,10 +304,10 @@
 {
   VTermScreen *screen = user;
 
-  vterm_scroll_rect(rect, downward, rightward,
-      moverect_internal, erase_internal, screen);
-
   if(screen->damage_merge != VTERM_DAMAGE_SCROLL) {
+    vterm_scroll_rect(rect, downward, rightward,
+        moverect_internal, erase_internal, screen);
+
     vterm_screen_flush_damage(screen);
 
     vterm_scroll_rect(rect, downward, rightward,
@@ -340,10 +340,14 @@
     screen->pending_scroll_rightward = rightward;
   }
 
+  vterm_scroll_rect(rect, downward, rightward,
+      moverect_internal, erase_internal, screen);
+
   if(screen->damaged.start_row == -1)
     return 1;
 
   if(rect_contains(&rect, &screen->damaged)) {
+    /* Scroll region entirely contains the damage; just move it */
     vterm_rect_move(&screen->damaged, -downward, -rightward);
     rect_clip(&screen->damaged, &rect);
   }
@@ -373,7 +377,7 @@
     }
   }
   else {
-    fprintf(stderr, "TODO: Just flush and redo damaged=" STRFrect " rect=" STRFrect "\n",
+    DEBUG_LOG("TODO: Just flush and redo damaged=" STRFrect " rect=" STRFrect "\n",
         ARGSrect(screen->damaged), ARGSrect(rect));
   }
 
@@ -422,6 +426,9 @@
   case VTERM_ATTR_BACKGROUND:
     screen->pen.bg = val->color;
     return 1;
+
+  case VTERM_N_ATTRS:
+    return 0;
   }
 
   return 0;
@@ -457,16 +464,6 @@
   return 1;
 }
 
-static int setmousefunc(VTermMouseFunc func, void *data, void *user)
-{
-  VTermScreen *screen = user;
-
-  if(screen->callbacks && screen->callbacks->setmousefunc)
-    return (*screen->callbacks->setmousefunc)(func, data, screen->cbdata);
-
-  return 0;
-}
-
 static int bell(void *user)
 {
   VTermScreen *screen = user;
@@ -490,8 +487,10 @@
     // Fewer rows - determine if we're going to scroll at all, and if so, push
     // those lines to scrollback
     VTermPos pos = { 0, 0 };
+    VTermPos cursor = screen->state->pos;
+    // Find the first blank row after the cursor.
     for(pos.row = old_rows - 1; pos.row >= new_rows; pos.row--)
-      if(!vterm_screen_is_eol(screen, pos))
+      if(!vterm_screen_is_eol(screen, pos) || cursor.row == pos.row)
         break;
 
     int first_blank_row = pos.row + 1;
@@ -609,16 +608,15 @@
 }
 
 static VTermStateCallbacks state_cbs = {
-  .putglyph     = &putglyph,
-  .movecursor   = &movecursor,
-  .scrollrect   = &scrollrect,
-  .erase        = &erase,
-  .setpenattr   = &setpenattr,
-  .settermprop  = &settermprop,
-  .setmousefunc = &setmousefunc,
-  .bell         = &bell,
-  .resize       = &resize,
-  .setlineinfo  = &setlineinfo,
+  .putglyph    = &putglyph,
+  .movecursor  = &movecursor,
+  .scrollrect  = &scrollrect,
+  .erase       = &erase,
+  .setpenattr  = &setpenattr,
+  .settermprop = &settermprop,
+  .bell        = &bell,
+  .resize      = &resize,
+  .setlineinfo = &setlineinfo,
 };
 
 static VTermScreen *screen_new(VTerm *vt)
@@ -642,6 +640,9 @@
   screen->rows = rows;
   screen->cols = cols;
 
+  screen->callbacks = NULL;
+  screen->cbdata    = NULL;
+
   screen->buffers[0] = realloc_buffer(screen, NULL, rows, cols);
 
   screen->buffer = screen->buffers[0];
@@ -839,6 +840,21 @@
   screen->cbdata = user;
 }
 
+void *vterm_screen_get_cbdata(VTermScreen *screen)
+{
+  return screen->cbdata;
+}
+
+void vterm_screen_set_unrecognised_fallbacks(VTermScreen *screen, const VTermParserCallbacks *fallbacks, void *user)
+{
+  vterm_state_set_unrecognised_fallbacks(screen->state, fallbacks, user);
+}
+
+void *vterm_screen_get_unrecognised_fbdata(VTermScreen *screen)
+{
+  return vterm_state_get_unrecognised_fbdata(screen->state);
+}
+
 void vterm_screen_flush_damage(VTermScreen *screen)
 {
   if(screen->pending_scrollrect.start_row != -1) {
@@ -878,9 +894,9 @@
     return 1;
   if((attrs & VTERM_ATTR_FONT_MASK)       && (a->pen.font != b->pen.font))
     return 1;
-  if((attrs & VTERM_ATTR_FOREGROUND_MASK) && !vterm_color_equal(a->pen.fg, b->pen.fg))
+  if((attrs & VTERM_ATTR_FOREGROUND_MASK) && !vterm_color_is_equal(&a->pen.fg, &b->pen.fg))
     return 1;
-  if((attrs & VTERM_ATTR_BACKGROUND_MASK) && !vterm_color_equal(a->pen.bg, b->pen.bg))
+  if((attrs & VTERM_ATTR_BACKGROUND_MASK) && !vterm_color_is_equal(&a->pen.bg, &b->pen.bg))
     return 1;
 
   return 0;
@@ -913,3 +929,8 @@
 
   return 1;
 }
+
+void vterm_screen_convert_color_to_rgb(const VTermScreen *screen, VTermColor *col)
+{
+  vterm_state_convert_color_to_rgb(screen->state, col);
+}
diff --git a/src/state.c b/src/state.c
index e42be53..68cc4f6 100644
--- a/src/state.c
+++ b/src/state.c
@@ -5,16 +5,10 @@
 
 #define strneq(a,b,n) (strncmp(a,b,n)==0)
 
-#include "utf8.h"
-
 #if defined(DEBUG) && DEBUG > 1
 # define DEBUG_GLYPH_COMBINE
 #endif
 
-#define MOUSE_WANT_CLICK 0x01
-#define MOUSE_WANT_DRAG  0x02
-#define MOUSE_WANT_MOVE  0x04
-
 /* Some convenient wrappers to make callback functions easier */
 
 static void putglyph(VTermState *state, const uint32_t chars[], int width, VTermPos pos)
@@ -31,7 +25,7 @@
     if((*state->callbacks->putglyph)(&info, pos, state->cbdata))
       return;
 
-  fprintf(stderr, "libvterm: Unhandled putglyph U+%04x at (%d,%d)\n", chars[0], pos.col, pos.row);
+  DEBUG_LOG("libvterm: Unhandled putglyph U+%04x at (%d,%d)\n", chars[0], pos.col, pos.row);
 }
 
 static void updatecursor(VTermState *state, VTermPos *oldpos, int cancel_phantom)
@@ -63,6 +57,15 @@
   state->rows = vt->rows;
   state->cols = vt->cols;
 
+  state->mouse_col     = 0;
+  state->mouse_row     = 0;
+  state->mouse_buttons = 0;
+
+  state->mouse_protocol = MOUSE_X10;
+
+  state->callbacks = NULL;
+  state->cbdata    = NULL;
+
   vterm_state_newpen(state);
 
   state->bold_is_highbright = 0;
@@ -83,6 +86,18 @@
   if(!downward && !rightward)
     return;
 
+  int rows = rect.end_row - rect.start_row;
+  if(downward > rows)
+    downward = rows;
+  else if(downward < -rows)
+    downward = -rows;
+
+  int cols = rect.end_col - rect.start_col;
+  if(rightward > cols)
+    rightward = cols;
+  else if(rightward < -cols)
+    rightward = -cols;
+
   // Update lineinfo if full line
   if(rect.start_col == 0 && rect.end_col == state->cols && rightward == 0) {
     int height = rect.end_row - rect.start_row - abs(downward);
@@ -153,15 +168,37 @@
   return state->tabstops[col >> 3] & mask;
 }
 
+static int is_cursor_in_scrollregion(const VTermState *state)
+{
+  if(state->pos.row < state->scrollregion_top ||
+     state->pos.row >= SCROLLREGION_BOTTOM(state))
+    return 0;
+  if(state->pos.col < SCROLLREGION_LEFT(state) ||
+     state->pos.col >= SCROLLREGION_RIGHT(state))
+    return 0;
+
+  return 1;
+}
+
 static void tab(VTermState *state, int count, int direction)
 {
-  while(count--)
-    while(state->pos.col >= 0 && state->pos.col < THISROWWIDTH(state)-1) {
-      state->pos.col += direction;
+  while(count > 0) {
+    if(direction > 0) {
+      if(state->pos.col >= THISROWWIDTH(state)-1)
+        return;
 
-      if(is_col_tabstop(state, state->pos.col))
-        break;
+      state->pos.col++;
     }
+    else if(direction < 0) {
+      if(state->pos.col < 1)
+        return;
+
+      state->pos.col--;
+    }
+
+    if(is_col_tabstop(state, state->pos.col))
+      count--;
+  }
 }
 
 #define NO_FORCE 0
@@ -219,6 +256,12 @@
       codepoints, &npoints, state->gsingle_set ? 1 : len,
       bytes, &eaten, len);
 
+  /* There's a chance an encoding (e.g. UTF-8) hasn't found enough bytes yet
+   * for even a single codepoint
+   */
+  if(!npoints)
+    return eaten;
+
   if(state->gsingle_set && npoints)
     state->gsingle_set = 0;
 
@@ -262,7 +305,7 @@
       putglyph(state, state->combine_chars, state->combine_width, state->combine_pos);
     }
     else {
-      fprintf(stderr, "libvterm: TODO: Skip over split char+combining\n");
+      DEBUG_LOG("libvterm: TODO: Skip over split char+combining\n");
     }
   }
 
@@ -280,7 +323,14 @@
 
     for( ; i < glyph_ends; i++) {
       chars[i - glyph_starts] = codepoints[i];
-      width += vterm_unicode_width(codepoints[i]);
+      int this_width = vterm_unicode_width(codepoints[i]);
+#ifdef DEBUG
+      if(this_width < 0) {
+        fprintf(stderr, "Text with negative-width codepoint U+%04x\n", codepoints[i]);
+        abort();
+      }
+#endif
+      width += this_width;
     }
 
     chars[glyph_ends - glyph_starts] = 0;
@@ -343,6 +393,15 @@
 
   updatecursor(state, &oldpos, 0);
 
+#ifdef DEBUG
+  if(state->pos.row < 0 || state->pos.row >= state->rows ||
+     state->pos.col < 0 || state->pos.col >= state->cols) {
+    fprintf(stderr, "Position out of bounds after text: (%d,%d)\n",
+        state->pos.row, state->pos.col);
+    abort();
+  }
+#endif
+
   return eaten;
 }
 
@@ -424,104 +483,27 @@
     break;
 
   default:
+    if(state->fallbacks && state->fallbacks->control)
+      if((*state->fallbacks->control)(control, state->fbdata))
+        return 1;
+
     return 0;
   }
 
   updatecursor(state, &oldpos, 1);
 
+#ifdef DEBUG
+  if(state->pos.row < 0 || state->pos.row >= state->rows ||
+     state->pos.col < 0 || state->pos.col >= state->cols) {
+    fprintf(stderr, "Position out of bounds after Ctrl %02x: (%d,%d)\n",
+        control, state->pos.row, state->pos.col);
+    abort();
+  }
+#endif
+
   return 1;
 }
 
-static void output_mouse(VTermState *state, int code, int pressed, int modifiers, int col, int row)
-{
-  modifiers <<= 2;
-
-  switch(state->mouse_protocol) {
-  case MOUSE_X10:
-    if(col + 0x21 > 0xff)
-      col = 0xff - 0x21;
-    if(row + 0x21 > 0xff)
-      row = 0xff - 0x21;
-
-    if(!pressed)
-      code = 3;
-
-    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%c%c%c",
-        (code | modifiers) + 0x20, col + 0x21, row + 0x21);
-    break;
-
-  case MOUSE_UTF8:
-    {
-      char utf8[18]; size_t len = 0;
-
-      if(!pressed)
-        code = 3;
-
-      len += fill_utf8((code | modifiers) + 0x20, utf8 + len);
-      len += fill_utf8(col + 0x21, utf8 + len);
-      len += fill_utf8(row + 0x21, utf8 + len);
-      utf8[len] = 0;
-
-      vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%s", utf8);
-    }
-    break;
-
-  case MOUSE_SGR:
-    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "<%d;%d;%d%c",
-        code | modifiers, col + 1, row + 1, pressed ? 'M' : 'm');
-    break;
-
-  case MOUSE_RXVT:
-    if(!pressed)
-      code = 3;
-
-    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%d;%d;%dM",
-        code | modifiers, col + 1, row + 1);
-    break;
-  }
-}
-
-static void mousefunc(int col, int row, int button, int pressed, int modifiers, void *data)
-{
-  VTermState *state = data;
-
-  int old_col     = state->mouse_col;
-  int old_row     = state->mouse_row;
-  int old_buttons = state->mouse_buttons;
-
-  state->mouse_col = col;
-  state->mouse_row = row;
-
-  if(button > 0 && button <= 3) {
-    if(pressed)
-      state->mouse_buttons |= (1 << (button-1));
-    else
-      state->mouse_buttons &= ~(1 << (button-1));
-  }
-
-  modifiers &= 0x7;
-
-
-  /* Most of the time we don't get button releases from 4/5 */
-  if(state->mouse_buttons != old_buttons || button >= 4) {
-    if(button < 4) {
-      output_mouse(state, button-1, pressed, modifiers, col, row);
-    }
-    else if(button < 6) {
-      output_mouse(state, button-4 + 0x40, pressed, modifiers, col, row);
-    }
-  }
-  else if(col != old_col || row != old_row) {
-    if((state->mouse_flags & MOUSE_WANT_DRAG && state->mouse_buttons) ||
-       (state->mouse_flags & MOUSE_WANT_MOVE)) {
-      int button = state->mouse_buttons & 0x01 ? 1 :
-                   state->mouse_buttons & 0x02 ? 2 :
-                   state->mouse_buttons & 0x04 ? 3 : 4;
-      output_mouse(state, button-1 + 0x20, 1, modifiers, col, row);
-    }
-  }
-}
-
 static int settermprop_bool(VTermState *state, VTermProp prop, int v)
 {
   VTermValue val = { .boolean = v };
@@ -722,7 +704,7 @@
     break;
 
   default:
-    fprintf(stderr, "libvterm: Unknown mode %d\n", num);
+    DEBUG_LOG("libvterm: Unknown mode %d\n", num);
     return;
   }
 }
@@ -774,26 +756,15 @@
   case 1000:
   case 1002:
   case 1003:
-    if(val) {
-      state->mouse_col     = 0;
-      state->mouse_row     = 0;
-      state->mouse_buttons = 0;
+    settermprop_int(state, VTERM_PROP_MOUSE,
+        !val          ? VTERM_PROP_MOUSE_NONE  :
+        (num == 1000) ? VTERM_PROP_MOUSE_CLICK :
+        (num == 1002) ? VTERM_PROP_MOUSE_DRAG  :
+                        VTERM_PROP_MOUSE_MOVE);
+    break;
 
-      state->mouse_flags = MOUSE_WANT_CLICK;
-      state->mouse_protocol = MOUSE_X10;
-
-      if(num == 1002)
-        state->mouse_flags |= MOUSE_WANT_DRAG;
-      if(num == 1003)
-        state->mouse_flags |= MOUSE_WANT_MOVE;
-    }
-    else {
-      state->mouse_flags = 0;
-    }
-
-    if(state->callbacks && state->callbacks->setmousefunc)
-      (*state->callbacks->setmousefunc)(val ? mousefunc : NULL, state, state->cbdata);
-
+  case 1004:
+    state->mode.report_focus = val;
     break;
 
   case 1005:
@@ -821,8 +792,12 @@
     savecursor(state, val);
     break;
 
+  case 2004:
+    state->mode.bracketpaste = val;
+    break;
+
   default:
-    fprintf(stderr, "libvterm: Unknown DEC mode %d\n", num);
+    DEBUG_LOG("libvterm: Unknown DEC mode %d\n", num);
     return;
   }
 }
@@ -872,6 +847,10 @@
       reply = state->mouse_flags == (MOUSE_WANT_CLICK|MOUSE_WANT_MOVE);
       break;
 
+    case 1004:
+      reply = state->mode.report_focus;
+      break;
+
     case 1005:
       reply = state->mouse_protocol == MOUSE_UTF8;
       break;
@@ -888,6 +867,10 @@
       reply = state->mode.alt_screen;
       break;
 
+    case 2004:
+      reply = state->mode.bracketpaste;
+      break;
+
     default:
       vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?%d;%d$y", num, 0);
       return;
@@ -901,6 +884,7 @@
   VTermState *state = user;
   int leader_byte = 0;
   int intermed_byte = 0;
+  int cancel_phantom = 1;
 
   if(leader && leader[0]) {
     if(leader[1]) // longer than 1 char
@@ -950,6 +934,9 @@
   case 0x40: // ICH - ECMA-48 8.3.64
     count = CSI_ARG_COUNT(args[0]);
 
+    if(!is_cursor_in_scrollregion(state))
+      break;
+
     rect.start_row = state->pos.row;
     rect.end_row   = state->pos.row + 1;
     rect.start_col = state->pos.col;
@@ -1093,6 +1080,9 @@
   case 0x4c: // IL - ECMA-48 8.3.67
     count = CSI_ARG_COUNT(args[0]);
 
+    if(!is_cursor_in_scrollregion(state))
+      break;
+
     rect.start_row = state->pos.row;
     rect.end_row   = SCROLLREGION_BOTTOM(state);
     rect.start_col = SCROLLREGION_LEFT(state);
@@ -1105,6 +1095,9 @@
   case 0x4d: // DL - ECMA-48 8.3.32
     count = CSI_ARG_COUNT(args[0]);
 
+    if(!is_cursor_in_scrollregion(state))
+      break;
+
     rect.start_row = state->pos.row;
     rect.end_row   = SCROLLREGION_BOTTOM(state);
     rect.start_col = SCROLLREGION_LEFT(state);
@@ -1117,6 +1110,9 @@
   case 0x50: // DCH - ECMA-48 8.3.26
     count = CSI_ARG_COUNT(args[0]);
 
+    if(!is_cursor_in_scrollregion(state))
+      break;
+
     rect.start_row = state->pos.row;
     rect.end_row   = state->pos.row + 1;
     rect.start_col = state->pos.col;
@@ -1182,6 +1178,24 @@
     state->at_phantom = 0;
     break;
 
+  case 0x62: { // REP - ECMA-48 8.3.103
+    const int row_width = THISROWWIDTH(state);
+    count = CSI_ARG_COUNT(args[0]);
+    col = state->pos.col + count;
+    UBOUND(col, row_width);
+    while (state->pos.col < col) {
+      putglyph(state, state->combine_chars, state->combine_width, state->pos);
+      state->pos.col += state->combine_width;
+    }
+    if (state->pos.col + state->combine_width >= row_width) {
+      if (state->mode.autowrap) {
+        state->at_phantom = 1;
+        cancel_phantom = 0;
+      }
+    }
+    break;
+  }
+
   case 0x63: // DA - ECMA-48 8.3.24
     val = CSI_ARG_OR(args[0], 0);
     if(val == 0)
@@ -1357,7 +1371,7 @@
   case 0x72: // DECSTBM - DEC custom
     state->scrollregion_top = CSI_ARG_OR(args[0], 1) - 1;
     state->scrollregion_bottom = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]);
-    LBOUND(state->scrollregion_top, -1);
+    LBOUND(state->scrollregion_top, 0);
     UBOUND(state->scrollregion_top, state->rows);
     LBOUND(state->scrollregion_bottom, -1);
     if(state->scrollregion_top == 0 && state->scrollregion_bottom == state->rows)
@@ -1365,13 +1379,19 @@
     else
       UBOUND(state->scrollregion_bottom, state->rows);
 
+    if(SCROLLREGION_BOTTOM(state) <= state->scrollregion_top) {
+      // Invalid
+      state->scrollregion_top    = 0;
+      state->scrollregion_bottom = -1;
+    }
+
     break;
 
   case 0x73: // DECSLRM - DEC custom
     // Always allow setting these margins, just they won't take effect without DECVSSM
     state->scrollregion_left = CSI_ARG_OR(args[0], 1) - 1;
     state->scrollregion_right = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]);
-    LBOUND(state->scrollregion_left, -1);
+    LBOUND(state->scrollregion_left, 0);
     UBOUND(state->scrollregion_left, state->cols);
     LBOUND(state->scrollregion_right, -1);
     if(state->scrollregion_left == 0 && state->scrollregion_right == state->cols)
@@ -1379,11 +1399,21 @@
     else
       UBOUND(state->scrollregion_right, state->cols);
 
+    if(state->scrollregion_right > -1 &&
+       state->scrollregion_right <= state->scrollregion_left) {
+      // Invalid
+      state->scrollregion_left  = 0;
+      state->scrollregion_right = -1;
+    }
+
     break;
 
   case INTERMED('\'', 0x7D): // DECIC
     count = CSI_ARG_COUNT(args[0]);
 
+    if(!is_cursor_in_scrollregion(state))
+      break;
+
     rect.start_row = state->scrollregion_top;
     rect.end_row   = SCROLLREGION_BOTTOM(state);
     rect.start_col = state->pos.col;
@@ -1396,6 +1426,9 @@
   case INTERMED('\'', 0x7E): // DECDC
     count = CSI_ARG_COUNT(args[0]);
 
+    if(!is_cursor_in_scrollregion(state))
+      break;
+
     rect.start_row = state->scrollregion_top;
     rect.end_row   = SCROLLREGION_BOTTOM(state);
     rect.start_col = state->pos.col;
@@ -1406,12 +1439,16 @@
     break;
 
   default:
+    if(state->fallbacks && state->fallbacks->csi)
+      if((*state->fallbacks->csi)(leader, args, argcount, intermed, command, state->fbdata))
+        return 1;
+
     return 0;
   }
 
   if(state->mode.origin) {
     LBOUND(state->pos.row, state->scrollregion_top);
-    UBOUND(state->pos.row, state->scrollregion_bottom-1);
+    UBOUND(state->pos.row, SCROLLREGION_BOTTOM(state)-1);
     LBOUND(state->pos.col, SCROLLREGION_LEFT(state));
     UBOUND(state->pos.col, SCROLLREGION_RIGHT(state)-1);
   }
@@ -1422,7 +1459,28 @@
     UBOUND(state->pos.col, THISROWWIDTH(state)-1);
   }
 
-  updatecursor(state, &oldpos, 1);
+  updatecursor(state, &oldpos, cancel_phantom);
+
+#ifdef DEBUG
+  if(state->pos.row < 0 || state->pos.row >= state->rows ||
+     state->pos.col < 0 || state->pos.col >= state->cols) {
+    fprintf(stderr, "Position out of bounds after CSI %c: (%d,%d)\n",
+        command, state->pos.row, state->pos.col);
+    abort();
+  }
+
+  if(SCROLLREGION_BOTTOM(state) <= state->scrollregion_top) {
+    fprintf(stderr, "Scroll region height out of bounds after CSI %c: %d <= %d\n",
+        command, SCROLLREGION_BOTTOM(state), state->scrollregion_top);
+    abort();
+  }
+
+  if(SCROLLREGION_RIGHT(state) <= SCROLLREGION_LEFT(state)) {
+    fprintf(stderr, "Scroll region width out of bounds after CSI %c: %d <= %d\n",
+        command, SCROLLREGION_RIGHT(state), SCROLLREGION_LEFT(state));
+    abort();
+  }
+#endif
 
   return 1;
 }
@@ -1447,6 +1505,9 @@
     settermprop_string(state, VTERM_PROP_TITLE, command + 2, cmdlen - 2);
     return 1;
   }
+  else if(state->fallbacks && state->fallbacks->osc)
+    if((*state->fallbacks->osc)(command, cmdlen, state->fbdata))
+      return 1;
 
   return 0;
 }
@@ -1508,6 +1569,9 @@
     request_status_string(state, command+2, cmdlen-2);
     return 1;
   }
+  else if(state->fallbacks && state->fallbacks->dcs)
+    if((*state->fallbacks->dcs)(command, cmdlen, state->fbdata))
+      return 1;
 
   return 0;
 }
@@ -1563,6 +1627,11 @@
   state->rows = rows;
   state->cols = cols;
 
+  if(state->scrollregion_bottom > -1)
+    UBOUND(state->scrollregion_bottom, state->rows);
+  if(state->scrollregion_right > -1)
+    UBOUND(state->scrollregion_right, state->cols);
+
   VTermPos delta = { 0, 0 };
 
   if(state->callbacks && state->callbacks->resize)
@@ -1615,7 +1684,7 @@
   if(*state->encoding_utf8.enc->init)
     (*state->encoding_utf8.enc->init)(state->encoding_utf8.enc, state->encoding_utf8.data);
 
-  vterm_set_parser_callbacks(vt, &parser_callbacks, state);
+  vterm_parser_set_callbacks(vt, &parser_callbacks, state);
 
   return state;
 }
@@ -1635,6 +1704,8 @@
   state->mode.alt_screen      = 0;
   state->mode.origin          = 0;
   state->mode.leftrightmargin = 0;
+  state->mode.bracketpaste    = 0;
+  state->mode.report_focus    = 0;
 
   state->vt->mode.ctrl8bit   = 0;
 
@@ -1703,6 +1774,28 @@
   }
 }
 
+void *vterm_state_get_cbdata(VTermState *state)
+{
+  return state->cbdata;
+}
+
+void vterm_state_set_unrecognised_fallbacks(VTermState *state, const VTermParserCallbacks *fallbacks, void *user)
+{
+  if(fallbacks) {
+    state->fallbacks = fallbacks;
+    state->fbdata = user;
+  }
+  else {
+    state->fallbacks = NULL;
+    state->fbdata = NULL;
+  }
+}
+
+void *vterm_state_get_unrecognised_fbdata(VTermState *state)
+{
+  return state->fbdata;
+}
+
 int vterm_state_set_termprop(VTermState *state, VTermProp prop, VTermValue *val)
 {
   /* Only store the new value of the property if usercode said it was happy.
@@ -1740,11 +1833,35 @@
       erase(state, rect, 0);
     }
     return 1;
+  case VTERM_PROP_MOUSE:
+    state->mouse_flags = 0;
+    if(val->number)
+      state->mouse_flags |= MOUSE_WANT_CLICK;
+    if(val->number == VTERM_PROP_MOUSE_DRAG)
+      state->mouse_flags |= MOUSE_WANT_DRAG;
+    if(val->number == VTERM_PROP_MOUSE_MOVE)
+      state->mouse_flags |= MOUSE_WANT_MOVE;
+    return 1;
+
+  case VTERM_N_PROPS:
+    return 0;
   }
 
   return 0;
 }
 
+void vterm_state_focus_in(VTermState *state)
+{
+  if(state->mode.report_focus)
+    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "I");
+}
+
+void vterm_state_focus_out(VTermState *state)
+{
+  if(state->mode.report_focus)
+    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "O");
+}
+
 const VTermLineInfo *vterm_state_get_lineinfo(const VTermState *state, int row)
 {
   return state->lineinfo + row;
diff --git a/src/unicode.c b/src/unicode.c
index 69b7682..0d1b5ff 100644
--- a/src/unicode.c
+++ b/src/unicode.c
@@ -67,8 +67,6 @@
  * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
  */
 
-#include <wchar.h>
-
 struct interval {
   int first;
   int last;
@@ -129,7 +127,7 @@
 
 
 /* auxiliary function for binary search in interval table */
-static int bisearch(wchar_t ucs, const struct interval *table, int max) {
+static int bisearch(uint32_t ucs, const struct interval *table, int max) {
   int min = 0;
   int mid;
 
@@ -177,12 +175,12 @@
  *      ISO 8859-1 and WGL4 characters, Unicode control characters,
  *      etc.) have a column width of 1.
  *
- * This implementation assumes that wchar_t characters are encoded
+ * This implementation assumes that uint32_t characters are encoded
  * in ISO 10646.
  */
 
 
-static int mk_wcwidth(wchar_t ucs)
+static int mk_wcwidth(uint32_t ucs)
 {
   /* test for 8-bit control characters */
   if (ucs == 0)
@@ -214,7 +212,7 @@
 }
 
 
-static int mk_wcswidth(const wchar_t *pwcs, size_t n)
+static int mk_wcswidth(const uint32_t *pwcs, size_t n)
 {
   int w, width = 0;
 
@@ -237,7 +235,7 @@
  * the traditional terminal character-width behaviour. It is not
  * otherwise recommended for general use.
  */
-static int mk_wcwidth_cjk(wchar_t ucs)
+static int mk_wcwidth_cjk(uint32_t ucs)
 {
   /* sorted list of non-overlapping intervals of East Asian Ambiguous
    * characters, generated by "uniset +WIDTH-A -cat=Me -cat=Mn -cat=Cf c" */
@@ -305,7 +303,7 @@
 }
 
 
-static int mk_wcswidth_cjk(const wchar_t *pwcs, size_t n)
+static int mk_wcswidth_cjk(const uint32_t *pwcs, size_t n)
 {
   int w, width = 0;
 
@@ -321,12 +319,19 @@
 // ################################
 // ### The rest added by Paul Evans
 
-INTERNAL int vterm_unicode_width(int codepoint)
+static const struct interval fullwidth[] = {
+#include "fullwidth.inc"
+};
+
+INTERNAL int vterm_unicode_width(uint32_t codepoint)
 {
+  if(bisearch(codepoint, fullwidth, sizeof(fullwidth) / sizeof(fullwidth[0]) - 1))
+    return 2;
+
   return mk_wcwidth(codepoint);
 }
 
-INTERNAL int vterm_unicode_is_combining(int codepoint)
+INTERNAL int vterm_unicode_is_combining(uint32_t codepoint)
 {
   return bisearch(codepoint, combining, sizeof(combining) / sizeof(struct interval) - 1);
 }
diff --git a/src/vterm.c b/src/vterm.c
index 04651d3..843bb47 100644
--- a/src/vterm.c
+++ b/src/vterm.c
@@ -43,11 +43,14 @@
   vt->rows = rows;
   vt->cols = cols;
 
-  vt->parser_state = NORMAL;
+  vt->parser.state = NORMAL;
 
-  vt->strbuffer_len = 64;
-  vt->strbuffer_cur = 0;
-  vt->strbuffer = vterm_allocator_malloc(vt, vt->strbuffer_len);
+  vt->parser.callbacks = NULL;
+  vt->parser.cbdata    = NULL;
+
+  vt->parser.strbuffer_len = 64;
+  vt->parser.strbuffer_cur = 0;
+  vt->parser.strbuffer = vterm_allocator_malloc(vt, vt->parser.strbuffer_len);
 
   vt->outbuffer_len = 64;
   vt->outbuffer_cur = 0;
@@ -64,7 +67,7 @@
   if(vt->state)
     vterm_state_free(vt->state);
 
-  vterm_allocator_free(vt, vt->strbuffer);
+  vterm_allocator_free(vt, vt->parser.strbuffer);
   vterm_allocator_free(vt, vt->outbuffer);
 
   vterm_allocator_free(vt, vt);
@@ -93,17 +96,16 @@
   vt->rows = rows;
   vt->cols = cols;
 
-  if(vt->parser_callbacks && vt->parser_callbacks->resize)
-    (*vt->parser_callbacks->resize)(rows, cols, vt->cbdata);
+  if(vt->parser.callbacks && vt->parser.callbacks->resize)
+    (*vt->parser.callbacks->resize)(rows, cols, vt->parser.cbdata);
 }
 
-void vterm_set_parser_callbacks(VTerm *vt, const VTermParserCallbacks *callbacks, void *user)
+int vterm_get_utf8(const VTerm *vt)
 {
-  vt->parser_callbacks = callbacks;
-  vt->cbdata = user;
+  return vt->mode.utf8;
 }
 
-void vterm_parser_set_utf8(VTerm *vt, int is_utf8)
+void vterm_set_utf8(VTerm *vt, int is_utf8)
 {
   vt->mode.utf8 = is_utf8;
 }
@@ -111,7 +113,7 @@
 INTERNAL void vterm_push_output_bytes(VTerm *vt, const char *bytes, size_t len)
 {
   if(len > vt->outbuffer_len - vt->outbuffer_cur) {
-    fprintf(stderr, "vterm_push_output(): buffer overflow; truncating output\n");
+    DEBUG_LOG("vterm_push_output(): buffer overflow; truncating output\n");
     len = vt->outbuffer_len - vt->outbuffer_cur;
   }
 
@@ -119,12 +121,28 @@
   vt->outbuffer_cur += len;
 }
 
+static int outbuffer_is_full(VTerm *vt)
+{
+  return vt->outbuffer_cur >= vt->outbuffer_len - 1;
+}
+
 INTERNAL void vterm_push_output_vsprintf(VTerm *vt, const char *format, va_list args)
 {
+  if(outbuffer_is_full(vt)) {
+    DEBUG_LOG("vterm_push_output(): buffer overflow; truncating output\n");
+    return;
+  }
+
   int written = vsnprintf(vt->outbuffer + vt->outbuffer_cur,
       vt->outbuffer_len - vt->outbuffer_cur,
       format, args);
-  vt->outbuffer_cur += written;
+
+  if(written == vt->outbuffer_len - vt->outbuffer_cur) {
+    /* output was truncated */
+    vt->outbuffer_cur = vt->outbuffer_len - 1;
+  }
+  else
+    vt->outbuffer_cur += written;
 }
 
 INTERNAL void vterm_push_output_sprintf(VTerm *vt, const char *format, ...)
@@ -137,8 +155,10 @@
 
 INTERNAL void vterm_push_output_sprintf_ctrl(VTerm *vt, unsigned char ctrl, const char *fmt, ...)
 {
+  size_t orig_cur = vt->outbuffer_cur;
+
   if(ctrl >= 0x80 && !vt->mode.ctrl8bit)
-    vterm_push_output_sprintf(vt, "\e%c", ctrl - 0x40);
+    vterm_push_output_sprintf(vt, ESC_S "%c", ctrl - 0x40);
   else
     vterm_push_output_sprintf(vt, "%c", ctrl);
 
@@ -146,12 +166,17 @@
   va_start(args, fmt);
   vterm_push_output_vsprintf(vt, fmt, args);
   va_end(args);
+
+  if(outbuffer_is_full(vt))
+    vt->outbuffer_cur = orig_cur;
 }
 
 INTERNAL void vterm_push_output_sprintf_dcs(VTerm *vt, const char *fmt, ...)
 {
+  size_t orig_cur = vt->outbuffer_cur;
+
   if(!vt->mode.ctrl8bit)
-    vterm_push_output_sprintf(vt, "\e%c", C1_DCS - 0x40);
+    vterm_push_output_sprintf(vt, ESC_S "%c", C1_DCS - 0x40);
   else
     vterm_push_output_sprintf(vt, "%c", C1_DCS);
 
@@ -161,11 +186,9 @@
   va_end(args);
 
   vterm_push_output_sprintf_ctrl(vt, C1_ST, "");
-}
 
-size_t vterm_output_bufferlen(VTerm *vt)
-{
-  return vterm_output_get_buffer_current(vt);
+  if(outbuffer_is_full(vt))
+    vt->outbuffer_cur = orig_cur;
 }
 
 size_t vterm_output_get_buffer_size(const VTerm *vt)
@@ -183,7 +206,7 @@
   return vt->outbuffer_len - vt->outbuffer_cur;
 }
 
-size_t vterm_output_bufferread(VTerm *vt, char *buffer, size_t len)
+size_t vterm_output_read(VTerm *vt, char *buffer, size_t len)
 {
   if(len > vt->outbuffer_cur)
     len = vt->outbuffer_cur;
@@ -210,6 +233,8 @@
     case VTERM_ATTR_FONT:       return VTERM_VALUETYPE_INT;
     case VTERM_ATTR_FOREGROUND: return VTERM_VALUETYPE_COLOR;
     case VTERM_ATTR_BACKGROUND: return VTERM_VALUETYPE_COLOR;
+
+    case VTERM_N_ATTRS: return 0;
   }
   return 0; /* UNREACHABLE */
 }
@@ -224,6 +249,9 @@
     case VTERM_PROP_ICONNAME:      return VTERM_VALUETYPE_STRING;
     case VTERM_PROP_REVERSE:       return VTERM_VALUETYPE_BOOL;
     case VTERM_PROP_CURSORSHAPE:   return VTERM_VALUETYPE_INT;
+    case VTERM_PROP_MOUSE:         return VTERM_VALUETYPE_INT;
+
+    case VTERM_N_PROPS: return 0;
   }
   return 0; /* UNREACHABLE */
 }
diff --git a/src/vterm_internal.h b/src/vterm_internal.h
index 4bc8e6b..363faee 100644
--- a/src/vterm_internal.h
+++ b/src/vterm_internal.h
@@ -11,6 +11,19 @@
 # define INTERNAL
 #endif
 
+#ifdef DEBUG
+# define DEBUG_LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+# define DEBUG_LOG(...)
+#endif
+
+#define ESC_S "\x1b"
+
+#define INTERMED_MAX 16
+
+#define CSI_ARGS_MAX 16
+#define CSI_LEADER_MAX 16
+
 typedef struct VTermEncoding VTermEncoding;
 
 typedef struct {
@@ -33,11 +46,6 @@
   unsigned int font:4; /* To store 0-9 */
 };
 
-static inline int vterm_color_equal(VTermColor a, VTermColor b)
-{
-  return a.red == b.red && a.green == b.green && a.blue == b.blue;
-}
-
 struct VTermState
 {
   VTerm *vt;
@@ -45,6 +53,9 @@
   const VTermStateCallbacks *callbacks;
   void *cbdata;
 
+  const VTermParserCallbacks *fallbacks;
+  void *fbdata;
+
   int rows;
   int cols;
 
@@ -72,6 +83,10 @@
   int mouse_col, mouse_row;
   int mouse_buttons;
   int mouse_flags;
+#define MOUSE_WANT_CLICK 0x01
+#define MOUSE_WANT_DRAG  0x02
+#define MOUSE_WANT_MOVE  0x04
+
   enum { MOUSE_X10, MOUSE_UTF8, MOUSE_SGR, MOUSE_RXVT } mouse_protocol;
 
   /* Last glyph output, for Unicode recombining purposes */
@@ -81,18 +96,20 @@
   VTermPos combine_pos;   // Position before movement
 
   struct {
-    int keypad:1;
-    int cursor:1;
-    int autowrap:1;
-    int insert:1;
-    int newline:1;
-    int cursor_visible:1;
-    int cursor_blink:1;
+    unsigned int keypad:1;
+    unsigned int cursor:1;
+    unsigned int autowrap:1;
+    unsigned int insert:1;
+    unsigned int newline:1;
+    unsigned int cursor_visible:1;
+    unsigned int cursor_blink:1;
     unsigned int cursor_shape:2;
-    int alt_screen:1;
-    int origin:1;
-    int screen:1;
-    int leftrightmargin:1;
+    unsigned int alt_screen:1;
+    unsigned int origin:1;
+    unsigned int screen:1;
+    unsigned int leftrightmargin:1;
+    unsigned int bracketpaste:1;
+    unsigned int report_focus:1;
   } mode;
 
   VTermEncodingInstance encoding[4], encoding_utf8;
@@ -104,8 +121,6 @@
   VTermColor default_bg;
   VTermColor colors[16]; // Store the 8 ANSI and the 8 ANSI high-brights only
 
-  int fg_index;
-  int bg_index;
   int bold_is_highbright;
 
   unsigned int protected_cell : 1;
@@ -116,13 +131,20 @@
     struct VTermPen pen;
 
     struct {
-      int cursor_visible:1;
-      int cursor_blink:1;
+      unsigned int cursor_visible:1;
+      unsigned int cursor_blink:1;
       unsigned int cursor_shape:2;
     } mode;
   } saved;
 };
 
+typedef enum {
+  VTERM_PARSER_OSC,
+  VTERM_PARSER_DCS,
+
+  VTERM_N_PARSER_TYPES
+} VTermParserStringType;
+
 struct VTerm
 {
   VTermAllocatorFunctions *allocator;
@@ -132,26 +154,41 @@
   int cols;
 
   struct {
-    int utf8:1;
-    int ctrl8bit:1;
+    unsigned int utf8:1;
+    unsigned int ctrl8bit:1;
   } mode;
 
-  enum VTermParserState {
-    NORMAL,
-    CSI,
-    OSC,
-    DCS,
-    ESC,
-    ESC_IN_OSC,
-    ESC_IN_DCS,
-  } parser_state;
-  const VTermParserCallbacks *parser_callbacks;
-  void *cbdata;
+  struct {
+    enum VTermParserState {
+      NORMAL,
+      CSI_LEADER,
+      CSI_ARGS,
+      CSI_INTERMED,
+      ESC,
+      /* below here are the "string states" */
+      STRING,
+      ESC_IN_STRING,
+    } state;
+
+    int intermedlen;
+    char intermed[INTERMED_MAX];
+
+    int csi_leaderlen;
+    char csi_leader[CSI_LEADER_MAX];
+
+    int csi_argi;
+    long csi_args[CSI_ARGS_MAX];
+
+    const VTermParserCallbacks *callbacks;
+    void *cbdata;
+
+    VTermParserStringType stringtype;
+    char  *strbuffer;
+    size_t strbuffer_len;
+    size_t strbuffer_cur;
+  } parser;
 
   /* len == malloc()ed size; cur == number of valid bytes */
-  char  *strbuffer;
-  size_t strbuffer_len;
-  size_t strbuffer_cur;
 
   char  *outbuffer;
   size_t outbuffer_len;
@@ -203,7 +240,7 @@
 
 VTermEncoding *vterm_lookup_encoding(VTermEncodingType type, char designation);
 
-int vterm_unicode_width(int codepoint);
-int vterm_unicode_is_combining(int codepoint);
+int vterm_unicode_width(uint32_t codepoint);
+int vterm_unicode_is_combining(uint32_t codepoint);
 
 #endif