Merge pull request #8455 from UtkarshMe/grid-split

implement ext_multigrid: draw each window on a separate resizable grid.

45 files changed, 3280 insertions, 1144 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5aadbd1ffb..32cbe8472e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -116,9 +116,9 @@ set(NVIM_VERSION_PATCH 0)
 set(NVIM_VERSION_PRERELEASE "-dev") # for package maintainers
 
 # API level
-set(NVIM_API_LEVEL 5)         # Bump this after any API change.
+set(NVIM_API_LEVEL 6)         # Bump this after any API change.
 set(NVIM_API_LEVEL_COMPAT 0)  # Adjust this after a _breaking_ API change.
-set(NVIM_API_PRERELEASE false)
+set(NVIM_API_PRERELEASE true)
 
 file(TO_CMAKE_PATH ${CMAKE_CURRENT_LIST_DIR}/.git FORCED_GIT_DIR)
 include(GetGitRevisionDescription)
diff --git a/runtime/doc/ui.txt b/runtime/doc/ui.txt
index c021f236c8..9acd8b2c5a 100644
--- a/runtime/doc/ui.txt
+++ b/runtime/doc/ui.txt
@@ -12,9 +12,10 @@ Nvim UI protocol							  *ui*
 UI Events							    *ui-events*
 
 GUIs can be implemented as external processes communicating with Nvim over the
-RPC API. The UI model consists of a terminal-like grid with a single,
-monospace font size. Some elements (UI "widgets") can be drawn separately from
-the grid ("externalized").
+RPC API. The default UI model consists of a terminal-like grid with a single,
+monospace font size. The UI can opt-in to have windows drawn on separate
+grids, as well as to have some elements (UI "widgets") be drawn by the UI
+itself rather than by nvim ("externalized").
 
 
 								  *ui-options*
@@ -32,6 +33,7 @@ a dictionary with these (optional) keys:
 	`ext_cmdline`		Externalize the cmdline. |ui-cmdline|
 	`ext_wildmenu`		Externalize the wildmenu. |ui-wildmenu|
 	`ext_linegrid`		Use new revision of the grid events. |ui-linegrid|
+	`ext_multigrid`		Use per-window grid based events. |ui-multigrid|
 	`ext_hlstate`		Use detailed highlight state. |ui-hlstate|
 
 Specifying a non-existent option is an error. UIs can check the |api-metadata|
@@ -46,7 +48,7 @@ Each update event is itself an array whose first element is the event name and
 remaining elements are event-parameter tuples. This allows multiple events of
 the same kind to be sent in a row without the event name being repeated. This
 batching is mostly used for "grid_line", because each "grid_line" event puts
-contents in one screen line, but clients must be prepared for multiple argument
+contents in one grid line, but clients must be prepared for multiple argument
 sets being batched for all event kinds.
 
 Events must be handled in-order. A "flush" event is sent when nvim is done
@@ -61,10 +63,12 @@ By default, Nvim sends |ui-global| and |ui-grid-old| events; these suffice to
 implement a terminal-like interface. However there are two revisions of the
 grid part of the protocol. The newer revision |ui-linegrid|, enabled by
 `ext_linegrid` option, has a more effecient representation of text (especially
-highlighted text), and room for futher enhancements that will use
-multiple grids. The older revision is available and used by default only for
-backwards compatibility reasons. New UIs are strongly recommended to use
-|ui-linegrid|, as further protocol extensions will require it.
+highlighted text), and allows extensions that use multiple grids.
+
+The older revision is available and used by default only for backwards
+compatibility reasons. New UIs are strongly recommended to use |ui-linegrid|,
+as further protocol extensions require it. The |ui-multigrid| extension
+enables |ui-linegrid| implicitly.
 
 Nvim optionally sends screen elements "semantically" as structured events
 instead of raw grid-lines, controlled by |ui-ext-options|. The UI must present
@@ -220,7 +224,8 @@ Most of these events take a `grid` index as first parameter.  Grid 1 is the
 global grid used by default for the entire editor screen state. Grids other
 than that will be defined by future extensions. Just activating the
 `ext_linegrid` option by itself will never cause any additional grids to be
-created.
+created.  To enable per-window grids, `ext_multigrid` option should be set (see
+|ui-multigrid|).
 
 Highlight attribute groups are predefined. UIs should maintain a table to map
 numerical highlight `id`:s to the actual attributes.
@@ -476,18 +481,65 @@ highlight group is cleared, so `ui_name` can always be used to reliably identify
 screen elements, even if no attributes have been applied.
 
 ==============================================================================
+Multigrid Events 	  					 *ui-multigrid*
+
+Only sent if `ext_multigrid` option is set in |ui-options|. Enables the
+`ext_linegrid` extension implicitly.
+
+The multigrid extension gives the UIs more control over how windows are
+displayed. The UIs receive updates on a separate grid for each window. The UIs
+can set the grid size independently of how much space the window occupies on
+the global layout. This enables the UIs to set a different font size for each
+window if the UI so desires. The UI can also reserve space around the border
+of the window for its own elements, for instance scrollbars from the UI
+toolkit.
+
+By default, the grid size is handled by nvim and set to the outer grid size
+(i.e. the size of the window frame in nvim) whenever the split is created.
+Once a UI sets a grid size, nvim does not handle the size for that grid and
+the UI must change the grid size whenever the outer size is changed. To
+delegate the handling of grid size back to nvim, the UIs should request the
+size (0, 0).
+
+A window can be hidden and redisplayed without its grid being deallocated.
+This can happen multiple times for the same window, for instance when switching
+tabs.
+
+["win_pos", grid, win, start_row, start_col, width, height]
+	Set the position and size of the grid in nvim (i.e. the outer grid
+	size). If the window was previously hidden, it should now be shown
+	again.
+
+["win_hide", grid]
+	Stop displaying the window.
+
+["win_scroll_over_start"]
+	Hint that following `grid_scroll` on the default grid should
+	scroll over windows. This is a temporary workaround to allow
+	UIs to use the builtin message drawing. Later on, messages will be
+	drawn on a dedicated grid.
+
+["win_scroll_over_reset"]
+	Hint that scrolled over windows should be redrawn again, and not be
+	overdrawn by default grid scrolling anymore.
+
+See |ui-linegrid| for grid events.
+See |nvim_ui_try_resize_grid| in |api-ui| to request changing the grid size.
+
+==============================================================================
 Popupmenu Events						 *ui-popupmenu*
 
 Only sent if `ext_popupmenu` option is set in |ui-options|
 
-["popupmenu_show", items, selected, row, col]
+["popupmenu_show", items, selected, row, col, grid]
 	Show |popupmenu-completion|. `items` is an array of completion items
 	to show; each item is an array of the form [word, kind, menu, info] as
 	defined at |complete-items|, except that `word` is replaced by `abbr`
 	if present.  `selected` is the initially-selected item, a zero-based
 	index into the array of items (-1 if no item is selected). `row` and
 	`col` give the anchor position, where the first character of the
-	completed word will be.
+	completed word will be. When |ui-multigrid| is used, `grid` is the
+	grid for the anchor position.
 
 ["popupmenu_select", selected]
 	Select an item in the current popupmenu. `selected` is a zero-based
diff --git a/src/nvim/api/private/defs.h b/src/nvim/api/private/defs.h
index 390b7e8363..feca140547 100644
--- a/src/nvim/api/private/defs.h
+++ b/src/nvim/api/private/defs.h
@@ -6,6 +6,7 @@
 #include <string.h>
 
 #include "nvim/func_attr.h"
+#include "nvim/types.h"
 
 #define ARRAY_DICT_INIT {.size = 0, .capacity = 0, .items = NULL}
 #define STRING_INIT {.data = NULL, .size = 0}
@@ -20,8 +21,6 @@
 # define DictionaryOf(...) Dictionary
 #endif
 
-typedef int handle_T;
-
 // Basic types
 typedef enum {
   kErrorTypeNone = -1,
diff --git a/src/nvim/api/ui.c b/src/nvim/api/ui.c
index 01f8c9f71c..7ba5251c60 100644
--- a/src/nvim/api/ui.c
+++ b/src/nvim/api/ui.c
@@ -126,7 +126,7 @@ void nvim_ui_attach(uint64_t channel_id, Integer width, Integer height,
     }
   }
 
-  if (ui->ui_ext[kUIHlState]) {
+  if (ui->ui_ext[kUIHlState] || ui->ui_ext[kUIMultigrid]) {
     ui->ui_ext[kUILinegrid] = true;
   }
 
@@ -245,6 +245,28 @@ static void ui_set_option(UI *ui, bool init, String name, Object value,
                 name.data);
 }
 
+/// Tell nvim to resize a grid. Nvim sends grid_resize event with the
+/// requested grid size is within size limits and with maximum allowed size
+/// otherwise.
+///
+/// On invalid grid handle, fails with error.
+///
+/// @param grid    The handle of the grid to be changed.
+/// @param width   The new requested width.
+/// @param height  The new requested height.
+void nvim_ui_try_resize_grid(uint64_t channel_id, Integer grid, Integer width,
+                             Integer height, Error *error)
+  FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY
+{
+  if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
+    api_set_error(error, kErrorTypeException,
+                  "UI not attached to channel: %" PRId64, channel_id);
+    return;
+  }
+
+  ui_grid_resize((handle_T)grid, (int)width, (int)height, error);
+}
+
 /// Pushes data into UI.UIData, to be consumed later by remote_ui_flush().
 static void push_call(UI *ui, const char *name, Array args)
 {
diff --git a/src/nvim/api/ui_events.in.h b/src/nvim/api/ui_events.in.h
index 10331fd5c2..59a7780651 100644
--- a/src/nvim/api/ui_events.in.h
+++ b/src/nvim/api/ui_events.in.h
@@ -81,8 +81,21 @@ void grid_line(Integer grid, Integer row, Integer col_start, Array data)
 void grid_scroll(Integer grid, Integer top, Integer bot,
                  Integer left, Integer right, Integer rows, Integer cols)
   FUNC_API_SINCE(5) FUNC_API_REMOTE_IMPL;
+void grid_destroy(Integer grid)
+  FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
 
-void popupmenu_show(Array items, Integer selected, Integer row, Integer col)
+void win_pos(Integer grid, Integer win, Integer startrow,
+             Integer startcol, Integer width, Integer height)
+  FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
+void win_hide(Integer grid)
+  FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
+void win_scroll_over_start(void)
+  FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
+void win_scroll_over_reset(void)
+  FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
+
+void popupmenu_show(Array items, Integer selected,
+                    Integer row, Integer col, Integer grid)
   FUNC_API_SINCE(3) FUNC_API_REMOTE_ONLY;
 void popupmenu_hide(void)
   FUNC_API_SINCE(3) FUNC_API_REMOTE_ONLY;
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index ecfff1ea8f..2a724a85ec 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -1920,13 +1920,13 @@ Object nvim_get_proc(Integer pid, Error *err)
 Array nvim__inspect_cell(Integer row, Integer col, Error *err)
 {
   Array ret = ARRAY_DICT_INIT;
-  if (row < 0 || row >= screen_Rows
-      || col < 0 || col >= screen_Columns) {
+  if (row < 0 || row >= default_grid.Rows
+      || col < 0 || col >= default_grid.Columns) {
     return ret;
   }
-  size_t off = LineOffset[(size_t)row] + (size_t)col;
-  ADD(ret, STRING_OBJ(cstr_to_string((char *)ScreenLines[off])));
-  int attr = ScreenAttrs[off];
+  size_t off = default_grid.line_offset[(size_t)row] + (size_t)col;
+  ADD(ret, STRING_OBJ(cstr_to_string((char *)default_grid.chars[off])));
+  int attr = default_grid.attrs[off];
   ADD(ret, DICTIONARY_OBJ(hl_get_attr_by_id(attr, true, err)));
   // will not work first time
   if (!highlight_use_hlstate()) {
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index d270714611..05688790c2 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -18,6 +18,8 @@ typedef struct {
 
 // for garray_T
 #include "nvim/garray.h"
+// for ScreenGrid
+#include "nvim/grid_defs.h"
 // for HLF_COUNT
 #include "nvim/highlight_defs.h"
 // for pos_T, lpos_T and linenr_T
@@ -1183,6 +1185,9 @@ struct window_S {
   int w_tagstackidx;                    /* idx just below active entry */
   int w_tagstacklen;                    /* number of tags on stack */
 
+  ScreenGrid w_grid;                    // the grid specific to the window
+  bool w_pos_changed;                   // true if window position changed
+
   /*
    * w_fraction is the fractional row of the cursor within the window, from
    * 0 at the top row to FRACTION_MULT at the last row.
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index 4e8bb3b0d7..c220c4e347 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -1022,12 +1022,12 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
       && vim_isbreak(c)
       && !vim_isbreak((int)s[1])
       && wp->w_p_wrap
-      && (wp->w_width != 0)) {
+      && (wp->w_grid.Columns != 0)) {
     // Count all characters from first non-blank after a blank up to next
     // non-blank after a blank.
     numberextra = win_col_off(wp);
     col2 = col;
-    colmax = (colnr_T)(wp->w_width - numberextra - col_adj);
+    colmax = (colnr_T)(wp->w_grid.Columns - numberextra - col_adj);
 
     if (col >= colmax) {
         colmax += col_adj;
@@ -1076,9 +1076,9 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
     numberextra = numberwidth;
     col += numberextra + mb_added;
 
-    if (col >= (colnr_T)wp->w_width) {
-      col -= wp->w_width;
-      numberextra = wp->w_width - (numberextra - win_col_off2(wp));
+    if (col >= (colnr_T)wp->w_grid.Columns) {
+      col -= wp->w_grid.Columns;
+      numberextra = wp->w_grid.Columns - (numberextra - win_col_off2(wp));
       if (col >= numberextra && numberextra > 0) {
         col %= numberextra;
       }
@@ -1097,16 +1097,17 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
       numberwidth -= win_col_off2(wp);
     }
 
-    if (col == 0 || (col + size + sbrlen > (colnr_T)wp->w_width)) {
+    if (col == 0 || (col + size + sbrlen > (colnr_T)wp->w_grid.Columns)) {
       added = 0;
 
       if (*p_sbr != NUL) {
-        if (size + sbrlen + numberwidth > (colnr_T)wp->w_width) {
+        if (size + sbrlen + numberwidth > (colnr_T)wp->w_grid.Columns) {
           // Calculate effective window width.
-          int width = (colnr_T)wp->w_width - sbrlen - numberwidth;
-          int prev_width = col ? ((colnr_T)wp->w_width - (sbrlen + col)) : 0;
+          int width = (colnr_T)wp->w_grid.Columns - sbrlen - numberwidth;
+          int prev_width = col ? ((colnr_T)wp->w_grid.Columns - (sbrlen + col))
+                               : 0;
           if (width == 0) {
-            width = (colnr_T)wp->w_width;
+            width = (colnr_T)wp->w_grid.Columns;
           }
           added += ((size - prev_width) / width) * vim_strsize(p_sbr);
           if ((size - prev_width) % width) {
@@ -1175,11 +1176,11 @@ bool in_win_border(win_T *wp, colnr_T vcol)
   int width1;             // width of first line (after line number)
   int width2;             // width of further lines
 
-  if (wp->w_width == 0) {
+  if (wp->w_grid.Columns == 0) {
     // there is no border
     return false;
   }
-  width1 = wp->w_width - win_col_off(wp);
+  width1 = wp->w_grid.Columns - win_col_off(wp);
 
   if ((int)vcol < width1 - 1) {
     return false;
diff --git a/src/nvim/cursor.c b/src/nvim/cursor.c
index 0fda941a51..ee1bc6cf31 100644
--- a/src/nvim/cursor.c
+++ b/src/nvim/cursor.c
@@ -120,11 +120,11 @@ static int coladvance2(
         --curwin->w_curswant;
     }
   } else {
-    int width = curwin->w_width - win_col_off(curwin);
+    int width = curwin->w_grid.Columns - win_col_off(curwin);
 
     if (finetune
         && curwin->w_p_wrap
-        && curwin->w_width != 0
+        && curwin->w_grid.Columns != 0
         && wcol >= (colnr_T)width) {
       csize = linetabsize(line);
       if (csize > 0)
@@ -223,9 +223,10 @@ static int coladvance2(
     } else {
       int b = (int)wcol - (int)col;
 
-      /* The difference between wcol and col is used to set coladd. */
-      if (b > 0 && b < (MAXCOL - 2 * curwin->w_width))
+      // The difference between wcol and col is used to set coladd.
+      if (b > 0 && b < (MAXCOL - 2 * curwin->w_grid.Columns)) {
         pos->coladd = b;
+      }
 
       col += b;
     }
@@ -436,7 +437,7 @@ bool leftcol_changed(void)
   bool retval = false;
 
   changed_cline_bef_curs();
-  lastcol = curwin->w_leftcol + curwin->w_width - curwin_col_off() - 1;
+  lastcol = curwin->w_leftcol + curwin->w_grid.Columns - curwin_col_off() - 1;
   validate_virtcol();
 
   /*
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index c04190eaba..41a2be6ad4 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -560,7 +560,7 @@ static int insert_check(VimState *state)
 
     if (curwin->w_wcol < s->mincol - curbuf->b_p_ts
         && curwin->w_wrow == curwin->w_winrow
-        + curwin->w_height - 1 - p_so
+        + curwin->w_grid.Rows - 1 - p_so
         && (curwin->w_cursor.lnum != curwin->w_topline
             || curwin->w_topfill > 0)) {
       if (curwin->w_topfill > 0) {
@@ -1494,40 +1494,41 @@ void edit_putchar(int c, int highlight)
 {
   int attr;
 
-  if (ScreenLines != NULL) {
-    update_topline();           /* just in case w_topline isn't valid */
+  if (curwin->w_grid.chars != NULL || default_grid.chars != NULL) {
+    update_topline();  // just in case w_topline isn't valid
     validate_cursor();
     if (highlight) {
       attr = HL_ATTR(HLF_8);
     } else {
       attr = 0;
     }
-    pc_row = curwin->w_winrow + curwin->w_wrow;
-    pc_col = curwin->w_wincol;
+    pc_row = curwin->w_wrow;
+    pc_col = 0;
     pc_status = PC_STATUS_UNSET;
     if (curwin->w_p_rl) {
-      pc_col += curwin->w_width - 1 - curwin->w_wcol;
+      pc_col += curwin->w_grid.Columns - 1 - curwin->w_wcol;
       if (has_mbyte) {
-        int fix_col = mb_fix_col(pc_col, pc_row);
+        int fix_col = grid_fix_col(&curwin->w_grid, pc_col, pc_row);
 
         if (fix_col != pc_col) {
-          screen_putchar(' ', pc_row, fix_col, attr);
-          --curwin->w_wcol;
+          grid_putchar(&curwin->w_grid, ' ', pc_row, fix_col, attr);
+          curwin->w_wcol--;
           pc_status = PC_STATUS_RIGHT;
         }
       }
     } else {
       pc_col += curwin->w_wcol;
-      if (mb_lefthalve(pc_row, pc_col))
+      if (grid_lefthalve(&curwin->w_grid, pc_row, pc_col)) {
         pc_status = PC_STATUS_LEFT;
+      }
     }
 
     /* save the character to be able to put it back */
     if (pc_status == PC_STATUS_UNSET) {
-      screen_getbytes(pc_row, pc_col, pc_bytes, &pc_attr);
+      grid_getbytes(&curwin->w_grid, pc_row, pc_col, pc_bytes, &pc_attr);
       pc_status = PC_STATUS_SET;
     }
-    screen_putchar(c, pc_row, pc_col, attr);
+    grid_putchar(&curwin->w_grid, c, pc_row, pc_col, attr);
   }
 }
 
@@ -1543,7 +1544,8 @@ void edit_unputchar(void)
     if (pc_status == PC_STATUS_RIGHT || pc_status == PC_STATUS_LEFT) {
       redrawWinline(curwin, curwin->w_cursor.lnum, false);
     } else {
-      screen_puts(pc_bytes, pc_row - msg_scrolled, pc_col, pc_attr);
+      grid_puts(&curwin->w_grid, pc_bytes, pc_row - msg_scrolled, pc_col,
+                pc_attr);
     }
   }
 }
@@ -1566,8 +1568,8 @@ void display_dollar(colnr_T col)
   char_u *p = get_cursor_line_ptr();
   curwin->w_cursor.col -= utf_head_off(p, p + col);
   curs_columns(false);              // Recompute w_wrow and w_wcol
-  if (curwin->w_wcol < curwin->w_width) {
-    edit_putchar('$', FALSE);
+  if (curwin->w_wcol < curwin->w_grid.Columns) {
+    edit_putchar('$', false);
     dollar_vcol = curwin->w_virtcol;
   }
   curwin->w_cursor.col = save_col;
@@ -5825,7 +5827,7 @@ static void check_auto_format(
 /*
  * Find out textwidth to be used for formatting:
  *	if 'textwidth' option is set, use it
- *	else if 'wrapmargin' option is set, use curwin->w_width - 'wrapmargin'
+ *	else if 'wrapmargin' option is set, use curwin->w_grid.Columns-'wrapmargin'
  *	if invalid value, use 0.
  *	Set default to window width (maximum 79) for "gq" operator.
  */
@@ -5840,9 +5842,10 @@ comp_textwidth (
   if (textwidth == 0 && curbuf->b_p_wm) {
     /* The width is the window width minus 'wrapmargin' minus all the
      * things that add to the margin. */
-    textwidth = curwin->w_width - curbuf->b_p_wm;
-    if (cmdwin_type != 0)
+    textwidth = curwin->w_grid.Columns - curbuf->b_p_wm;
+    if (cmdwin_type != 0) {
       textwidth -= 1;
+    }
     textwidth -= curwin->w_p_fdc;
 
     if (signcolumn_on(curwin)) {
@@ -5855,9 +5858,10 @@ comp_textwidth (
   if (textwidth < 0)
     textwidth = 0;
   if (ff && textwidth == 0) {
-    textwidth = curwin->w_width - 1;
-    if (textwidth > 79)
+    textwidth = curwin->w_grid.Columns - 1;
+    if (textwidth > 79) {
       textwidth = 79;
+    }
   }
   return textwidth;
 }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index d67818aa81..3a231ab8f1 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -14023,11 +14023,11 @@ static void f_screenattr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   const int row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
   const int col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
-  if (row < 0 || row >= screen_Rows
-      || col < 0 || col >= screen_Columns) {
+  if (row < 0 || row >= default_grid.Rows
+      || col < 0 || col >= default_grid.Columns) {
     c = -1;
   } else {
-    c = ScreenAttrs[LineOffset[row] + col];
+    c = default_grid.attrs[default_grid.line_offset[row] + col];
   }
   rettv->vval.v_number = c;
 }
@@ -14042,12 +14042,12 @@ static void f_screenchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   const int row = tv_get_number_chk(&argvars[0], NULL) - 1;
   const int col = tv_get_number_chk(&argvars[1], NULL) - 1;
-  if (row < 0 || row >= screen_Rows
-      || col < 0 || col >= screen_Columns) {
+  if (row < 0 || row >= default_grid.Rows
+      || col < 0 || col >= default_grid.Columns) {
     c = -1;
   } else {
-    off = LineOffset[row] + col;
-    c = utf_ptr2char(ScreenLines[off]);
+    off = default_grid.line_offset[row] + col;
+    c = utf_ptr2char(default_grid.chars[off]);
   }
   rettv->vval.v_number = c;
 }
@@ -16774,10 +16774,10 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
   }
 
-  uint16_t term_width = MAX(0, curwin->w_width - win_col_off(curwin));
+  uint16_t term_width = MAX(0, curwin->w_grid.Columns - win_col_off(curwin));
   Channel *chan = channel_job_start(argv, on_stdout, on_stderr, on_exit,
                                     true, false, false, cwd,
-                                    term_width, curwin->w_height,
+                                    term_width, curwin->w_grid.Rows,
                                     xstrdup("xterm-256color"),
                                     &rettv->vval.v_number);
   if (rettv->vval.v_number <= 0) {
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 36c4e333cf..0067445b38 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -256,10 +256,12 @@ void ex_align(exarg_T *eap)
      */
     if (width <= 0)
       width = curbuf->b_p_tw;
-    if (width == 0 && curbuf->b_p_wm > 0)
-      width = curwin->w_width - curbuf->b_p_wm;
-    if (width <= 0)
+    if (width == 0 && curbuf->b_p_wm > 0) {
+      width = curwin->w_grid.Columns - curbuf->b_p_wm;
+    }
+    if (width <= 0) {
       width = 80;
+    }
   }
 
   if (u_save((linenr_T)(eap->line1 - 1), (linenr_T)(eap->line2 + 1)) == FAIL)
@@ -2870,11 +2872,11 @@ void ex_z(exarg_T *eap)
   // Vi compatible: ":z!" uses display height, without a count uses
   // 'scroll'
   if (eap->forceit) {
-    bigness = curwin->w_height;
+    bigness = curwin->w_grid.Rows;
   } else if (ONE_WINDOW) {
     bigness = curwin->w_p_scr * 2;
   } else {
-    bigness = curwin->w_height - 3;
+    bigness = curwin->w_grid.Rows - 3;
   }
   if (bigness < 1) {
     bigness = 1;
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 4ef332186e..8bc6193d08 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -9194,10 +9194,10 @@ static int ses_winsizes(FILE *fd, int restore_size, win_T *tab_firstwin)
       /* restore height when not full height */
       if (wp->w_height + wp->w_status_height < topframe->fr_height
           && (fprintf(fd,
-                  "exe '%dresize ' . ((&lines * %" PRId64
-                  " + %" PRId64 ") / %" PRId64 ")",
-                  n, (int64_t)wp->w_height,
-                  (int64_t)(Rows / 2), (int64_t)Rows) < 0
+                      "exe '%dresize ' . ((&lines * %" PRId64
+                      " + %" PRId64 ") / %" PRId64 ")",
+                      n, (int64_t)wp->w_grid.Rows,
+                      (int64_t)(Rows / 2), (int64_t)Rows) < 0
               || put_eol(fd) == FAIL))
         return FAIL;
 
@@ -9459,8 +9459,8 @@ put_view(
                 " * winheight(0) + %" PRId64 ") / %" PRId64 ")",
                 (int64_t)wp->w_cursor.lnum,
                 (int64_t)(wp->w_cursor.lnum - wp->w_topline),
-                (int64_t)(wp->w_height / 2),
-                (int64_t)wp->w_height) < 0
+                (int64_t)(wp->w_grid.Rows / 2),
+                (int64_t)wp->w_grid.Rows) < 0
         || put_eol(fd) == FAIL
         || put_line(fd, "if s:l < 1 | let s:l = 1 | endif") == FAIL
         || put_line(fd, "exe s:l") == FAIL
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 94702a9a3a..53e9846c2d 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -2120,8 +2120,8 @@ static int vgetorpeek(int advance)
                     ++col;
                 }
                 curwin->w_wrow = curwin->w_cline_row
-                                 + curwin->w_wcol / curwin->w_width;
-                curwin->w_wcol %= curwin->w_width;
+                                 + curwin->w_wcol / curwin->w_grid.Columns;
+                curwin->w_wcol %= curwin->w_grid.Columns;
                 curwin->w_wcol += curwin_col_off();
                 col = 0;                        /* no correction needed */
               } else {
@@ -2129,8 +2129,8 @@ static int vgetorpeek(int advance)
                 col = curwin->w_cursor.col - 1;
               }
             } else if (curwin->w_p_wrap && curwin->w_wrow) {
-              --curwin->w_wrow;
-              curwin->w_wcol = curwin->w_width - 1;
+              curwin->w_wrow--;
+              curwin->w_wcol = curwin->w_grid.Columns - 1;
               col = curwin->w_cursor.col - 1;
             }
             if (col > 0 && curwin->w_wcol > 0) {
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 04ff1320ce..f2bd6408e8 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -91,9 +91,10 @@ EXTERN struct nvim_stats_s {
 /*
  * Number of Rows and Columns in the screen.
  * Must be long to be able to use them as options in option.c.
- * Note: Use screen_Rows and screen_Columns to access items in ScreenLines[].
- * They may have different values when the screen wasn't (re)allocated yet
- * after setting Rows or Columns (e.g., when starting up).
+ * Note: Use default_grid.Rows and default_grid.Columns to access items in
+ * default_grid.chars[]. They may have different values when the screen
+ * wasn't (re)allocated yet after setting Rows or Columns (e.g., when starting
+ * up).
  */
 #define DFLT_COLS       80              // default value for 'columns'
 #define DFLT_ROWS       24              // default value for 'lines'
@@ -129,45 +130,6 @@ typedef off_t off_T;
 #endif
 
 /*
- * The characters and attributes cached for the screen.
- */
-typedef char_u schar_T[(MAX_MCO+1) * 4 + 1];
-typedef int16_t sattr_T;
-
-/// ScreenLines[] contains a copy of the whole screen, as it currently is
-/// displayed. It is a single block of screen cells, the size of the screen
-/// plus one line. The extra line used as a buffer while redrawing a window
-/// line, so it can be compared with the previous state of that line. This way
-/// we can avoid sending bigger updates than neccessary to the Ul layer.
-///
-/// Screen cells are stored as NUL-terminated UTF-8 strings, and a cell can
-/// contain up to MAX_MCO composing characters after the base character.
-/// The composing characters are to be drawn on top of the original character.
-/// The content after the NUL is not defined (so comparison must be done a
-/// single cell at a time). Double-width characters are stored in the left cell,
-/// and the right cell should only contain the empty string. When a part of the
-/// screen is cleared, the cells should be filled with a single whitespace char.
-///
-/// ScreenAttrs[] contains the highlighting attribute for each cell.
-/// LineOffset[n] is the offset from ScreenLines[] and ScreenAttrs[] for the
-/// start of line 'n'. These offsets are in general not linear, as full screen
-/// scrolling is implemented by rotating the offsets in the LineOffset array.
-/// LineWraps[] is an array of boolean flags indicating if the screen line wraps
-/// to the next line. It can only be true if a window occupies the entire screen
-/// width.
-///
-///
-/// Note: before the screen is initialized and when out of memory these can be
-/// NULL.
-EXTERN schar_T  *ScreenLines INIT(= NULL);
-EXTERN sattr_T  *ScreenAttrs INIT(= NULL);
-EXTERN unsigned *LineOffset INIT(= NULL);
-EXTERN char_u   *LineWraps INIT(= NULL);        /* line wraps to next line */
-
-EXTERN int screen_Rows INIT(= 0);           /* actual size of ScreenLines[] */
-EXTERN int screen_Columns INIT(= 0);        /* actual size of ScreenLines[] */
-
-/*
  * When vgetc() is called, it sets mod_mask to the set of modifiers that are
  * held down based on the MOD_MASK_* symbols that are read first.
  */
@@ -228,11 +190,8 @@ EXTERN int compl_cont_status INIT(= 0);
 # define CONT_LOCAL     32      /* for ctrl_x_mode 0, ^X^P/^X^N do a local
                                  * expansion, (eg use complete=.) */
 
-/*
- * Functions for putting characters in the command line,
- * while keeping ScreenLines[] updated.
- */
-EXTERN int cmdmsg_rl INIT(= FALSE);         /* cmdline is drawn right to left */
+// state for putting characters in the message area
+EXTERN int cmdmsg_rl INIT(= false);  // cmdline is drawn right to left
 EXTERN int msg_col;
 EXTERN int msg_row;
 EXTERN int msg_scrolled;        /* Number of screen lines that windows have
diff --git a/src/nvim/grid_defs.h b/src/nvim/grid_defs.h
new file mode 100644
index 0000000000..37d85ead0c
--- /dev/null
+++ b/src/nvim/grid_defs.h
@@ -0,0 +1,59 @@
+#ifndef NVIM_GRID_DEFS_H
+#define NVIM_GRID_DEFS_H
+
+#include <stdint.h>
+
+#include "nvim/types.h"
+
+#define MAX_MCO  6  // maximum value for 'maxcombine'
+
+// The characters and attributes drawn on grids.
+typedef char_u schar_T[(MAX_MCO+1) * 4 + 1];
+typedef int16_t sattr_T;
+
+/// ScreenGrid represents a resizable rectuangular grid displayed by UI clients.
+///
+/// chars[] contains the UTF-8 text that is currently displayed on the grid.
+/// It is stored as a single block of cells. When redrawing a part of the grid,
+/// the new state can be compared with the existing state of the grid. This way
+/// we can avoid sending bigger updates than neccessary to the Ul layer.
+///
+/// Screen cells are stored as NUL-terminated UTF-8 strings, and a cell can
+/// contain up to MAX_MCO composing characters after the base character.
+/// The composing characters are to be drawn on top of the original character.
+/// The content after the NUL is not defined (so comparison must be done a
+/// single cell at a time). Double-width characters are stored in the left cell,
+/// and the right cell should only contain the empty string. When a part of the
+/// screen is cleared, the cells should be filled with a single whitespace char.
+///
+/// attrs[] contains the highlighting attribute for each cell.
+/// line_offset[n] is the offset from chars[] and attrs[] for the
+/// start of line 'n'. These offsets are in general not linear, as full screen
+/// scrolling is implemented by rotating the offsets in the line_offset array.
+/// line_wraps[] is an array of boolean flags indicating if the screen line
+/// wraps to the next line. It can only be true if a window occupies the entire
+/// screen width.
+typedef struct {
+  handle_T handle;
+
+  schar_T  *chars;
+  sattr_T  *attrs;
+  unsigned *line_offset;
+  char_u   *line_wraps;
+
+  // the size of the allocated grid.
+  int Rows;
+  int Columns;
+
+  // offsets for the grid relative to the global screen
+  int row_offset;
+  int col_offset;
+
+  // grid size requested by the UI. Used for window grids only.
+  int requested_rows;
+  int requested_cols;
+
+  int was_resized;
+} ScreenGrid;
+
+#endif  // NVIM_GRID_DEFS_H
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index a8731d5bd7..983dbb7bbe 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -582,8 +582,9 @@ static void prt_header(prt_settings_T *const psettings, const int pagenum,
  */
 static void prt_message(char_u *s)
 {
-  screen_fill((int)Rows - 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
-  screen_puts(s, (int)Rows - 1, 0, HL_ATTR(HLF_R));
+  grid_fill(&default_grid, (int)Rows - 1, (int)Rows, 0, (int)Columns, ' ', ' ',
+            0);
+  grid_puts(&default_grid, s, (int)Rows - 1, 0, HL_ATTR(HLF_R));
   ui_flush();
 }
 
diff --git a/src/nvim/highlight.c b/src/nvim/highlight.c
index 5a9727f46e..41d60fa3ea 100644
--- a/src/nvim/highlight.c
+++ b/src/nvim/highlight.c
@@ -98,7 +98,7 @@ static int get_attr_entry(HlEntry entry)
   return id;
 }
 
-/// When a UI connects, we need to send it the table of higlights used so far.
+/// When a UI connects, we need to send it the table of highlights used so far.
 void ui_send_all_hls(UI *ui)
 {
   for (size_t i = 1; i < kv_size(attr_entries); i++) {
@@ -212,13 +212,7 @@ void clear_hl_tables(bool reinit)
     map_clear(int, int)(combine_attr_entries);
     highlight_attr_set_all();
     highlight_changed();
-    redraw_all_later(NOT_VALID);
-    if (ScreenAttrs) {
-      // the meaning of 0 doesn't change anyway
-      // but the rest must be retransmitted
-      memset(ScreenAttrs, 0,
-             sizeof(*ScreenAttrs) * (size_t)(screen_Rows * screen_Columns));
-    }
+    screen_invalidate_highlights();
   } else {
     kv_destroy(attr_entries);
     map_free(HlEntry, int)(attr_entry_ids);
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index 3cc64e0033..0b7ebd498a 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -463,8 +463,8 @@ int get_breakindent_win(win_T *wp, char_u *line)
   static char_u *prev_line = NULL;  // cached pointer to line.
   static varnumber_T prev_tick = 0;  // Changedtick of cached value.
   int bri = 0;
-  /* window width minus window margin space, i.e. what rests for text */
-  const int eff_wwidth = wp->w_width
+  // window width minus window margin space, i.e. what rests for text
+  const int eff_wwidth = wp->w_grid.Columns
     - ((wp->w_p_nu || wp->w_p_rnu)
         && (vim_strchr(p_cpo, CPO_NUMCOL) == NULL)
         ? number_width(wp) + 1 : 0);
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 0ee8e2bd85..ead6b4405d 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -556,13 +556,6 @@ size_t mb_string2cells(const char_u *str)
   return clen;
 }
 
-/// Return number of display cells for char at ScreenLines[off].
-/// We make sure that the offset used is less than "max_off".
-int utf_off2cells(unsigned off, unsigned max_off)
-{
-  return (off + 1 < max_off && ScreenLines[off + 1][0] == 0) ? 2 : 1;
-}
-
 /// Convert a UTF-8 byte sequence to a wide character
 ///
 /// If the sequence is illegal or truncated by a NUL then the first byte is
@@ -1822,32 +1815,6 @@ const char *mb_unescape(const char **const pp)
   return NULL;
 }
 
-/*
- * Return true if the character at "row"/"col" on the screen is the left side
- * of a double-width character.
- * Caller must make sure "row" and "col" are not invalid!
- */
-bool mb_lefthalve(int row, int col)
-{
-  return utf_off2cells(LineOffset[row] + col,
-                       LineOffset[row] + screen_Columns) > 1;
-}
-
-/*
- * Correct a position on the screen, if it's the right half of a double-wide
- * char move it to the left half.  Returns the corrected column.
- */
-int mb_fix_col(int col, int row)
-{
-  col = check_col(col);
-  row = check_row(row);
-  if (ScreenLines != NULL && col > 0
-      && ScreenLines[LineOffset[row] + col][0] == 0) {
-    return col - 1;
-  }
-  return col;
-}
-
 
 /*
  * Skip the Vim specific head of a 'encoding' name.
@@ -2524,23 +2491,3 @@ char_u * string_convert_ext(const vimconv_T *const vcp, char_u *ptr,
 
   return retval;
 }
-
-// Check bounds for column number
-static int check_col(int col)
-{
-  if (col < 0)
-    return 0;
-  if (col >= screen_Columns)
-    return screen_Columns - 1;
-  return col;
-}
-
-// Check bounds for row number
-static int check_row(int row)
-{
-  if (row < 0)
-    return 0;
-  if (row >= screen_Rows)
-    return screen_Rows - 1;
-  return row;
-}
diff --git a/src/nvim/mbyte.h b/src/nvim/mbyte.h
index 70073a8540..ed48705c6d 100644
--- a/src/nvim/mbyte.h
+++ b/src/nvim/mbyte.h
@@ -19,13 +19,6 @@
 #define MB_BYTE2LEN(b)         utf8len_tab[b]
 #define MB_BYTE2LEN_CHECK(b)   (((b) < 0 || (b) > 255) ? 1 : utf8len_tab[b])
 
-/// Maximum value for 'maxcombine'
-///
-/// At most that number of composing characters may be attached to the leading
-/// character by various `utfc_*` functions. Note that some functions do not
-/// have this limit.
-enum { MAX_MCO = 6 };
-
 // max length of an unicode char
 #define MB_MAXCHAR     6
 
diff --git a/src/nvim/memory.c b/src/nvim/memory.c
index 6b96a3b070..d38079ca72 100644
--- a/src/nvim/memory.c
+++ b/src/nvim/memory.c
@@ -698,8 +698,8 @@ void free_all_mem(void)
     buf = bufref_valid(&bufref) ? nextbuf : firstbuf;
   }
 
-  /* screenlines (can't display anything now!) */
-  free_screenlines();
+  // free screenlines (can't display anything now!)
+  screen_free_all_mem();
 
   clear_hl_tables(false);
   list_free_log();
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 6de81a8aaf..37e40c3cc1 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -1546,10 +1546,8 @@ void msg_prt_line(char_u *s, int list)
   msg_clr_eos();
 }
 
-/*
- * Use screen_puts() to output one multi-byte character.
- * Return the pointer "s" advanced to the next character.
- */
+// Use grid_puts() to output one multi-byte character.
+// Return the pointer "s" advanced to the next character.
 static char_u *screen_puts_mbyte(char_u *s, int l, int attr)
 {
   int cw;
@@ -1563,7 +1561,7 @@ static char_u *screen_puts_mbyte(char_u *s, int l, int attr)
     return s;
   }
 
-  screen_puts_len(s, l, msg_row, msg_col, attr);
+  grid_puts_len(&default_grid, s, l, msg_row, msg_col, attr);
   if (cmdmsg_rl) {
     msg_col -= cw;
     if (msg_col == 0) {
@@ -1886,19 +1884,22 @@ int msg_scrollsize(void)
  */
 static void msg_scroll_up(void)
 {
+  if (msg_scrolled == 0) {
+    ui_call_win_scroll_over_start();
+  }
   if (dy_flags & DY_MSGSEP) {
     if (msg_scrolled == 0) {
-      screen_fill(Rows-p_ch-1, Rows-p_ch, 0, (int)Columns,
-                  fill_msgsep, fill_msgsep, HL_ATTR(HLF_MSGSEP));
+      grid_fill(&default_grid, Rows-p_ch-1, Rows-p_ch, 0, (int)Columns,
+                fill_msgsep, fill_msgsep, HL_ATTR(HLF_MSGSEP));
     }
     int nscroll = MIN(msg_scrollsize()+1, Rows);
-    screen_del_lines(Rows-nscroll, 1, Rows, 0, Columns);
+    grid_del_lines(&default_grid, Rows-nscroll, 1, Rows, 0, Columns);
   } else {
-    screen_del_lines(0, 1, (int)Rows, 0, Columns);
+    grid_del_lines(&default_grid, 0, 1, (int)Rows, 0, Columns);
   }
   // TODO(bfredl): when msgsep display is properly batched, this fill should be
   // eliminated.
-  screen_fill(Rows-1, Rows, 0, (int)Columns, ' ', ' ', 0);
+  grid_fill(&default_grid, Rows-1, Rows, 0, (int)Columns, ' ', ' ', 0);
 }
 
 /*
@@ -2097,7 +2098,8 @@ static void t_puts(int *t_col, const char_u *t_s, const char_u *s, int attr)
 {
   // Output postponed text.
   msg_didout = true;  // Remember that line is not empty.
-  screen_puts_len((char_u *)t_s, (int)(s - t_s), msg_row, msg_col, attr);
+  grid_puts_len(&default_grid, (char_u *)t_s, (int)(s - t_s), msg_row, msg_col,
+                attr);
   msg_col += *t_col;
   *t_col = 0;
   /* If the string starts with a composing character don't increment the
@@ -2313,8 +2315,9 @@ static int do_more_prompt(int typed_char)
           }
 
           if (toscroll == -1
-              && screen_ins_lines(0, 1, (int)Rows, 0, (int)Columns) == OK) {
-            screen_fill(0, 1, 0, (int)Columns, ' ', ' ', 0);
+              && grid_ins_lines(&default_grid, 0, 1, (int)Rows,
+                                0, (int)Columns) == OK) {
+            grid_fill(&default_grid, 0, 1, 0, (int)Columns, ' ', ' ', 0);
             // display line at top
             (void)disp_sb_line(0, mp);
           } else {
@@ -2333,18 +2336,18 @@ static int do_more_prompt(int typed_char)
           /* scroll up, display line at bottom */
           msg_scroll_up();
           inc_msg_scrolled();
-          screen_fill((int)Rows - 2, (int)Rows - 1, 0,
-              (int)Columns, ' ', ' ', 0);
+          grid_fill(&default_grid, (int)Rows - 2, (int)Rows - 1, 0,
+                    (int)Columns, ' ', ' ', 0);
           mp_last = disp_sb_line((int)Rows - 2, mp_last);
           --toscroll;
         }
       }
 
       if (toscroll <= 0) {
-        /* displayed the requested text, more prompt again */
-        screen_fill((int)Rows - 1, (int)Rows, 0,
-            (int)Columns, ' ', ' ', 0);
-        msg_moremsg(FALSE);
+        // displayed the requested text, more prompt again
+        grid_fill(&default_grid, (int)Rows - 1, (int)Rows, 0,
+                  (int)Columns, ' ', ' ', 0);
+        msg_moremsg(false);
         continue;
       }
 
@@ -2355,8 +2358,9 @@ static int do_more_prompt(int typed_char)
     break;
   }
 
-  /* clear the --more-- message */
-  screen_fill((int)Rows - 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
+  // clear the --more-- message
+  grid_fill(&default_grid, (int)Rows - 1, (int)Rows, 0, (int)Columns, ' ', ' ',
+            0);
   State = oldState;
   setmouse();
   if (quit_more) {
@@ -2452,8 +2456,8 @@ void mch_msg(char *str)
  */
 static void msg_screen_putchar(int c, int attr)
 {
-  msg_didout = TRUE;            /* remember that line is not empty */
-  screen_putchar(c, msg_row, msg_col, attr);
+  msg_didout = true;            // remember that line is not empty
+  grid_putchar(&default_grid, c, msg_row, msg_col, attr);
   if (cmdmsg_rl) {
     if (--msg_col == 0) {
       msg_col = Columns;
@@ -2473,11 +2477,12 @@ void msg_moremsg(int full)
   char_u      *s = (char_u *)_("-- More --");
 
   attr = HL_ATTR(HLF_M);
-  screen_puts(s, (int)Rows - 1, 0, attr);
-  if (full)
-    screen_puts((char_u *)
-        _(" SPACE/d/j: screen/page/line down, b/u/k: up, q: quit "),
-        (int)Rows - 1, vim_strsize(s), attr);
+  grid_puts(&default_grid, s, (int)Rows - 1, 0, attr);
+  if (full) {
+    grid_puts(&default_grid, (char_u *)
+              _(" SPACE/d/j: screen/page/line down, b/u/k: up, q: quit "),
+              (int)Rows - 1, vim_strsize(s), attr);
+  }
 }
 
 /*
@@ -2525,13 +2530,13 @@ void msg_clr_eos(void)
  */
 void msg_clr_eos_force(void)
 {
-  if (cmdmsg_rl) {
-    screen_fill(msg_row, msg_row + 1, 0, msg_col + 1, ' ', ' ', 0);
-    screen_fill(msg_row + 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
-  } else {
-    screen_fill(msg_row, msg_row + 1, msg_col, (int)Columns, ' ', ' ', 0);
-    screen_fill(msg_row + 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
-  }
+  int msg_startcol = (cmdmsg_rl) ? 0 : msg_col;
+  int msg_endcol = (cmdmsg_rl) ? msg_col + 1 : (int)Columns;
+
+  grid_fill(&default_grid, msg_row, msg_row + 1, msg_startcol, msg_endcol, ' ',
+            ' ', 0);
+  grid_fill(&default_grid, msg_row + 1, (int)Rows, 0, (int)Columns, ' ', ' ',
+            0);
 }
 
 /*
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index ffe2d11f08..5f76458275 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -1251,7 +1251,7 @@ int plines_win_nofill(
     return 1;
   }
 
-  if (wp->w_width == 0) {
+  if (wp->w_grid.Columns == 0) {
     return 1;
   }
 
@@ -1261,8 +1261,8 @@ int plines_win_nofill(
   }
 
   const int lines = plines_win_nofold(wp, lnum);
-  if (winheight && lines > wp->w_height) {
-    return wp->w_height;
+  if (winheight && lines > wp->w_grid.Rows) {
+    return wp->w_grid.Rows;
   }
   return lines;
 }
@@ -1292,7 +1292,7 @@ int plines_win_nofold(win_T *wp, linenr_T lnum)
   /*
    * Add column offset for 'number', 'relativenumber' and 'foldcolumn'.
    */
-  width = wp->w_width - win_col_off(wp);
+  width = wp->w_grid.Columns - win_col_off(wp);
   if (width <= 0 || col > 32000) {
     return 32000;  // bigger than the number of screen columns
   }
@@ -1318,8 +1318,9 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
   if (!wp->w_p_wrap)
     return lines + 1;
 
-  if (wp->w_width == 0)
+  if (wp->w_grid.Columns == 0) {
     return lines + 1;
+  }
 
   char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
   char_u *s = line;
@@ -1340,7 +1341,7 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
   }
 
   // Add column offset for 'number', 'relativenumber', 'foldcolumn', etc.
-  int width = wp->w_width - win_col_off(wp);
+  int width = wp->w_grid.Columns - win_col_off(wp);
   if (width <= 0) {
     return 9999;
   }
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index 3c792326a4..3790886194 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -110,8 +110,9 @@ retnomove:
   // Remember the character under the mouse, it might be a '-' or '+' in the
   // fold column. NB: only works for ASCII chars!
   if (row >= 0 && row < Rows && col >= 0 && col <= Columns
-      && ScreenLines != NULL) {
-    mouse_char = ScreenLines[LineOffset[row] + (unsigned)col][0];
+      && default_grid.chars != NULL) {
+    mouse_char = default_grid.chars[default_grid.line_offset[row]
+                                    + (unsigned)col][0];
   } else {
     mouse_char = ' ';
   }
diff --git a/src/nvim/move.c b/src/nvim/move.c
index 3a29851ee6..b8225cc64c 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -83,8 +83,9 @@ static void comp_botline(win_T *wp)
       redraw_for_cursorline(wp);
       wp->w_valid |= (VALID_CROW|VALID_CHEIGHT);
     }
-    if (done + n > wp->w_height)
+    if (done + n > wp->w_grid.Rows) {
       break;
+    }
     done += n;
     lnum = last;
   }
@@ -149,9 +150,12 @@ void update_topline(void)
   bool check_botline = false;
   long save_so = p_so;
 
+  // need to have w_grid.Rows/Columns updated
+  win_grid_alloc(curwin);
+
   // If there is no valid screen and when the window height is zero just use
   // the cursor line.
-  if (!screen_valid(true) || curwin->w_height == 0) {
+  if (!screen_valid(true) || curwin->w_grid.Rows == 0) {
     curwin->w_topline = curwin->w_cursor.lnum;
     curwin->w_botline = curwin->w_topline;
     curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
@@ -200,9 +204,10 @@ void update_topline(void)
       check_topline = true;
 
     if (check_topline) {
-      int halfheight = curwin->w_height / 2 - 1;
-      if (halfheight < 2)
+      int halfheight = curwin->w_grid.Rows / 2 - 1;
+      if (halfheight < 2) {
         halfheight = 2;
+      }
       long n;
       if (hasAnyFolding(curwin)) {
         /* Count the number of logical lines between the cursor and
@@ -289,20 +294,22 @@ void update_topline(void)
            * botline - p_so (approximation of how much will be
            * scrolled). */
           for (linenr_T lnum = curwin->w_cursor.lnum;
-               lnum >= curwin->w_botline - p_so; --lnum) {
-            ++line_count;
-            /* stop at end of file or when we know we are far off */
-            if (lnum <= 0 || line_count > curwin->w_height + 1)
+               lnum >= curwin->w_botline - p_so; lnum--) {
+            line_count++;
+            // stop at end of file or when we know we are far off
+            if (lnum <= 0 || line_count > curwin->w_grid.Rows + 1) {
               break;
+            }
             (void)hasFolding(lnum, &lnum, NULL);
           }
         } else
           line_count = curwin->w_cursor.lnum - curwin->w_botline
                        + 1 + p_so;
-        if (line_count <= curwin->w_height + 1)
+        if (line_count <= curwin->w_grid.Rows + 1) {
           scroll_cursor_bot(scrolljump_value(), false);
-        else
+        } else {
           scroll_cursor_halfway(false);
+        }
       }
     }
   }
@@ -346,7 +353,7 @@ void update_topline_win(win_T* win)
  */
 static int scrolljump_value(void)
 {
-  long result = p_sj >= 0 ? p_sj : (curwin->w_height * -p_sj) / 100;
+  long result = p_sj >= 0 ? p_sj : (curwin->w_grid.Rows * -p_sj) / 100;
   assert(result <= INT_MAX);
   return (int)result;
 }
@@ -522,6 +529,7 @@ int cursor_valid(void)
  */
 void validate_cursor(void)
 {
+  win_grid_alloc(curwin);  // we need to have w_grid.Rows/Columns updated
   check_cursor_moved(curwin);
   if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW))
     curs_columns(true);
@@ -660,18 +668,19 @@ void validate_cursor_col(void)
     colnr_T col = curwin->w_virtcol;
     colnr_T off = curwin_col_off();
     col += off;
-    int width = curwin->w_width - off + curwin_col_off2();
-
-    /* long line wrapping, adjust curwin->w_wrow */
-    if (curwin->w_p_wrap
-        && col >= (colnr_T)curwin->w_width
-        && width > 0)
-      /* use same formula as what is used in curs_columns() */
-      col -= ((col - curwin->w_width) / width + 1) * width;
-    if (col > (int)curwin->w_leftcol)
+    int width = curwin->w_grid.Columns - off + curwin_col_off2();
+
+    // long line wrapping, adjust curwin->w_wrow
+    if (curwin->w_p_wrap && col >= (colnr_T)curwin->w_grid.Columns
+        && width > 0) {
+      // use same formula as what is used in curs_columns()
+      col -= ((col - curwin->w_grid.Columns) / width + 1) * width;
+    }
+    if (col > (int)curwin->w_leftcol) {
       col -= curwin->w_leftcol;
-    else
+    } else {
       col = 0;
+    }
     curwin->w_wcol = col;
 
     curwin->w_valid |= VALID_WCOL;
@@ -760,20 +769,20 @@ void curs_columns(
    */
   curwin->w_wrow = curwin->w_cline_row;
 
-  int textwidth = curwin->w_width - extra;
+  int textwidth = curwin->w_grid.Columns - extra;
   if (textwidth <= 0) {
-    /* No room for text, put cursor in last char of window. */
-    curwin->w_wcol = curwin->w_width - 1;
-    curwin->w_wrow = curwin->w_height - 1;
+    // No room for text, put cursor in last char of window.
+    curwin->w_wcol = curwin->w_grid.Columns - 1;
+    curwin->w_wrow = curwin->w_grid.Rows - 1;
   } else if (curwin->w_p_wrap
-             && curwin->w_width != 0
+             && curwin->w_grid.Columns != 0
              ) {
     width = textwidth + curwin_col_off2();
 
-    /* long line wrapping, adjust curwin->w_wrow */
-    if (curwin->w_wcol >= curwin->w_width) {
-      /* this same formula is used in validate_cursor_col() */
-      n = (curwin->w_wcol - curwin->w_width) / width + 1;
+    // long line wrapping, adjust curwin->w_wrow
+    if (curwin->w_wcol >= curwin->w_grid.Columns) {
+      // this same formula is used in validate_cursor_col()
+      n = (curwin->w_wcol - curwin->w_grid.Columns) / width + 1;
       curwin->w_wcol -= n * width;
       curwin->w_wrow += n;
 
@@ -800,7 +809,7 @@ void curs_columns(
     assert(p_siso <= INT_MAX);
     int off_left = startcol - curwin->w_leftcol - (int)p_siso;
     int off_right =
-        endcol - curwin->w_leftcol - curwin->w_width + (int)p_siso + 1;
+        endcol - curwin->w_leftcol - curwin->w_grid.Columns + (int)p_siso + 1;
     if (off_left < 0 || off_right > 0) {
       int diff = (off_left < 0) ? -off_left: off_right;
 
@@ -843,17 +852,16 @@ void curs_columns(
   prev_skipcol = curwin->w_skipcol;
 
   int p_lines = 0;
-  if ((curwin->w_wrow >= curwin->w_height
+  if ((curwin->w_wrow >= curwin->w_grid.Rows
        || ((prev_skipcol > 0
-            || curwin->w_wrow + p_so >= curwin->w_height)
+            || curwin->w_wrow + p_so >= curwin->w_grid.Rows)
            && (p_lines =
-                 plines_win_nofill
-                   (curwin, curwin->w_cursor.lnum, false))
-           - 1 >= curwin->w_height))
-      && curwin->w_height != 0
+               plines_win_nofill(curwin, curwin->w_cursor.lnum, false)) - 1
+           >= curwin->w_grid.Rows))
+      && curwin->w_grid.Rows != 0
       && curwin->w_cursor.lnum == curwin->w_topline
       && width > 0
-      && curwin->w_width != 0
+      && curwin->w_grid.Columns != 0
       ) {
     /* Cursor past end of screen.  Happens with a single line that does
      * not fit on screen.  Find a skipcol to show the text around the
@@ -875,19 +883,22 @@ void curs_columns(
     }
     else
       n = p_lines;
-    if ((colnr_T)n >= curwin->w_height + curwin->w_skipcol / width)
+    if ((colnr_T)n >= curwin->w_grid.Rows + curwin->w_skipcol / width) {
       extra += 2;
+    }
 
     if (extra == 3 || p_lines < p_so * 2) {
-      /* not enough room for 'scrolloff', put cursor in the middle */
+      // not enough room for 'scrolloff', put cursor in the middle
       n = curwin->w_virtcol / width;
-      if (n > curwin->w_height / 2)
-        n -= curwin->w_height / 2;
-      else
+      if (n > curwin->w_grid.Rows / 2) {
+        n -= curwin->w_grid.Rows / 2;
+      } else {
         n = 0;
-      /* don't skip more than necessary */
-      if (n > p_lines - curwin->w_height + 1)
-        n = p_lines - curwin->w_height + 1;
+      }
+      // don't skip more than necessary
+      if (n > p_lines - curwin->w_grid.Rows + 1) {
+        n = p_lines - curwin->w_grid.Rows + 1;
+      }
       curwin->w_skipcol = n * width;
     } else if (extra == 1) {
       /* less then 'scrolloff' lines above, decrease skipcol */
@@ -900,18 +911,20 @@ void curs_columns(
         curwin->w_skipcol -= extra * width;
       }
     } else if (extra == 2) {
-      /* less then 'scrolloff' lines below, increase skipcol */
-      endcol = (n - curwin->w_height + 1) * width;
-      while (endcol > curwin->w_virtcol)
+      // less then 'scrolloff' lines below, increase skipcol
+      endcol = (n - curwin->w_grid.Rows + 1) * width;
+      while (endcol > curwin->w_virtcol) {
         endcol -= width;
-      if (endcol > curwin->w_skipcol)
+      }
+      if (endcol > curwin->w_skipcol) {
         curwin->w_skipcol = endcol;
+      }
     }
 
     curwin->w_wrow -= curwin->w_skipcol / width;
-    if (curwin->w_wrow >= curwin->w_height) {
-      /* small window, make sure cursor is in it */
-      extra = curwin->w_wrow - curwin->w_height + 1;
+    if (curwin->w_wrow >= curwin->w_grid.Rows) {
+      // small window, make sure cursor is in it
+      extra = curwin->w_wrow - curwin->w_grid.Rows + 1;
       curwin->w_skipcol += extra * width;
       curwin->w_wrow -= extra;
     }
@@ -953,9 +966,9 @@ scrolldown (
   validate_cursor();            /* w_wrow needs to be valid */
   while (line_count-- > 0) {
     if (curwin->w_topfill < diff_check(curwin, curwin->w_topline)
-        && curwin->w_topfill < curwin->w_height - 1) {
-      ++curwin->w_topfill;
-      ++done;
+        && curwin->w_topfill < curwin->w_grid.Rows - 1) {
+      curwin->w_topfill++;
+      done++;
     } else {
       if (curwin->w_topline == 1)
         break;
@@ -988,15 +1001,15 @@ scrolldown (
    */
   int wrow = curwin->w_wrow;
   if (curwin->w_p_wrap
-      && curwin->w_width != 0
+      && curwin->w_grid.Columns != 0
       ) {
     validate_virtcol();
     validate_cheight();
     wrow += curwin->w_cline_height - 1 -
-            curwin->w_virtcol / curwin->w_width;
+            curwin->w_virtcol / curwin->w_grid.Columns;
   }
   bool moved = false;
-  while (wrow >= curwin->w_height && curwin->w_cursor.lnum > 1) {
+  while (wrow >= curwin->w_grid.Rows && curwin->w_cursor.lnum > 1) {
     linenr_T first;
     if (hasFolding(curwin->w_cursor.lnum, &first, NULL)) {
       --wrow;
@@ -1081,14 +1094,15 @@ check_topfill (
 {
   if (wp->w_topfill > 0) {
     int n = plines_win_nofill(wp, wp->w_topline, true);
-    if (wp->w_topfill + n > wp->w_height) {
+    if (wp->w_topfill + n > wp->w_grid.Rows) {
       if (down && wp->w_topline > 1) {
         --wp->w_topline;
         wp->w_topfill = 0;
       } else {
-        wp->w_topfill = wp->w_height - n;
-        if (wp->w_topfill < 0)
+        wp->w_topfill = wp->w_grid.Rows - n;
+        if (wp->w_topfill < 0) {
           wp->w_topfill = 0;
+        }
       }
     }
   }
@@ -1101,12 +1115,13 @@ check_topfill (
 static void max_topfill(void)
 {
   int n = plines_nofill(curwin->w_topline);
-  if (n >= curwin->w_height)
+  if (n >= curwin->w_grid.Rows) {
     curwin->w_topfill = 0;
-  else {
+  } else {
     curwin->w_topfill = diff_check_fill(curwin, curwin->w_topline);
-    if (curwin->w_topfill + n > curwin->w_height)
-      curwin->w_topfill = curwin->w_height - n;
+    if (curwin->w_topfill + n > curwin->w_grid.Rows) {
+      curwin->w_topfill = curwin->w_grid.Rows - n;
+    }
   }
 }
 
@@ -1137,14 +1152,14 @@ void scrolldown_clamp(void)
   else
     end_row += plines_nofill(curwin->w_topline - 1);
   if (curwin->w_p_wrap
-      && curwin->w_width != 0
+      && curwin->w_grid.Columns != 0
       ) {
     validate_cheight();
     validate_virtcol();
     end_row += curwin->w_cline_height - 1 -
-               curwin->w_virtcol / curwin->w_width;
+               curwin->w_virtcol / curwin->w_grid.Columns;
   }
-  if (end_row < curwin->w_height - p_so) {
+  if (end_row < curwin->w_grid.Rows - p_so) {
     if (can_fill) {
       ++curwin->w_topfill;
       check_topfill(curwin, true);
@@ -1179,10 +1194,10 @@ void scrollup_clamp(void)
   int start_row = curwin->w_wrow - plines_nofill(curwin->w_topline)
               - curwin->w_topfill;
   if (curwin->w_p_wrap
-      && curwin->w_width != 0
+      && curwin->w_grid.Columns != 0
       ) {
     validate_virtcol();
-    start_row -= curwin->w_virtcol / curwin->w_width;
+    start_row -= curwin->w_virtcol / curwin->w_grid.Columns;
   }
   if (start_row >= p_so) {
     if (curwin->w_topfill > 0)
@@ -1336,10 +1351,12 @@ void scroll_cursor_top(int min_scroll, int always)
       else
         used += plines(bot);
     }
-    if (used > curwin->w_height)
+    if (used > curwin->w_grid.Rows) {
       break;
-    if (top < curwin->w_topline)
+    }
+    if (top < curwin->w_topline) {
       scrolled += i;
+    }
 
     /*
      * If scrolling is needed, scroll at least 'sj' lines.
@@ -1359,7 +1376,7 @@ void scroll_cursor_top(int min_scroll, int always)
    * This makes sure we get the same position when using "k" and "j"
    * in a small window.
    */
-  if (used > curwin->w_height) {
+  if (used > curwin->w_grid.Rows) {
     scroll_cursor_halfway(false);
   } else {
     /*
@@ -1393,10 +1410,10 @@ void scroll_cursor_top(int min_scroll, int always)
 void set_empty_rows(win_T *wp, int used)
 {
   wp->w_filler_rows = 0;
-  if (used == 0)
-    wp->w_empty_rows = 0;       /* single line that doesn't fit */
-  else {
-    wp->w_empty_rows = wp->w_height - used;
+  if (used == 0) {
+    wp->w_empty_rows = 0;  // single line that doesn't fit
+  } else {
+    wp->w_empty_rows = wp->w_grid.Rows - used;
     if (wp->w_botline <= wp->w_buffer->b_ml.ml_line_count) {
       wp->w_filler_rows = diff_check_fill(wp, wp->w_botline);
       if (wp->w_empty_rows > wp->w_filler_rows)
@@ -1439,8 +1456,9 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
          curwin->w_topline = loff.lnum) {
       loff.lnum = curwin->w_topline;
       topline_back(&loff);
-      if (loff.height == MAXCOL || used + loff.height > curwin->w_height)
+      if (loff.height == MAXCOL || used + loff.height > curwin->w_grid.Rows) {
         break;
+      }
       used += loff.height;
       curwin->w_topfill = loff.fill;
     }
@@ -1497,12 +1515,14 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
 
     /* Add one line above */
     topline_back(&loff);
-    if (loff.height == MAXCOL)
+    if (loff.height == MAXCOL) {
       used = MAXCOL;
-    else
+    } else {
       used += loff.height;
-    if (used > curwin->w_height)
+    }
+    if (used > curwin->w_grid.Rows) {
       break;
+    }
     if (loff.lnum >= curwin->w_botline
         && (loff.lnum > curwin->w_botline
             || loff.fill <= fill_below_window)
@@ -1519,8 +1539,9 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
       /* Add one line below */
       botline_forw(&boff);
       used += boff.height;
-      if (used > curwin->w_height)
+      if (used > curwin->w_grid.Rows) {
         break;
+      }
       if (extra < (
             mouse_dragging > 0 ? mouse_dragging - 1 :
             p_so) || scrolled < min_scroll) {
@@ -1541,14 +1562,14 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
   }
 
   linenr_T line_count;
-  /* curwin->w_empty_rows is larger, no need to scroll */
-  if (scrolled <= 0)
+  // curwin->w_empty_rows is larger, no need to scroll
+  if (scrolled <= 0) {
     line_count = 0;
-  /* more than a screenfull, don't scroll but redraw */
-  else if (used > curwin->w_height)
+  // more than a screenfull, don't scroll but redraw
+  } else if (used > curwin->w_grid.Rows) {
     line_count = used;
-  /* scroll minimal number of lines */
-  else {
+  // scroll minimal number of lines
+  } else {
     line_count = 0;
     boff.fill = curwin->w_topfill;
     boff.lnum = curwin->w_topline - 1;
@@ -1566,10 +1587,11 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
    * Scroll up if the cursor is off the bottom of the screen a bit.
    * Otherwise put it at 1/2 of the screen.
    */
-  if (line_count >= curwin->w_height && line_count > min_scroll)
+  if (line_count >= curwin->w_grid.Rows && line_count > min_scroll) {
     scroll_cursor_halfway(false);
-  else
+  } else {
     scrollup(line_count, true);
+  }
 
   /*
    * If topline didn't change we need to restore w_botline and w_empty_rows
@@ -1608,8 +1630,9 @@ void scroll_cursor_halfway(int atend)
       if (boff.lnum < curbuf->b_ml.ml_line_count) {
         botline_forw(&boff);
         used += boff.height;
-        if (used > curwin->w_height)
+        if (used > curwin->w_grid.Rows) {
           break;
+        }
         below += boff.height;
       } else {
         ++below;                    /* count a "~" line */
@@ -1624,8 +1647,9 @@ void scroll_cursor_halfway(int atend)
         used = MAXCOL;
       else
         used += loff.height;
-      if (used > curwin->w_height)
+      if (used > curwin->w_grid.Rows) {
         break;
+      }
       above += loff.height;
       topline = loff.lnum;
       topfill = loff.fill;
@@ -1634,8 +1658,9 @@ void scroll_cursor_halfway(int atend)
   if (!hasFolding(topline, &curwin->w_topline, NULL))
     curwin->w_topline = topline;
   curwin->w_topfill = topfill;
-  if (old_topline > curwin->w_topline + curwin->w_height)
+  if (old_topline > curwin->w_topline + curwin->w_grid.Rows) {
     curwin->w_botfill = false;
+  }
   check_topfill(curwin, false);
   curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
   curwin->w_valid |= VALID_TOPLINE;
@@ -1662,18 +1687,20 @@ void cursor_correct(void)
   }
   if (curwin->w_topline == 1) {
     above_wanted = 0;
-    int max_off = curwin->w_height / 2;
-    if (below_wanted > max_off)
+    int max_off = curwin->w_grid.Rows / 2;
+    if (below_wanted > max_off) {
       below_wanted = max_off;
+    }
   }
   validate_botline();
   if (curwin->w_botline == curbuf->b_ml.ml_line_count + 1
       && mouse_dragging == 0
       ) {
     below_wanted = 0;
-    int max_off = (curwin->w_height - 1) / 2;
-    if (above_wanted > max_off)
+    int max_off = (curwin->w_grid.Rows - 1) / 2;
+    if (above_wanted > max_off) {
       above_wanted = max_off;
+    }
   }
 
   /*
@@ -1844,7 +1871,7 @@ int onepage(Direction dir, long count)
       /* Find the line just above the new topline to get the right line
        * at the bottom of the window. */
       n = 0;
-      while (n <= curwin->w_height && loff.lnum >= 1) {
+      while (n <= curwin->w_grid.Rows && loff.lnum >= 1) {
         topline_back(&loff);
         if (loff.height == MAXCOL)
           n = MAXCOL;
@@ -1935,7 +1962,7 @@ int onepage(Direction dir, long count)
  */
 static void get_scroll_overlap(lineoff_T *lp, int dir)
 {
-  int min_height = curwin->w_height - 2;
+  int min_height = curwin->w_grid.Rows - 2;
 
   if (lp->fill > 0)
     lp->height = 1;
@@ -1989,12 +2016,13 @@ void halfpage(bool flag, linenr_T Prenum)
   long scrolled = 0;
   int i;
 
-  if (Prenum)
-    curwin->w_p_scr = (Prenum > curwin->w_height) ?
-                      curwin->w_height : Prenum;
+  if (Prenum) {
+    curwin->w_p_scr = (Prenum > curwin->w_grid.Rows) ? curwin->w_grid.Rows
+                                                     : Prenum;
+  }
   assert(curwin->w_p_scr <= INT_MAX);
-  int n = curwin->w_p_scr <= curwin->w_height ? (int)curwin->w_p_scr
-                                              : curwin->w_height;
+  int n = curwin->w_p_scr <= curwin->w_grid.Rows ? (int)curwin->w_p_scr
+                                              : curwin->w_grid.Rows;
 
   update_topline();
   validate_botline();
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 38ee0936aa..a050c95224 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -3466,10 +3466,10 @@ static void display_showcmd(void)
   int len;
 
   len = (int)STRLEN(showcmd_buf);
-  if (len == 0)
+  if (len == 0) {
     showcmd_is_clear = true;
-  else {
-    screen_puts(showcmd_buf, (int)Rows - 1, sc_col, 0);
+  } else {
+    grid_puts(&default_grid, showcmd_buf, (int)Rows - 1, sc_col, 0);
     showcmd_is_clear = false;
   }
 
@@ -3477,7 +3477,8 @@ static void display_showcmd(void)
    * clear the rest of an old message by outputting up to SHOWCMD_COLS
    * spaces
    */
-  screen_puts((char_u *)"          " + len, (int)Rows - 1, sc_col + len, 0);
+  grid_puts(&default_grid, (char_u *)"          " + len, (int)Rows - 1,
+            sc_col + len, 0);
 
   setcursor();              /* put cursor back where it belongs */
 }
@@ -3905,18 +3906,16 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
 
   col_off1 = curwin_col_off();
   col_off2 = col_off1 - curwin_col_off2();
-  width1 = curwin->w_width - col_off1;
-  width2 = curwin->w_width - col_off2;
+  width1 = curwin->w_grid.Columns - col_off1;
+  width2 = curwin->w_grid.Columns - col_off2;
 
   if (width2 == 0) {
     width2 = 1;  // Avoid divide by zero.
   }
 
-  if (curwin->w_width != 0) {
-    /*
-     * Instead of sticking at the last character of the buffer line we
-     * try to stick in the last column of the screen.
-     */
+  if (curwin->w_grid.Columns != 0) {
+    // Instead of sticking at the last character of the buffer line we
+    // try to stick in the last column of the screen.
     if (curwin->w_curswant == MAXCOL) {
       atend = true;
       validate_virtcol();
@@ -4255,7 +4254,7 @@ dozet:
 
   /* "zH" - scroll screen right half-page */
   case 'H':
-    cap->count1 *= curwin->w_width / 2;
+    cap->count1 *= curwin->w_grid.Columns / 2;
     FALLTHROUGH;
 
   /* "zh" - scroll screen to the right */
@@ -4270,8 +4269,8 @@ dozet:
     }
     break;
 
-  /* "zL" - scroll screen left half-page */
-  case 'L':   cap->count1 *= curwin->w_width / 2;
+  // "zL" - scroll screen left half-page
+  case 'L':   cap->count1 *= curwin->w_grid.Columns / 2;
     FALLTHROUGH;
 
   /* "zl" - scroll screen to the left */
@@ -4307,11 +4306,12 @@ dozet:
         col = 0;                        /* like the cursor is in col 0 */
       else
         getvcol(curwin, &curwin->w_cursor, NULL, NULL, &col);
-      n = curwin->w_width - curwin_col_off();
-      if (col + l_p_siso < n)
+      n = curwin->w_grid.Columns - curwin_col_off();
+      if (col + l_p_siso < n) {
         col = 0;
-      else
+      } else {
         col = col + l_p_siso - n + 1;
+      }
       if (curwin->w_leftcol != col) {
         curwin->w_leftcol = col;
         redraw_later(NOT_VALID);
@@ -5016,11 +5016,11 @@ static void nv_scroll(cmdarg_T *cap)
       /* Don't count filler lines above the window. */
       used -= diff_check_fill(curwin, curwin->w_topline)
               - curwin->w_topfill;
-      validate_botline();           /* make sure w_empty_rows is valid */
-      half = (curwin->w_height - curwin->w_empty_rows + 1) / 2;
-      for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; ++n) {
-        /* Count half he number of filler lines to be "below this
-         * line" and half to be "above the next line". */
+      validate_botline();  // make sure w_empty_rows is valid
+      half = (curwin->w_grid.Rows - curwin->w_empty_rows + 1) / 2;
+      for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; n++) {
+        // Count half he number of filler lines to be "below this
+        // line" and half to be "above the next line".
         if (n > 0 && used + diff_check_fill(curwin, curwin->w_topline
                 + n) / 2 >= half) {
           --n;
@@ -5032,9 +5032,10 @@ static void nv_scroll(cmdarg_T *cap)
         if (hasFolding(curwin->w_topline + n, NULL, &lnum))
           n = lnum - curwin->w_topline;
       }
-      if (n > 0 && used > curwin->w_height)
-        --n;
-    } else { /* (cap->cmdchar == 'H') */
+      if (n > 0 && used > curwin->w_grid.Rows) {
+        n--;
+      }
+    } else {  // (cap->cmdchar == 'H')
       n = cap->count1 - 1;
       if (hasAnyFolding(curwin)) {
         /* Count a fold for one screen line. */
@@ -6747,9 +6748,9 @@ static void nv_g_cmd(cmdarg_T *cap)
     oap->motion_type = kMTCharWise;
     oap->inclusive = false;
     if (curwin->w_p_wrap
-        && curwin->w_width != 0
+        && curwin->w_grid.Columns != 0
         ) {
-      int width1 = curwin->w_width - curwin_col_off();
+      int width1 = curwin->w_grid.Columns - curwin_col_off();
       int width2 = width1 + curwin_col_off2();
 
       validate_virtcol();
@@ -6761,10 +6762,11 @@ static void nv_g_cmd(cmdarg_T *cap)
     /* Go to the middle of the screen line.  When 'number' or
      * 'relativenumber' is on and lines are wrapping the middle can be more
      * to the left. */
-    if (cap->nchar == 'm')
-      i += (curwin->w_width - curwin_col_off()
+    if (cap->nchar == 'm') {
+      i += (curwin->w_grid.Columns - curwin_col_off()
             + ((curwin->w_p_wrap && i > 0)
                ? curwin_col_off2() : 0)) / 2;
+    }
     coladvance((colnr_T)i);
     if (flag) {
       do
@@ -6808,11 +6810,11 @@ static void nv_g_cmd(cmdarg_T *cap)
     oap->motion_type = kMTCharWise;
     oap->inclusive = true;
     if (curwin->w_p_wrap
-        && curwin->w_width != 0
+        && curwin->w_grid.Columns != 0
         ) {
       curwin->w_curswant = MAXCOL;              /* so we stay at the end */
       if (cap->count1 == 1) {
-        int width1 = curwin->w_width - col_off;
+        int width1 = curwin->w_grid.Columns - col_off;
         int width2 = width1 + curwin_col_off2();
 
         validate_virtcol();
@@ -6838,7 +6840,7 @@ static void nv_g_cmd(cmdarg_T *cap)
       } else if (nv_screengo(oap, FORWARD, cap->count1 - 1) == false)
         clearopbeep(oap);
     } else {
-      i = curwin->w_leftcol + curwin->w_width - col_off - 1;
+      i = curwin->w_leftcol + curwin->w_grid.Columns - col_off - 1;
       coladvance((colnr_T)i);
 
       /* Make sure we stick in this column. */
@@ -7953,7 +7955,7 @@ static void get_op_vcol(
   colnr_T end;
 
   if (VIsual_mode != Ctrl_V
-      || (!initial && oap->end.col < curwin->w_width)) {
+      || (!initial && oap->end.col < curwin->w_grid.Columns)) {
     return;
   }
 
diff --git a/src/nvim/popupmnu.c b/src/nvim/popupmnu.c
index 68c8967b91..b5c74b5255 100644
--- a/src/nvim/popupmnu.c
+++ b/src/nvim/popupmnu.c
@@ -68,12 +68,12 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed)
   int kind_width;
   int extra_width;
   int i;
-  int row;
   int context_lines;
-  int col;
   int above_row;
   int below_row;
   int redo_count = 0;
+  int row;
+  int col;
 
   if (!pum_is_visible) {
     // To keep the code simple, we only allow changing the
@@ -90,13 +90,20 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed)
     below_row = cmdline_row;
 
     // anchor position: the start of the completed word
-    row = curwin->w_wrow + curwin->w_winrow;
+    row = curwin->w_wrow;
     if (curwin->w_p_rl) {
-      col = curwin->w_wincol + curwin->w_width - curwin->w_wcol - 1;
+      col = curwin->w_width - curwin->w_wcol - 1;
     } else {
       col = curwin->w_wincol + curwin->w_wcol;
     }
 
+    int grid = (int)curwin->w_grid.handle;
+    if (!ui_is_external(kUIMultigrid)) {
+      grid = (int)default_grid.handle;
+      row += curwin->w_winrow;
+      col += curwin->w_wincol;
+    }
+
     if (pum_external) {
       if (array_changed) {
         Array arr = ARRAY_DICT_INIT;
@@ -108,7 +115,7 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed)
           ADD(item, STRING_OBJ(cstr_to_string((char *)array[i].pum_info)));
           ADD(arr, ARRAY_OBJ(item));
         }
-        ui_call_popupmenu_show(arr, selected, row, col);
+        ui_call_popupmenu_show(arr, selected, row, col, grid);
       } else {
         ui_call_popupmenu_select(selected);
       }
@@ -351,10 +358,10 @@ void pum_redraw(void)
     // prepend a space if there is room
     if (curwin->w_p_rl) {
       if (pum_col < curwin->w_wincol + curwin->w_width - 1) {
-        screen_putchar(' ', row, pum_col + 1, attr);
+        grid_putchar(&default_grid, ' ', row, pum_col + 1, attr);
       }
     } else if (pum_col > 0) {
-      screen_putchar(' ', row, pum_col - 1, attr);
+      grid_putchar(&default_grid, ' ', row, pum_col - 1, attr);
     }
 
     // Display each entry, use two spaces for a Tab.
@@ -416,12 +423,13 @@ void pum_redraw(void)
                   size++;
                 }
               }
-              screen_puts_len(rt, (int)STRLEN(rt), row, col - size + 1, attr);
+              grid_puts_len(&default_grid, rt, (int)STRLEN(rt), row,
+                            col - size + 1, attr);
               xfree(rt_start);
               xfree(st);
               col -= width;
             } else {
-              screen_puts_len(st, (int)STRLEN(st), row, col, attr);
+              grid_puts_len(&default_grid, st, (int)STRLEN(st), row, col, attr);
               xfree(st);
               col += width;
             }
@@ -432,10 +440,11 @@ void pum_redraw(void)
 
             // Display two spaces for a Tab.
             if (curwin->w_p_rl) {
-              screen_puts_len((char_u *)"  ", 2, row, col - 1, attr);
+              grid_puts_len(&default_grid, (char_u *)"  ", 2, row, col - 1,
+                            attr);
               col -= 2;
             } else {
-              screen_puts_len((char_u *)"  ", 2, row, col, attr);
+              grid_puts_len(&default_grid, (char_u *)"  ", 2, row, col, attr);
               col += 2;
             }
             totwidth += 2;
@@ -466,36 +475,37 @@ void pum_redraw(void)
       }
 
       if (curwin->w_p_rl) {
-        screen_fill(row, row + 1, pum_col - pum_base_width - n + 1,
-                    col + 1, ' ', ' ', attr);
+        grid_fill(&default_grid, row, row + 1, pum_col - pum_base_width - n + 1,
+                  col + 1, ' ', ' ', attr);
         col = pum_col - pum_base_width - n + 1;
       } else {
-        screen_fill(row, row + 1, col, pum_col + pum_base_width + n,
-                    ' ', ' ', attr);
+        grid_fill(&default_grid, row, row + 1, col,
+                  pum_col + pum_base_width + n, ' ', ' ', attr);
         col = pum_col + pum_base_width + n;
       }
       totwidth = pum_base_width + n;
     }
 
     if (curwin->w_p_rl) {
-      screen_fill(row, row + 1, pum_col - pum_width + 1, col + 1, ' ', ' ',
-                  attr);
+      grid_fill(&default_grid, row, row + 1, pum_col - pum_width + 1, col + 1,
+                ' ', ' ', attr);
     } else {
-      screen_fill(row, row + 1, col, pum_col + pum_width, ' ', ' ', attr);
+      grid_fill(&default_grid, row, row + 1, col, pum_col + pum_width, ' ', ' ',
+                attr);
     }
 
     if (pum_scrollbar > 0) {
       if (curwin->w_p_rl) {
-        screen_putchar(' ', row, pum_col - pum_width,
-                       i >= thumb_pos && i < thumb_pos + thumb_heigth
-                       ? attr_thumb : attr_scroll);
+        grid_putchar(&default_grid, ' ', row, pum_col - pum_width,
+                     i >= thumb_pos && i < thumb_pos + thumb_heigth
+                     ? attr_thumb : attr_scroll);
       } else {
-        screen_putchar(' ', row, pum_col + pum_width,
-                       i >= thumb_pos && i < thumb_pos + thumb_heigth
-                       ? attr_thumb : attr_scroll);
+        grid_putchar(&default_grid, ' ', row, pum_col + pum_width,
+                     i >= thumb_pos && i < thumb_pos + thumb_heigth
+                     ? attr_thumb : attr_scroll);
       }
     }
-    screen_puts_line_flush(false);
+    grid_puts_line_flush(&default_grid, false);
     row++;
   }
 }
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index d095bdb7c8..770e00a80e 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -7,8 +7,7 @@
 // by remembering what is already on the screen, and only updating the parts
 // that changed.
 //
-// The screen_*() functions write to the screen and handle updating
-// ScreenLines[].
+// The grid_*() functions write to the screen and handle updating grid->lines[].
 //
 // update_screen() is the function that updates all windows and status lines.
 // It is called from the main loop when must_redraw is non-zero.  It may be
@@ -119,17 +118,21 @@
 #define MB_FILLER_CHAR '<'  /* character used when a double-width character
                              * doesn't fit. */
 #define W_ENDCOL(wp)   (wp->w_wincol + wp->w_width)
+#define W_ENDROW(wp)   (wp->w_winrow + wp->w_height)
+
+
+// temporary buffer for rendering a single screenline, so it can be
+// comparared with previous contents to calulate smallest delta.
+static size_t linebuf_size = 0;
+static schar_T *linebuf_char = NULL;
+static sattr_T *linebuf_attr = NULL;
 
 static match_T search_hl;       /* used for 'hlsearch' highlight matching */
 
 static foldinfo_T win_foldinfo; /* info for 'foldcolumn' */
 
-/*
- * Buffer for one screen line (characters and attributes).
- */
-static schar_T  *current_ScreenLine;
-
 StlClickDefinition *tab_page_click_defs = NULL;
+
 long tab_page_click_defs_size = 0;
 
 // for line_putchar. Contains the state that needs to be remembered from
@@ -141,6 +144,12 @@ typedef struct {
 } LineState;
 #define LINE_STATE(p) { p, 0, 0 }
 
+/// Whether to call "ui_call_grid_resize" in win_grid_alloc
+static bool send_grid_resize = false;
+
+/// Highlight ids are no longer valid. Force retransmission
+static bool highlights_invalid = false;
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "screen.c.generated.h"
 #endif
@@ -177,6 +186,12 @@ void redraw_all_later(int type)
   }
 }
 
+void screen_invalidate_highlights(void)
+{
+  redraw_all_later(NOT_VALID);
+  highlights_invalid = true;
+}
+
 /*
  * Mark all windows that are editing the current buffer to be updated later.
  */
@@ -237,12 +252,12 @@ void update_curbuf(int type)
   update_screen(type);
 }
 
-/*
- * update_screen()
- *
- * Based on the current value of curwin->w_topline, transfer a screenfull
- * of stuff from Filemem to ScreenLines[], and update curwin->w_botline.
- */
+/// Redraw the parts of the screen that is marked for redraw.
+///
+/// Most code shouldn't call this directly, rather use redraw_later() and
+/// and redraw_all_later() to mark parts of the screen as needing a redraw.
+///
+/// @param type set to a NOT_VALID to force redraw of entire screen
 void update_screen(int type)
 {
   static int did_intro = FALSE;
@@ -285,6 +300,7 @@ void update_screen(int type)
    * if the screen was scrolled up when displaying a message, scroll it down
    */
   if (msg_scrolled) {
+    ui_call_win_scroll_over_reset();
     clear_cmdline = true;
     if (dy_flags & DY_MSGSEP) {
       int valid = MAX(Rows - msg_scrollsize(), 0);
@@ -292,25 +308,25 @@ void update_screen(int type)
         redraw_tabline = true;
       }
       FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-        if (wp->w_winrow + wp->w_height > valid) {
+        if (W_ENDROW(wp) > valid) {
           wp->w_redr_type = NOT_VALID;
           wp->w_lines_valid = 0;
         }
-        if (wp->w_winrow + wp->w_height + wp->w_status_height > valid) {
+        if (W_ENDROW(wp) + wp->w_status_height > valid) {
           wp->w_redr_status = true;
         }
       }
-    } else if (msg_scrolled > Rows - 5) {  // clearing is faster
+    } else if (msg_scrolled > default_grid.Rows - 5) {  // clearing is faster
       type = CLEAR;
     } else if (type != CLEAR) {
       check_for_delay(false);
-      if (screen_ins_lines(0, msg_scrolled, (int)Rows, 0, (int)Columns)
-          == FAIL) {
+      if (grid_ins_lines(&default_grid, 0, msg_scrolled, (int)Rows,
+                         0, (int)Columns) == FAIL) {
         type = CLEAR;
       }
       FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
         if (wp->w_winrow < msg_scrolled) {
-          if (wp->w_winrow + wp->w_height > msg_scrolled
+          if (W_ENDROW(wp) > msg_scrolled
               && wp->w_redr_type < REDRAW_TOP
               && wp->w_lines_valid > 0
               && wp->w_topline == wp->w_lines[0].wl_lnum) {
@@ -318,7 +334,7 @@ void update_screen(int type)
             wp->w_redr_type = REDRAW_TOP;
           } else {
             wp->w_redr_type = NOT_VALID;
-            if (wp->w_winrow + wp->w_height + wp->w_status_height
+            if (W_ENDROW(wp) + wp->w_status_height
                 <= msg_scrolled) {
               wp->w_redr_status = TRUE;
             }
@@ -345,6 +361,8 @@ void update_screen(int type)
     type = NOT_VALID;
     // must_redraw may be set indirectly, avoid another redraw later
     must_redraw = 0;
+  } else if (highlights_invalid) {
+    grid_invalidate(&default_grid);
   }
 
   if (clear_cmdline)            /* going to clear cmdline (done below) */
@@ -430,6 +448,8 @@ void update_screen(int type)
       win_redr_status(wp, true);  // any popup menu will be redrawn below
     }
   }
+  send_grid_resize = false;
+  highlights_invalid = false;
   end_search_hl();
   // May need to redraw the popup menu.
   if (pum_drawn()) {
@@ -498,7 +518,7 @@ void update_single_line(win_T *wp, linenr_T lnum)
   int j;
 
   // Don't do anything if the screen structures are (not yet) valid.
-  if (!screen_valid(true) || updating_screen) {
+  if (linebuf_char == NULL || updating_screen) {
     return;
   }
   updating_screen = true;
@@ -512,6 +532,8 @@ void update_single_line(win_T *wp, linenr_T lnum)
         start_search_hl();
         prepare_search_hl(wp, lnum);
         update_window_hl(wp, false);
+        // allocate window grid if not already
+        win_grid_alloc(wp);
         win_line(wp, lnum, row, row + wp->w_lines[j].wl_size, false, false);
         end_search_hl();
         break;
@@ -669,20 +691,22 @@ static void win_update(win_T *wp)
 
   type = wp->w_redr_type;
 
+  win_grid_alloc(wp);
+
   if (type >= NOT_VALID) {
     wp->w_redr_status = true;
     wp->w_lines_valid = 0;
   }
 
-  /* Window is zero-height: nothing to draw. */
-  if (wp->w_height == 0) {
+  // Window is zero-height: nothing to draw.
+  if (wp->w_grid.Rows == 0) {
     wp->w_redr_type = 0;
     return;
   }
 
-  /* Window is zero-width: Only need to draw the separator. */
-  if (wp->w_width == 0) {
-    /* draw the vertical separator right of this window */
+  // Window is zero-width: Only need to draw the separator.
+  if (wp->w_grid.Columns == 0) {
+    // draw the vertical separator right of this window
     draw_vsep_win(wp, 0);
     wp->w_redr_type = 0;
     return;
@@ -699,8 +723,8 @@ static void win_update(win_T *wp)
 
     if (buf->terminal) {
       terminal_resize(buf->terminal,
-                      (uint16_t)(MAX(0, wp->w_width - win_col_off(wp))),
-                      (uint16_t)wp->w_height);
+                      (uint16_t)(MAX(0, wp->w_grid.Columns - win_col_off(wp))),
+                      (uint16_t)wp->w_grid.Rows);
     }
   } else if (buf->b_mod_set
              && buf->b_mod_xlines != 0
@@ -870,21 +894,22 @@ static void win_update(win_T *wp)
         /* count the number of lines we are off, counting a sequence
          * of folded lines as one */
         j = 0;
-        for (ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ++ln) {
-          ++j;
-          if (j >= wp->w_height - 2)
+        for (ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ln++) {
+          j++;
+          if (j >= wp->w_grid.Rows - 2) {
             break;
+          }
           (void)hasFoldingWin(wp, ln, NULL, &ln, true, NULL);
         }
       } else
         j = wp->w_lines[0].wl_lnum - wp->w_topline;
-      if (j < wp->w_height - 2) {               /* not too far off */
+      if (j < wp->w_grid.Rows - 2) {               // not too far off
         i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1);
         /* insert extra lines for previously invisible filler lines */
         if (wp->w_lines[0].wl_lnum != wp->w_topline)
           i += diff_check_fill(wp, wp->w_lines[0].wl_lnum)
                - wp->w_old_topfill;
-        if (i < wp->w_height - 2) {  // less than a screen off
+        if (i < wp->w_grid.Rows - 2) {  // less than a screen off
           // Try to insert the correct number of lines.
           // If not the last window, delete the lines at the bottom.
           // win_ins_lines may fail when the terminal can't do it.
@@ -897,12 +922,15 @@ static void win_update(win_T *wp)
 
               /* Move the entries that were scrolled, disable
                * the entries for the lines to be redrawn. */
-              if ((wp->w_lines_valid += j) > wp->w_height)
-                wp->w_lines_valid = wp->w_height;
-              for (idx = wp->w_lines_valid; idx - j >= 0; idx--)
+              if ((wp->w_lines_valid += j) > wp->w_grid.Rows) {
+                wp->w_lines_valid = wp->w_grid.Rows;
+              }
+              for (idx = wp->w_lines_valid; idx - j >= 0; idx--) {
                 wp->w_lines[idx] = wp->w_lines[idx - j];
-              while (idx >= 0)
-                wp->w_lines[idx--].wl_valid = FALSE;
+              }
+              while (idx >= 0) {
+                wp->w_lines[idx--].wl_valid = false;
+              }
             }
           } else
             mid_start = 0;                      /* redraw all lines */
@@ -947,7 +975,7 @@ static void win_update(win_T *wp)
         row -= wp->w_topfill;
         if (row > 0) {
           if (win_del_lines(wp, 0, row) == OK) {
-            bot_start = wp->w_height - row;
+            bot_start = wp->w_grid.Rows - row;
           } else {
             mid_start = 0;                      // redraw all lines
           }
@@ -966,7 +994,7 @@ static void win_update(win_T *wp)
             /* stop at line that didn't fit, unless it is still
              * valid (no lines deleted) */
             if (row > 0 && bot_start + row
-                + (int)wp->w_lines[j].wl_size > wp->w_height) {
+                + (int)wp->w_lines[j].wl_size > wp->w_grid.Rows) {
               wp->w_lines_valid = idx + 1;
               break;
             }
@@ -990,18 +1018,18 @@ static void win_update(win_T *wp)
 
     // When starting redraw in the first line, redraw all lines.
     if (mid_start == 0) {
-      mid_end = wp->w_height;
+      mid_end = wp->w_grid.Rows;
     }
   } else {
     /* Not VALID or INVERTED: redraw all lines. */
     mid_start = 0;
-    mid_end = wp->w_height;
+    mid_end = wp->w_grid.Rows;
   }
 
   if (type == SOME_VALID) {
     /* SOME_VALID: redraw all lines. */
     mid_start = 0;
-    mid_end = wp->w_height;
+    mid_end = wp->w_grid.Rows;
     type = NOT_VALID;
   }
 
@@ -1146,8 +1174,8 @@ static void win_update(win_T *wp)
           ++lnum;
       }
       srow += mid_start;
-      mid_end = wp->w_height;
-      for (; idx < wp->w_lines_valid; ++idx) {                  /* find end */
+      mid_end = wp->w_grid.Rows;
+      for (; idx < wp->w_lines_valid; idx++) {                  // find end
         if (wp->w_lines[idx].wl_valid
             && wp->w_lines[idx].wl_lnum >= to + 1) {
           /* Only update until first row of this line */
@@ -1187,8 +1215,8 @@ static void win_update(win_T *wp)
   for (;; ) {
     /* stop updating when reached the end of the window (check for _past_
      * the end of the window is at the end of the loop) */
-    if (row == wp->w_height) {
-      didline = TRUE;
+    if (row == wp->w_grid.Rows) {
+      didline = true;
       break;
     }
 
@@ -1286,8 +1314,8 @@ static void win_update(win_T *wp)
               new_rows += plines_win(wp, l, true);
             }
             j++;
-            if (new_rows > wp->w_height - row - 2) {
-              /* it's getting too much, must redraw the rest */
+            if (new_rows > wp->w_grid.Rows - row - 2) {
+              // it's getting too much, must redraw the rest
               new_rows = 9999;
               break;
             }
@@ -1298,20 +1326,20 @@ static void win_update(win_T *wp)
              * remaining text or scrolling fails, must redraw the
              * rest.  If scrolling works, must redraw the text
              * below the scrolled text. */
-            if (row - xtra_rows >= wp->w_height - 2) {
+            if (row - xtra_rows >= wp->w_grid.Rows - 2) {
               mod_bot = MAXLNUM;
             } else {
               if (win_del_lines(wp, row, -xtra_rows) == FAIL) {
                 mod_bot = MAXLNUM;
               } else {
-                  bot_start = wp->w_height + xtra_rows;
+                bot_start = wp->w_grid.Rows + xtra_rows;
               }
             }
           } else if (xtra_rows > 0) {
             /* May scroll text down.  If there is not enough
              * remaining text of scrolling fails, must redraw the
              * rest. */
-            if (row + xtra_rows >= wp->w_height - 2) {
+            if (row + xtra_rows >= wp->w_grid.Rows - 2) {
               mod_bot = MAXLNUM;
             } else {
               if (win_ins_lines(wp, row + old_rows, xtra_rows) == FAIL) {
@@ -1340,7 +1368,7 @@ static void win_update(win_T *wp)
                 wp->w_lines[j] = wp->w_lines[i];
                 /* stop at a line that won't fit */
                 if (x + (int)wp->w_lines[j].wl_size
-                    > wp->w_height) {
+                    > wp->w_grid.Rows) {
                   wp->w_lines_valid = j + 1;
                   break;
                 }
@@ -1353,10 +1381,12 @@ static void win_update(win_T *wp)
                              /* move entries in w_lines[] downwards */
               j -= i;
               wp->w_lines_valid += j;
-              if (wp->w_lines_valid > wp->w_height)
-                wp->w_lines_valid = wp->w_height;
-              for (i = wp->w_lines_valid; i - j >= idx; --i)
+              if (wp->w_lines_valid > wp->w_grid.Rows) {
+                wp->w_lines_valid = wp->w_grid.Rows;
+              }
+              for (i = wp->w_lines_valid; i - j >= idx; i--) {
                 wp->w_lines[i] = wp->w_lines[i - j];
+              }
 
               /* The w_lines[] entries for inserted lines are
                * now invalid, but wl_size may be used above.
@@ -1388,12 +1418,12 @@ static void win_update(win_T *wp)
                  && wp->w_lines[idx].wl_lnum == lnum
                  && lnum > wp->w_topline
                  && !(dy_flags & (DY_LASTLINE | DY_TRUNCATE))
-                 && srow + wp->w_lines[idx].wl_size > wp->w_height
+                 && srow + wp->w_lines[idx].wl_size > wp->w_grid.Rows
                  && diff_check_fill(wp, lnum) == 0
                  ) {
         /* This line is not going to fit.  Don't draw anything here,
          * will draw "@  " lines below. */
-        row = wp->w_height + 1;
+        row = wp->w_grid.Rows + 1;
       } else {
         prepare_search_hl(wp, lnum);
         /* Let the syntax stuff know we skipped a few lines. */
@@ -1404,7 +1434,7 @@ static void win_update(win_T *wp)
         /*
          * Display one line.
          */
-        row = win_line(wp, lnum, srow, wp->w_height, mod_top == 0, false);
+        row = win_line(wp, lnum, srow, wp->w_grid.Rows, mod_top == 0, false);
 
         wp->w_lines[idx].wl_folded = FALSE;
         wp->w_lines[idx].wl_lastlnum = lnum;
@@ -1415,10 +1445,7 @@ static void win_update(win_T *wp)
       wp->w_lines[idx].wl_lnum = lnum;
       wp->w_lines[idx].wl_valid = true;
 
-      // Past end of the window or end of the screen. Note that after
-      // resizing wp->w_height may be end up too big. That's a problem
-      // elsewhere, but prevent a crash here.
-      if (row > wp->w_height || row + wp->w_winrow >= Rows) {
+      if (row > wp->w_grid.Rows) {         // past end of grid
         // we may need the size of that too long line later on
         if (dollar_vcol == -1) {
           wp->w_lines[idx].wl_size = plines_win(wp, lnum, true);
@@ -1434,13 +1461,14 @@ static void win_update(win_T *wp)
       if (wp->w_p_rnu) {
         // 'relativenumber' set: The text doesn't need to be drawn, but
         // the number column nearly always does.
-        (void)win_line(wp, lnum, srow, wp->w_height, true, true);
+        (void)win_line(wp, lnum, srow, wp->w_grid.Rows, true, true);
       }
 
       // This line does not need to be drawn, advance to the next one.
       row += wp->w_lines[idx++].wl_size;
-      if (row > wp->w_height)           /* past end of screen */
+      if (row > wp->w_grid.Rows) {  // past end of screen
         break;
+      }
       lnum = wp->w_lines[idx - 1].wl_lastlnum + 1;
       did_update = DID_NONE;
     }
@@ -1479,31 +1507,28 @@ static void win_update(win_T *wp)
        * Don't overwrite it, it can be edited.
        */
       wp->w_botline = lnum + 1;
-    } else if (diff_check_fill(wp, lnum) >= wp->w_height - srow) {
-      /* Window ends in filler lines. */
+    } else if (diff_check_fill(wp, lnum) >= wp->w_grid.Rows - srow) {
+      // Window ends in filler lines.
       wp->w_botline = lnum;
-      wp->w_filler_rows = wp->w_height - srow;
+      wp->w_filler_rows = wp->w_grid.Rows - srow;
     } else if (dy_flags & DY_TRUNCATE) {      // 'display' has "truncate"
-      int scr_row = wp->w_winrow + wp->w_height - 1;
+      int scr_row = wp->w_grid.Rows - 1;
 
       // Last line isn't finished: Display "@@@" in the last screen line.
-      screen_puts_len((char_u *)"@@", 2, scr_row, wp->w_wincol, at_attr);
+      grid_puts_len(&wp->w_grid, (char_u *)"@@", 2, scr_row, 0, at_attr);
 
-      screen_fill(scr_row, scr_row + 1,
-                  (int)wp->w_wincol + 2, (int)W_ENDCOL(wp),
-                  '@', ' ', at_attr);
+      grid_fill(&wp->w_grid, scr_row, scr_row + 1, 2, (int)wp->w_grid.Columns,
+                '@', ' ', at_attr);
       set_empty_rows(wp, srow);
       wp->w_botline = lnum;
     } else if (dy_flags & DY_LASTLINE) {      // 'display' has "lastline"
       // Last line isn't finished: Display "@@@" at the end.
-      screen_fill(wp->w_winrow + wp->w_height - 1,
-                  wp->w_winrow + wp->w_height,
-                  W_ENDCOL(wp) - 3, W_ENDCOL(wp),
-                  '@', '@', at_attr);
+      grid_fill(&wp->w_grid, wp->w_grid.Rows - 1, wp->w_grid.Rows,
+                wp->w_grid.Columns - 3, wp->w_grid.Columns, '@', '@', at_attr);
       set_empty_rows(wp, srow);
       wp->w_botline = lnum;
     } else {
-      win_draw_end(wp, '@', ' ', srow, wp->w_height, HLF_AT);
+      win_draw_end(wp, '@', ' ', srow, wp->w_grid.Rows, HLF_AT);
       wp->w_botline = lnum;
     }
   } else {
@@ -1518,8 +1543,9 @@ static void win_update(win_T *wp)
           i = '-';
         else
           i = fill_diff;
-        if (row + j > wp->w_height)
-          j = wp->w_height - row;
+        if (row + j > wp->w_grid.Rows) {
+          j = wp->w_grid.Rows - row;
+        }
         win_draw_end(wp, i, i, row, row + (int)j, HLF_DED);
         row += j;
       }
@@ -1528,7 +1554,7 @@ static void win_update(win_T *wp)
 
     // make sure the rest of the screen is blank
     // write the 'fill_eob' character to rows that aren't part of the file.
-    win_draw_end(wp, fill_eob, ' ', row, wp->w_height, HLF_EOB);
+    win_draw_end(wp, fill_eob, ' ', row, wp->w_grid.Rows, HLF_EOB);
   }
 
   if (wp->w_redr_type >= REDRAW_TOP) {
@@ -1607,71 +1633,67 @@ static void win_draw_end(win_T *wp, int c1, int c2, int row, int endrow, hlf_T h
     n = fdc;
 
     if (n > 0) {
-      /* draw the fold column at the right */
-      if (n > wp->w_width)
-        n = wp->w_width;
-      screen_fill(wp->w_winrow + row, wp->w_winrow + endrow,
-                  W_ENDCOL(wp) - n, W_ENDCOL(wp),
-                  ' ', ' ', win_hl_attr(wp, HLF_FC));
+      // draw the fold column at the right
+      if (n > wp->w_grid.Columns) {
+        n = wp->w_grid.Columns;
+      }
+      grid_fill(&wp->w_grid, row, endrow, wp->w_grid.Columns - n,
+                wp->w_grid.Columns, ' ', ' ', win_hl_attr(wp, HLF_FC));
     }
 
     if (signcolumn_on(wp)) {
         int nn = n + win_signcol_width(wp);
 
-        /* draw the sign column left of the fold column */
-        if (nn > wp->w_width) {
-            nn = wp->w_width;
+        // draw the sign column left of the fold column
+        if (nn > wp->w_grid.Columns) {
+            nn = wp->w_grid.Columns;
         }
-        screen_fill(wp->w_winrow + row, wp->w_winrow + endrow,
-                    W_ENDCOL(wp) - nn, W_ENDCOL(wp) - n,
-                    ' ', ' ', win_hl_attr(wp, HLF_SC));
+        grid_fill(&wp->w_grid, row, endrow, wp->w_grid.Columns - nn,
+                  wp->w_grid.Columns - n, ' ', ' ', win_hl_attr(wp, HLF_SC));
         n = nn;
     }
 
-    screen_fill(wp->w_winrow + row, wp->w_winrow + endrow,
-                wp->w_wincol, W_ENDCOL(wp) - 1 - FDC_OFF,
-                c2, c2, attr);
-    screen_fill(wp->w_winrow + row, wp->w_winrow + endrow,
-                W_ENDCOL(wp) - 1 - FDC_OFF, W_ENDCOL(wp) - FDC_OFF,
-                c1, c2, attr);
+    grid_fill(&wp->w_grid, row, endrow, 0, wp->w_grid.Columns - 1 - FDC_OFF,
+              c2, c2, attr);
+    grid_fill(&wp->w_grid, row, endrow,
+              wp->w_grid.Columns - 1 - FDC_OFF, wp->w_grid.Columns - FDC_OFF,
+              c1, c2, attr);
   } else {
     if (cmdwin_type != 0 && wp == curwin) {
       /* draw the cmdline character in the leftmost column */
       n = 1;
-      if (n > wp->w_width)
-        n = wp->w_width;
-      screen_fill(wp->w_winrow + row, wp->w_winrow + endrow,
-                  wp->w_wincol, wp->w_wincol + n,
-                  cmdwin_type, ' ', win_hl_attr(wp, HLF_AT));
+      if (n > wp->w_grid.Columns) {
+        n = wp->w_grid.Columns;
+      }
+      grid_fill(&wp->w_grid, row, endrow, 0, n, cmdwin_type, ' ',
+                win_hl_attr(wp, HLF_AT));
     }
     if (fdc > 0) {
       int nn = n + fdc;
 
-      /* draw the fold column at the left */
-      if (nn > wp->w_width)
-        nn = wp->w_width;
-      screen_fill(wp->w_winrow + row, wp->w_winrow + endrow,
-                  wp->w_wincol + n, wp->w_wincol + nn,
-                  ' ', ' ', win_hl_attr(wp, HLF_FC));
+      // draw the fold column at the left
+      if (nn > wp->w_grid.Columns) {
+        nn = wp->w_grid.Columns;
+      }
+      grid_fill(&wp->w_grid, row, endrow, n, nn, ' ', ' ',
+                win_hl_attr(wp, HLF_FC));
       n = nn;
     }
 
     if (signcolumn_on(wp)) {
         int nn = n + win_signcol_width(wp);
 
-        /* draw the sign column after the fold column */
-        if (nn > wp->w_width) {
-            nn = wp->w_width;
+        // draw the sign column after the fold column
+        if (nn > wp->w_grid.Columns) {
+            nn = wp->w_grid.Columns;
         }
-        screen_fill(wp->w_winrow + row, wp->w_winrow + endrow,
-                    wp->w_wincol + n, wp->w_wincol + nn,
-                    ' ', ' ', win_hl_attr(wp, HLF_SC));
+        grid_fill(&wp->w_grid, row, endrow, n, nn, ' ', ' ',
+                  win_hl_attr(wp, HLF_SC));
         n = nn;
     }
 
-    screen_fill(wp->w_winrow + row, wp->w_winrow + endrow,
-                wp->w_wincol + FDC_OFF, W_ENDCOL(wp),
-                c1, c2, attr);
+    grid_fill(&wp->w_grid, row, endrow, FDC_OFF, wp->w_grid.Columns, c1, c2,
+              attr);
   }
   set_empty_rows(wp, row);
 }
@@ -1693,7 +1715,7 @@ static int compute_foldcolumn(win_T *wp, int col)
 {
   int fdc = wp->w_p_fdc;
   int wmw = wp == curwin && p_wmw == 0 ? 1 : p_wmw;
-  int wwidth = wp->w_width;
+  int wwidth = wp->w_grid.Columns;
 
   if (fdc > wwidth - (col + wmw)) {
     fdc = wwidth - (col + wmw);
@@ -1764,7 +1786,7 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
   int fdc;
   int col;
   int txtcol;
-  int off = (int)(current_ScreenLine - ScreenLines);
+  int off;
   int ri;
 
   /* Build the fold line:
@@ -1776,14 +1798,15 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
    * 6. set highlighting for the Visual area an other text
    */
   col = 0;
+  off = 0;
 
   /*
    * 1. Add the cmdwin_type for the command-line window
    * Ignores 'rightleft', this window is never right-left.
    */
   if (cmdwin_type != 0 && wp == curwin) {
-    schar_from_ascii(ScreenLines[off], cmdwin_type);
-    ScreenAttrs[off] = win_hl_attr(wp, HLF_AT);
+    schar_from_ascii(linebuf_char[off], cmdwin_type);
+    linebuf_attr[off] = win_hl_attr(wp, HLF_AT);
     col++;
   }
 
@@ -1795,11 +1818,12 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
     if (wp->w_p_rl) {
       int i;
 
-      copy_text_attr(off + wp->w_width - fdc - col, buf, fdc,
+      copy_text_attr(off + wp->w_grid.Columns - fdc - col, buf, fdc,
                      win_hl_attr(wp, HLF_FC));
       // reverse the fold column
       for (i = 0; i < fdc; i++) {
-        schar_from_ascii(ScreenLines[off + wp->w_width - i - 1 - col], buf[i]);
+        schar_from_ascii(linebuf_char[off + wp->w_grid.Columns - i - 1 - col],
+                         buf[i]);
       }
     } else {
       copy_text_attr(off + col, buf, fdc, win_hl_attr(wp, HLF_FC));
@@ -1807,20 +1831,23 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
     col += fdc;
   }
 
-# define RL_MEMSET(p, v, l)  if (wp->w_p_rl) \
-    for (ri = 0; ri < l; ++ri) \
-      ScreenAttrs[off + (wp->w_width - (p) - (l)) + ri] = v; \
-  else \
-    for (ri = 0; ri < l; ++ri) \
-      ScreenAttrs[off + (p) + ri] = v
+# define RL_MEMSET(p, v, l)  if (wp->w_p_rl) { \
+    for (ri = 0; ri < l; ri++) { \
+      linebuf_attr[off + (wp->w_grid.Columns - (p) - (l)) + ri] = v; \
+    } \
+  } else { \
+    for (ri = 0; ri < l; ri++) { \
+      linebuf_attr[off + (p) + ri] = v; \
+    } \
+  }
 
   /* Set all attributes of the 'number' or 'relativenumber' column and the
    * text */
-  RL_MEMSET(col, win_hl_attr(wp, HLF_FL), wp->w_width - col);
+  RL_MEMSET(col, win_hl_attr(wp, HLF_FL), wp->w_grid.Columns - col);
 
   // If signs are being displayed, add spaces.
   if (signcolumn_on(wp)) {
-      len = wp->w_width - col;
+      len = wp->w_grid.Columns - col;
       if (len > 0) {
           int len_max = win_signcol_width(wp);
           if (len > len_max) {
@@ -1836,7 +1863,7 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
    * 3. Add the 'number' or 'relativenumber' column
    */
   if (wp->w_p_nu || wp->w_p_rnu) {
-    len = wp->w_width - col;
+    len = wp->w_grid.Columns - col;
     if (len > 0) {
       int w = number_width(wp);
       long num;
@@ -1862,7 +1889,7 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
       snprintf((char *)buf, FOLD_TEXT_LEN, fmt, w, num);
       if (wp->w_p_rl) {
         // the line number isn't reversed
-        copy_text_attr(off + wp->w_width - len - col, buf, len,
+        copy_text_attr(off + wp->w_grid.Columns - len - col, buf, len,
                        win_hl_attr(wp, HLF_FL));
       } else {
         copy_text_attr(off + col, buf, len, win_hl_attr(wp, HLF_FL));
@@ -1878,11 +1905,9 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
 
   txtcol = col;         /* remember where text starts */
 
-  /*
-   * 5. move the text to current_ScreenLine.  Fill up with "fill_fold".
-   *    Right-left text is put in columns 0 - number-col, normal text is put
-   *    in columns number-col - window-width.
-   */
+  // 5. move the text to linebuf_char[off].  Fill up with "fill_fold".
+  //    Right-left text is put in columns 0 - number-col, normal text is put
+  //    in columns number-col - window-width.
   int idx;
 
   if (wp->w_p_rl) {
@@ -1898,8 +1923,8 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
     // if(col + cells > wp->w_width - (wp->w_p_rl ? col : 0)) { break; }
     // This is obvious wrong. If Vim ever fixes this, solve for "cells" again
     // in the correct condition.
-    int maxcells = wp->w_width - col - (wp->w_p_rl ? col : 0);
-    int cells = line_putchar(&s, &ScreenLines[idx], maxcells, wp->w_p_rl);
+    int maxcells = wp->w_grid.Columns - col - (wp->w_p_rl ? col : 0);
+    int cells = line_putchar(&s, &linebuf_char[idx], maxcells, wp->w_p_rl);
     if (cells == -1) {
       break;
     }
@@ -1913,10 +1938,10 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
 
   schar_T sc;
   schar_from_char(sc, fill_fold);
-  while (col < wp->w_width
+  while (col < wp->w_grid.Columns
          - (wp->w_p_rl ? txtcol : 0)
          ) {
-    schar_copy(ScreenLines[off+col++], sc);
+    schar_copy(linebuf_char[off+col++], sc);
   }
 
   if (text != buf)
@@ -1948,20 +1973,21 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
                         >= (colnr_T)STRLEN(ml_get_buf(wp->w_buffer, lnume,
                                 FALSE))))))) {
       if (VIsual_mode == Ctrl_V) {
-        /* Visual block mode: highlight the chars part of the block */
-        if (wp->w_old_cursor_fcol + txtcol < (colnr_T)wp->w_width) {
+        // Visual block mode: highlight the chars part of the block
+        if (wp->w_old_cursor_fcol + txtcol < (colnr_T)wp->w_grid.Columns) {
           if (wp->w_old_cursor_lcol != MAXCOL
               && wp->w_old_cursor_lcol + txtcol
-              < (colnr_T)wp->w_width)
+              < (colnr_T)wp->w_grid.Columns) {
             len = wp->w_old_cursor_lcol;
-          else
-            len = wp->w_width - txtcol;
+          } else {
+            len = wp->w_grid.Columns - txtcol;
+          }
           RL_MEMSET(wp->w_old_cursor_fcol + txtcol, win_hl_attr(wp, HLF_V),
                     len - (int)wp->w_old_cursor_fcol);
         }
       } else {
         // Set all attributes of the text
-        RL_MEMSET(txtcol, win_hl_attr(wp, HLF_V), wp->w_width - txtcol);
+        RL_MEMSET(txtcol, win_hl_attr(wp, HLF_V), wp->w_grid.Columns - txtcol);
       }
     }
   }
@@ -1979,9 +2005,9 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
       } else {
         txtcol -= wp->w_leftcol;
       }
-      if (txtcol >= 0 && txtcol < wp->w_width) {
-        ScreenAttrs[off + txtcol] =
-          hl_combine_attr(ScreenAttrs[off + txtcol], win_hl_attr(wp, HLF_MC));
+      if (txtcol >= 0 && txtcol < wp->w_grid.Columns) {
+        linebuf_attr[off + txtcol] =
+          hl_combine_attr(linebuf_attr[off + txtcol], win_hl_attr(wp, HLF_MC));
       }
       txtcol = old_txtcol;
       j = wp->w_p_cc_cols[++i];
@@ -1995,13 +2021,14 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
       txtcol -= wp->w_skipcol;
     else
       txtcol -= wp->w_leftcol;
-    if (txtcol >= 0 && txtcol < wp->w_width)
-      ScreenAttrs[off + txtcol] = hl_combine_attr(
-          ScreenAttrs[off + txtcol], win_hl_attr(wp, HLF_CUC));
+    if (txtcol >= 0 && txtcol < wp->w_grid.Columns) {
+      linebuf_attr[off + txtcol] = hl_combine_attr(
+          linebuf_attr[off + txtcol], win_hl_attr(wp, HLF_CUC));
+    }
   }
 
-  screen_line(row + wp->w_winrow, wp->w_wincol, wp->w_width,
-              wp->w_width, false, wp, wp->w_hl_attr_normal, false);
+  grid_put_linebuf(&wp->w_grid, row, 0, wp->w_grid.Columns, wp->w_grid.Columns,
+                   false, wp, wp->w_hl_attr_normal, false);
 
   /*
    * Update w_cline_height and w_cline_folded if the cursor line was
@@ -2018,7 +2045,7 @@ static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T
 }
 
 
-/// Copy "buf[len]" to ScreenLines["off"] and set attributes to "attr".
+/// Copy "buf[len]" to linebuf_char["off"] and set attributes to "attr".
 ///
 /// Only works for ASCII text!
 static void copy_text_attr(int off, char_u *buf, int len, int attr)
@@ -2026,8 +2053,8 @@ static void copy_text_attr(int off, char_u *buf, int len, int attr)
   int i;
 
   for (i = 0; i < len; i++) {
-    schar_from_ascii(ScreenLines[off + i], buf[i]);
-    ScreenAttrs[off + i] = attr;
+    schar_from_ascii(linebuf_char[off + i], buf[i]);
+    linebuf_attr[off + i] = attr;
   }
 }
 
@@ -2102,7 +2129,6 @@ win_line (
     bool number_only                  // only update the number column
 )
 {
-  unsigned off;                         // offset in ScreenLines/ScreenAttrs
   int c = 0;                            // init for GCC
   long vcol = 0;                        // virtual column (for tabs)
   long vcol_sbr = -1;                   // virtual column after showbreak
@@ -2110,7 +2136,7 @@ win_line (
   char_u      *line;                    // current line
   char_u      *ptr;                     // current position in "line"
   int row;                              // row in the window, excl w_winrow
-  int screen_row;                       // row on the screen, incl w_winrow
+  ScreenGrid *grid = &wp->w_grid;       // grid specfic to the window
 
   char_u extra[18];                     /* line number and 'fdc' must fit in here */
   int n_extra = 0;                      /* number of extra chars */
@@ -2240,7 +2266,6 @@ win_line (
     return startrow;
 
   row = startrow;
-  screen_row = row + wp->w_winrow;
 
   if (!number_only) {
     // To speed up the loop below, set extra_check when there is linebreak,
@@ -2677,13 +2702,13 @@ win_line (
       cur = cur->next;
   }
 
-  off = (unsigned)(current_ScreenLine - ScreenLines);
+  unsigned off = 0;  // Offset relative start of line
   int col = 0;  // Visual column on screen.
   if (wp->w_p_rl) {
     // Rightleft window: process the text in the normal direction, but put
-    // it in current_ScreenLine[] from right to left.  Start at the
+    // it in linebuf_char[off] from right to left.  Start at the
     // rightmost column of the window.
-    col = wp->w_width - 1;
+    col = grid->Columns - 1;
     off += col;
   }
 
@@ -2858,10 +2883,11 @@ win_line (
             c_extra = '-';
           else
             c_extra = fill_diff;
-          if (wp->w_p_rl)
+          if (wp->w_p_rl) {
             n_extra = col + 1;
-          else
-            n_extra = wp->w_width - col;
+          } else {
+            n_extra = grid->Columns - col;
+          }
           char_attr = win_hl_attr(wp, HLF_DED);
         }
         if (*p_sbr != NUL && need_showbreak) {
@@ -2902,14 +2928,14 @@ win_line (
          && lnum == wp->w_cursor.lnum && vcol >= (long)wp->w_virtcol
          && filler_todo <= 0)
         || (number_only && draw_state > WL_NR)) {
-      screen_line(screen_row, wp->w_wincol, col, -wp->w_width, wp->w_p_rl, wp,
-                  wp->w_hl_attr_normal, false);
+      grid_put_linebuf(grid, row, 0, col, -grid->Columns, wp->w_p_rl, wp,
+                       wp->w_hl_attr_normal, false);
       // Pretend we have finished updating the window.  Except when
       // 'cursorcolumn' is set.
       if (wp->w_p_cuc) {
         row = wp->w_cline_row + wp->w_cline_height;
       } else {
-        row = wp->w_height;
+        row = grid->Rows;
       }
       break;
     }
@@ -3130,9 +3156,8 @@ win_line (
 
           /* If a double-width char doesn't fit display a '>' in the
            * last column. */
-          if ((
-                wp->w_p_rl ? (col <= 0) :
-                (col >= wp->w_width - 1))
+          if ((wp->w_p_rl ? (col <= 0) :
+               (col >= grid->Columns - 1))
               && (*mb_char2cells)(mb_c) == 2) {
             c = '>';
             mb_c = c;
@@ -3272,9 +3297,8 @@ win_line (
         /* If a double-width char doesn't fit display a '>' in the
          * last column; the character is displayed at the start of the
          * next line. */
-        if ((
-              wp->w_p_rl ? (col <= 0) :
-              (col >= wp->w_width - 1))
+        if ((wp->w_p_rl ? (col <= 0) :
+             (col >= grid->Columns - 1))
             && (*mb_char2cells)(mb_c) == 2) {
           c = '>';
           mb_c = c;
@@ -3448,7 +3472,7 @@ win_line (
           char_u *p = ptr - (mb_off + 1);
           // TODO: is passing p for start of the line OK?
           n_extra = win_lbr_chartabsize(wp, line, p, (colnr_T)vcol, NULL) - 1;
-          if (c == TAB && n_extra + col > wp->w_width) {
+          if (c == TAB && n_extra + col > grid->Columns) {
             n_extra = (int)wp->w_buffer->b_p_ts
                       - vcol % (int)wp->w_buffer->b_p_ts - 1;
           }
@@ -3504,8 +3528,7 @@ win_line (
        */
       if (!vim_isprintc(c)) {
         // when getting a character from the file, we may have to
-        // turn it into something else on the way to putting it
-        // into "ScreenLines".
+        // turn it into something else on the way to putting it on the screen.
         if (c == TAB && (!wp->w_p_list || lcs_tab1)) {
           int tab_len = 0;
           long vcol_adjusted = vcol;  // removed showbreak length
@@ -3605,9 +3628,7 @@ win_line (
                        || ((fromcol >= 0 || fromcol_prev >= 0)
                            && tocol > vcol
                            && VIsual_mode != Ctrl_V
-                           && (
-                             wp->w_p_rl ? (col >= 0) :
-                             (col < wp->w_width))
+                           && (wp->w_p_rl ? (col >= 0) : (col < grid->Columns))
                            && !(noinvcur
                                 && lnum == wp->w_cursor.lnum
                                 && (colnr_T)vcol == wp->w_virtcol)))
@@ -3672,14 +3693,11 @@ win_line (
           saved_attr2 = char_attr;  // save current attr
           mb_utf8 = false;   // don't draw as UTF-8
         } else if (VIsual_active
-                   && (VIsual_mode == Ctrl_V
-                       || VIsual_mode == 'v')
+                   && (VIsual_mode == Ctrl_V || VIsual_mode == 'v')
                    && virtual_active()
                    && tocol != MAXCOL
                    && vcol < tocol
-                   && (
-                     wp->w_p_rl ? (col >= 0) :
-                     (col < wp->w_width))) {
+                   && (wp->w_p_rl ? (col >= 0) : (col < grid->Columns))) {
           c = ' ';
           ptr--;  // put it back at the NUL
         }
@@ -3749,7 +3767,7 @@ win_line (
         && conceal_cursor_line(wp)
         && (int)wp->w_virtcol <= vcol + n_skip) {
       if (wp->w_p_rl) {
-        wp->w_wcol = wp->w_width - col + boguscols - 1;
+        wp->w_wcol = grid->Columns - col + boguscols - 1;
       } else {
         wp->w_wcol = col - boguscols;
       }
@@ -3837,8 +3855,9 @@ win_line (
           if (col < 0)
             n = 1;
         } else {
-          if (col >= wp->w_width)
+          if (col >= grid->Columns) {
             n = -1;
+          }
         }
         if (n != 0) {
           /* At the window boundary, highlight the last character
@@ -3847,7 +3866,7 @@ win_line (
           col += n;
         } else {
           // Add a blank character to highlight.
-          schar_from_ascii(ScreenLines[off], ' ');
+          schar_from_ascii(linebuf_char[off], ' ');
         }
         if (area_attr == 0) {
           /* Use attributes from match with highest priority among
@@ -3878,7 +3897,7 @@ win_line (
         if (wp->w_p_cul && lnum == wp->w_cursor.lnum) {
           eol_attr = hl_combine_attr(win_hl_attr(wp, HLF_CUL), eol_attr);
         }
-        ScreenAttrs[off] = eol_attr;
+        linebuf_attr[off] = eol_attr;
         if (wp->w_p_rl) {
           --col;
           --off;
@@ -3910,7 +3929,7 @@ win_line (
       if (((wp->w_p_cuc
             && (int)wp->w_virtcol >= VCOL_HLC - eol_hl_off
             && (int)wp->w_virtcol <
-            wp->w_width * (row - startrow + 1) + v
+            grid->Columns * (row - startrow + 1) + v
             && lnum != wp->w_cursor.lnum)
            || draw_color_col || line_attr_lowprio || line_attr
            || diff_hlf != (hlf_T)0 || do_virttext)) {
@@ -3958,7 +3977,7 @@ win_line (
 
         int col_stride = wp->w_p_rl ? -1 : 1;
 
-        while (wp->w_p_rl ? col >= 0 : col < wp->w_width) {
+        while (wp->w_p_rl ? col >= 0 : col < grid->Columns) {
           int cells = -1;
           if (do_virttext && !delay_virttext) {
             if (*s.p == NUL) {
@@ -3972,14 +3991,14 @@ win_line (
               }
             }
             if (*s.p != NUL) {
-              cells = line_putchar(&s, &ScreenLines[off], wp->w_width - col,
+              cells = line_putchar(&s, &linebuf_char[off], grid->Columns - col,
                                    false);
             }
           }
           delay_virttext = false;
 
           if (cells == -1) {
-            schar_from_ascii(ScreenLines[off], ' ');
+            schar_from_ascii(linebuf_char[off], ' ');
             cells = 1;
           }
           col += cells * col_stride;
@@ -4001,9 +4020,9 @@ win_line (
 
           attr = hl_combine_attr(attr, line_attr);
 
-          ScreenAttrs[off] = attr;
+          linebuf_attr[off] = attr;
           if (cells == 2) {
-            ScreenAttrs[off+1] = attr;
+            linebuf_attr[off+1] = attr;
           }
           off += cells * col_stride;
 
@@ -4020,14 +4039,14 @@ win_line (
       if (wp->w_buffer->terminal) {
         // terminal buffers may need to highlight beyond the end of the
         // logical line
-        while (col < wp->w_width) {
-          schar_from_ascii(ScreenLines[off], ' ');
-          ScreenAttrs[off++] = term_attrs[vcol++];
+        while (col < grid->Columns) {
+          schar_from_ascii(linebuf_char[off], ' ');
+          linebuf_attr[off++] = term_attrs[vcol++];
           col++;
         }
       }
-      screen_line(screen_row, wp->w_wincol, col, wp->w_width, wp->w_p_rl, wp,
-                  wp->w_hl_attr_normal, false);
+      grid_put_linebuf(grid, row, 0, col, grid->Columns, wp->w_p_rl, wp,
+                       wp->w_hl_attr_normal, false);
       row++;
 
       /*
@@ -4048,9 +4067,7 @@ win_line (
     if (lcs_ext
         && !wp->w_p_wrap
         && filler_todo <= 0
-        && (
-          wp->w_p_rl ? col == 0 :
-          col == wp->w_width - 1)
+        && (wp->w_p_rl ? col == 0 : col == grid->Columns - 1)
         && (*ptr != NUL
             || (wp->w_p_list && lcs_eol_one > 0)
             || (n_extra && (c_extra != NUL || *p_extra != NUL)))) {
@@ -4107,22 +4124,23 @@ win_line (
         --col;
       }
       if (mb_utf8) {
-        schar_from_cc(ScreenLines[off], mb_c, u8cc);
+        schar_from_cc(linebuf_char[off], mb_c, u8cc);
       } else {
-        schar_from_ascii(ScreenLines[off], c);
+        schar_from_ascii(linebuf_char[off], c);
       }
       if (multi_attr) {
-        ScreenAttrs[off] = multi_attr;
+        linebuf_attr[off] = multi_attr;
         multi_attr = 0;
-      } else
-        ScreenAttrs[off] = char_attr;
+      } else {
+        linebuf_attr[off] = char_attr;
+      }
 
       if (has_mbyte && (*mb_char2cells)(mb_c) > 1) {
         // Need to fill two screen columns.
         off++;
         col++;
         // UTF-8: Put a 0 in the second screen char.
-        ScreenLines[off][0] = 0;
+        linebuf_char[off][0] = 0;
         if (draw_state > WL_NR && filler_todo <= 0) {
           vcol++;
         }
@@ -4228,33 +4246,40 @@ win_line (
      * At end of screen line and there is more to come: Display the line
      * so far.  If there is no more to display it is caught above.
      */
-    if ((
-          wp->w_p_rl ? (col < 0) :
-          (col >= wp->w_width))
+    if ((wp->w_p_rl ? (col < 0) : (col >= grid->Columns))
         && (*ptr != NUL
             || filler_todo > 0
             || (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str)
             || (n_extra != 0 && (c_extra != NUL || *p_extra != NUL)))
         ) {
-      bool wrap = wp->w_p_wrap     // Wrapping enabled.
-        && filler_todo <= 0        // Not drawing diff filler lines.
-        && lcs_eol_one != -1       // Haven't printed the lcs_eol character.
-        && row != endrow - 1       // Not the last line being displayed.
-        && wp->w_width == Columns  // Window spans the width of the screen.
-        && !wp->w_p_rl;            // Not right-to-left.
-      screen_line(screen_row, wp->w_wincol, col - boguscols,
-                  wp->w_width, wp->w_p_rl, wp, wp->w_hl_attr_normal, wrap);
+      bool wrap = wp->w_p_wrap       // Wrapping enabled.
+        && filler_todo <= 0          // Not drawing diff filler lines.
+        && lcs_eol_one != -1         // Haven't printed the lcs_eol character.
+        && row != endrow - 1         // Not the last line being displayed.
+        && grid->Columns == Columns  // Window spans the width of the screen.
+        && !wp->w_p_rl;              // Not right-to-left.
+      grid_put_linebuf(grid, row, 0, col - boguscols, grid->Columns, wp->w_p_rl,
+                       wp, wp->w_hl_attr_normal, wrap);
       if (wrap) {
+        ScreenGrid *current_grid = grid;
+        int current_row = row;
+
+        // if we're not in ext_multigrid mode, grid has not been allocated; keep
+        // working on the default_grid.
+        if (!ui_is_external(kUIMultigrid)) {
+          current_row += grid->row_offset;
+          current_grid = &default_grid;
+        }
+
         // Force a redraw of the first column of the next line.
-        ScreenAttrs[LineOffset[screen_row + 1]] = -1;
+        current_grid->attrs[current_grid->line_offset[current_row+1]] = -1;
 
         // Remember that the line wraps, used for modeless copy.
-        LineWraps[screen_row] = true;
+        current_grid->line_wraps[current_row] = true;
       }
 
       boguscols = 0;
-      ++row;
-      ++screen_row;
+      row++;
 
       /* When not wrapping and finished diff lines, or when displayed
        * '$' and highlighting until last column, break here. */
@@ -4267,7 +4292,7 @@ win_line (
       if (draw_state != WL_LINE
           && filler_todo <= 0
           ) {
-        win_draw_end(wp, '@', ' ', row, wp->w_height, HLF_AT);
+        win_draw_end(wp, '@', ' ', row, wp->w_grid.Rows, HLF_AT);
         row = endrow;
       }
 
@@ -4278,9 +4303,9 @@ win_line (
       }
 
       col = 0;
-      off = (unsigned)(current_ScreenLine - ScreenLines);
+      off = 0;
       if (wp->w_p_rl) {
-        col = wp->w_width - 1;          /* col is not used if breaking! */
+        col = grid->Columns - 1;  // col is not used if breaking!
         off += col;
       }
 
@@ -4321,32 +4346,32 @@ win_line (
  * - the character is multi-byte and the next byte is different
  * - the character is two cells wide and the second cell differs.
  */
-static int char_needs_redraw(int off_from, int off_to, int cols)
+static int grid_char_needs_redraw(ScreenGrid *grid, int off_from, int off_to,
+                                  int cols)
 {
   return (cols > 0
-          && ((schar_cmp(ScreenLines[off_from], ScreenLines[off_to])
-               || ScreenAttrs[off_from] != ScreenAttrs[off_to]
-               || (utf_off2cells(off_from, off_from + cols) > 1
-                   && schar_cmp(ScreenLines[off_from + 1],
-                                ScreenLines[off_to + 1])))
+          && ((schar_cmp(linebuf_char[off_from], grid->chars[off_to])
+               || linebuf_attr[off_from] != grid->attrs[off_to]
+               || (line_off2cells(linebuf_char, off_from, off_from + cols) > 1
+                   && schar_cmp(linebuf_char[off_from + 1],
+                                grid->chars[off_to + 1])))
               || p_wd < 0));
 }
 
-/*
- * Move one "cooked" screen line to the screen, but only the characters that
- * have actually changed.  Handle insert/delete character.
- * "coloff" gives the first column on the screen for this line.
- * "endcol" gives the columns where valid characters are.
- * "clear_width" is the width of the window.  It's > 0 if the rest of the line
- * needs to be cleared, negative otherwise.
- * "rlflag" is TRUE in a rightleft window:
- *    When TRUE and "clear_width" > 0, clear columns 0 to "endcol"
- *    When FALSE and "clear_width" > 0, clear columns "endcol" to "clear_width"
- * If "wrap" is true, then hint to the UI that "row" contains a line
- * which has wrapped into the next row.
- */
-static void screen_line(int row, int coloff, int endcol, int clear_width,
-                        int rlflag, win_T *wp, int bg_attr, bool wrap)
+/// Move one buffered line to the window grid, but only the characters that
+/// have actually changed.  Handle insert/delete character.
+/// "coloff" gives the first column on the grid for this line.
+/// "endcol" gives the columns where valid characters are.
+/// "clear_width" is the width of the window.  It's > 0 if the rest of the line
+/// needs to be cleared, negative otherwise.
+/// "rlflag" is TRUE in a rightleft window:
+///    When TRUE and "clear_width" > 0, clear columns 0 to "endcol"
+///    When FALSE and "clear_width" > 0, clear columns "endcol" to "clear_width"
+/// If "wrap" is true, then hint to the UI that "row" contains a line
+/// which has wrapped into the next row.
+static void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int endcol,
+                             int clear_width, int rlflag, win_T *wp,
+                             int bg_attr, bool wrap)
 {
   unsigned off_from;
   unsigned off_to;
@@ -4360,56 +4385,65 @@ static void screen_line(int row, int coloff, int endcol, int clear_width,
                                             // 2: occupies two display cells
   int start_dirty = -1, end_dirty = 0;
 
-  /* Check for illegal row and col, just in case. */
-  if (row >= Rows)
-    row = Rows - 1;
-  if (endcol > Columns)
-    endcol = Columns;
+  // Check for illegal row and col, just in case
+  if (row >= grid->Rows) {
+    row = grid->Rows - 1;
+  }
+  if (endcol > grid->Columns) {
+    endcol = grid->Columns;
+  }
+
+  // If UI is not externalized, merge the contents of global and window grids
+  if (!ui_is_external(kUIMultigrid) && grid != &default_grid) {
+    row += grid->row_offset;
+    coloff += grid->col_offset;
+    grid = &default_grid;
+  }
 
-  off_from = (unsigned)(current_ScreenLine - ScreenLines);
-  off_to = LineOffset[row] + coloff;
-  max_off_from = off_from + screen_Columns;
-  max_off_to = LineOffset[row] + screen_Columns;
+  off_from = 0;
+  off_to = grid->line_offset[row] + coloff;
+  max_off_from = linebuf_size;
+  max_off_to = grid->line_offset[row] + grid->Columns;
 
   if (rlflag) {
     /* Clear rest first, because it's left of the text. */
     if (clear_width > 0) {
-      while (col <= endcol && ScreenLines[off_to][0] == ' '
-             && ScreenLines[off_to][1] == NUL
-             && ScreenAttrs[off_to] == bg_attr
+      while (col <= endcol && grid->chars[off_to][0] == ' '
+             && grid->chars[off_to][1] == NUL
+             && grid->attrs[off_to] == bg_attr
              ) {
         ++off_to;
         ++col;
       }
       if (col <= endcol) {
-        screen_fill(row, row + 1, col + coloff, endcol + coloff + 1, ' ', ' ',
-                    bg_attr);
+        grid_fill(grid, row, row + 1, col + coloff, endcol + coloff + 1,
+                  ' ', ' ', bg_attr);
       }
     }
     col = endcol + 1;
-    off_to = LineOffset[row] + col + coloff;
+    off_to = grid->line_offset[row] + col + coloff;
     off_from += col;
     endcol = (clear_width > 0 ? clear_width : -clear_width);
   }
 
   if (bg_attr) {
     for (int c = col; c < endcol; c++) {
-      ScreenAttrs[off_from+c] = hl_combine_attr(bg_attr,
-                                                ScreenAttrs[off_from+c]);
+      linebuf_attr[off_from+c] =
+        hl_combine_attr(bg_attr, linebuf_attr[off_from+c]);
     }
   }
 
-  redraw_next = char_needs_redraw(off_from, off_to, endcol - col);
+  redraw_next = grid_char_needs_redraw(grid, off_from, off_to, endcol - col);
 
   while (col < endcol) {
     char_cells = 1;
     if (col + 1 < endcol) {
-      char_cells = utf_off2cells(off_from, max_off_from);
+      char_cells = line_off2cells(linebuf_char, off_from, max_off_from);
     }
     redraw_this = redraw_next;
-    redraw_next = char_needs_redraw(off_from + char_cells,
-                                    off_to + char_cells,
-                                    endcol - col - char_cells);
+    redraw_next = grid_char_needs_redraw(grid, off_from + char_cells,
+                                         off_to + char_cells,
+                                         endcol - col - char_cells);
 
     if (redraw_this) {
       if (start_dirty == -1) {
@@ -4423,23 +4457,23 @@ static void screen_line(int row, int coloff, int endcol, int clear_width,
       // char over the left halve of an existing one
       if (col + char_cells == endcol
           && ((char_cells == 1
-               && utf_off2cells(off_to, max_off_to) > 1)
+               && grid_off2cells(grid, off_to, max_off_to) > 1)
               || (char_cells == 2
-                  && utf_off2cells(off_to, max_off_to) == 1
-                  && utf_off2cells(off_to + 1, max_off_to) > 1))) {
+                  && grid_off2cells(grid, off_to, max_off_to) == 1
+                  && grid_off2cells(grid, off_to + 1, max_off_to) > 1))) {
         clear_next = true;
       }
 
-      schar_copy(ScreenLines[off_to], ScreenLines[off_from]);
+      schar_copy(grid->chars[off_to], linebuf_char[off_from]);
       if (char_cells == 2) {
-        schar_copy(ScreenLines[off_to+1], ScreenLines[off_from+1]);
+        schar_copy(grid->chars[off_to+1], linebuf_char[off_from+1]);
       }
 
-      ScreenAttrs[off_to] = ScreenAttrs[off_from];
+      grid->attrs[off_to] = linebuf_attr[off_from];
       // For simplicity set the attributes of second half of a
       // double-wide character equal to the first half.
       if (char_cells == 2) {
-        ScreenAttrs[off_to + 1] = ScreenAttrs[off_from];
+        grid->attrs[off_to + 1] = linebuf_attr[off_from];
       }
     }
 
@@ -4451,7 +4485,7 @@ static void screen_line(int row, int coloff, int endcol, int clear_width,
   if (clear_next) {
     /* Clear the second half of a double-wide character of which the left
      * half was overwritten with a single-wide character. */
-    schar_from_ascii(ScreenLines[off_to], ' ');
+    schar_from_ascii(grid->chars[off_to], ' ');
     end_dirty++;
   }
 
@@ -4460,28 +4494,29 @@ static void screen_line(int row, int coloff, int endcol, int clear_width,
     // blank out the rest of the line
     // TODO(bfredl): we could cache winline widths
     while (col < clear_width) {
-        if (ScreenLines[off_to][0] != ' ' || ScreenLines[off_to][1] != NUL
-            || ScreenAttrs[off_to] != bg_attr) {
-            ScreenLines[off_to][0] = ' ';
-            ScreenLines[off_to][1] = NUL;
-            ScreenAttrs[off_to] = bg_attr;
-            if (start_dirty == -1) {
-              start_dirty = col;
-              end_dirty = col;
-            } else if (clear_end == -1) {
-              end_dirty = endcol;
-            }
-            clear_end = col+1;
+      if (grid->chars[off_to][0] != ' '
+          || grid->chars[off_to][1] != NUL
+          || grid->attrs[off_to] != bg_attr) {
+        grid->chars[off_to][0] = ' ';
+        grid->chars[off_to][1] = NUL;
+        grid->attrs[off_to] = bg_attr;
+        if (start_dirty == -1) {
+          start_dirty = col;
+          end_dirty = col;
+        } else if (clear_end == -1) {
+          end_dirty = endcol;
         }
-        col++;
-        off_to++;
+        clear_end = col+1;
+      }
+      col++;
+      off_to++;
     }
   }
 
-  if (clear_width > 0 || wp->w_width != Columns) {
+  if (clear_width > 0 || wp->w_width != grid->Columns) {
     // If we cleared after the end of the line, it did not wrap.
     // For vsplit, line wrapping is not possible.
-    LineWraps[row] = false;
+    grid->line_wraps[row] = false;
   }
 
   if (clear_end < end_dirty) {
@@ -4491,7 +4526,7 @@ static void screen_line(int row, int coloff, int endcol, int clear_width,
     start_dirty = end_dirty;
   }
   if (clear_end > start_dirty) {
-    ui_line(row, coloff+start_dirty, coloff+end_dirty, coloff+clear_end,
+    ui_line(grid, row, coloff+start_dirty, coloff+end_dirty, coloff+clear_end,
             bg_attr, wrap);
   }
 }
@@ -4586,9 +4621,8 @@ static void draw_vsep_win(win_T *wp, int row)
   if (wp->w_vsep_width) {
     // draw the vertical separator right of this window
     c = fillchar_vsep(wp, &hl);
-    screen_fill(wp->w_winrow + row, wp->w_winrow + wp->w_height,
-        W_ENDCOL(wp), W_ENDCOL(wp) + 1,
-        c, ' ', hl);
+    grid_fill(&default_grid, wp->w_winrow + row, W_ENDROW(wp),
+              W_ENDCOL(wp), W_ENDCOL(wp) + 1, c, ' ', hl);
   }
 }
 
@@ -4673,7 +4707,8 @@ win_redr_status_matches (
   if (matches == NULL)          /* interrupted completion? */
     return;
 
-  buf = xmalloc(has_mbyte ? Columns * MB_MAXBYTES + 1 : Columns + 1);
+  buf = xmalloc(has_mbyte ? default_grid.Columns * MB_MAXBYTES + 1
+                : default_grid.Columns + 1);
 
   if (match == -1) {    /* don't show match but original text */
     match = 0;
@@ -4693,15 +4728,16 @@ win_redr_status_matches (
       clen += status_match_len(xp, L_MATCH(i)) + 2;
     if (first_match > 0)
       clen += 2;
-    /* jumping right, put match at the left */
-    if ((long)clen > Columns) {
+    // jumping right, put match at the left
+    if ((long)clen > default_grid.Columns) {
       first_match = match;
       /* if showing the last match, we can add some on the left */
       clen = 2;
       for (i = match; i < num_matches; ++i) {
         clen += status_match_len(xp, L_MATCH(i)) + 2;
-        if ((long)clen >= Columns)
+        if ((long)clen >= default_grid.Columns) {
           break;
+        }
       }
       if (i == num_matches)
         add_left = TRUE;
@@ -4710,9 +4746,10 @@ win_redr_status_matches (
   if (add_left)
     while (first_match > 0) {
       clen += status_match_len(xp, L_MATCH(first_match - 1)) + 2;
-      if ((long)clen >= Columns)
+      if ((long)clen >= default_grid.Columns) {
         break;
-      --first_match;
+      }
+      first_match--;
     }
 
   fillchar = fillchar_status(&attr, curwin);
@@ -4727,7 +4764,8 @@ win_redr_status_matches (
   clen = len;
 
   i = first_match;
-  while ((long)(clen + status_match_len(xp, L_MATCH(i)) + 2) < Columns) {
+  while ((long)(clen + status_match_len(xp, L_MATCH(i)) + 2)
+         < default_grid.Columns) {
     if (i == match) {
       selstart = buf + len;
       selstart_col = clen;
@@ -4778,8 +4816,8 @@ win_redr_status_matches (
       if (msg_scrolled > 0) {
         /* Put the wildmenu just above the command line.  If there is
          * no room, scroll the screen one line up. */
-        if (cmdline_row == Rows - 1) {
-          screen_del_lines(0, 1, (int)Rows, 0, (int)Columns);
+        if (cmdline_row == default_grid.Rows - 1) {
+          grid_del_lines(&default_grid, 0, 1, (int)Rows, 0, (int)Columns);
           msg_scrolled++;
         } else {
           cmdline_row++;
@@ -4801,13 +4839,14 @@ win_redr_status_matches (
       }
     }
 
-    screen_puts(buf, row, 0, attr);
+    grid_puts(&default_grid, buf, row, 0, attr);
     if (selstart != NULL && highlight) {
       *selend = NUL;
-      screen_puts(selstart, row, selstart_col, HL_ATTR(HLF_WM));
+      grid_puts(&default_grid, selstart, row, selstart_col, HL_ATTR(HLF_WM));
     }
 
-    screen_fill(row, row + 1, clen, (int)Columns, fillchar, fillchar, attr);
+    grid_fill(&default_grid, row, row + 1, clen, (int)default_grid.Columns,
+              fillchar, fillchar, attr);
   }
 
   win_redraw_last_status(topframe);
@@ -4905,15 +4944,15 @@ static void win_redr_status(win_T *wp, int ignore_pum)
       }
     }
 
-    row = wp->w_winrow + wp->w_height;
-    screen_puts(p, row, wp->w_wincol, attr);
-    screen_fill(row, row + 1, len + wp->w_wincol,
-        this_ru_col + wp->w_wincol, fillchar, fillchar, attr);
+    row = W_ENDROW(wp);
+    grid_puts(&default_grid, p, row, wp->w_wincol, attr);
+    grid_fill(&default_grid, row, row + 1, len + wp->w_wincol,
+              this_ru_col + wp->w_wincol, fillchar, fillchar, attr);
 
     if (get_keymap_str(wp, (char_u *)"<%s>", NameBuff, MAXPATHL)
         && this_ru_col - len > (int)(STRLEN(NameBuff) + 1))
-      screen_puts(NameBuff, row, (int)(this_ru_col - STRLEN(NameBuff)
-                                       - 1 + wp->w_wincol), attr);
+      grid_puts(&default_grid, NameBuff, row,
+                (int)(this_ru_col - STRLEN(NameBuff) - 1), attr);
 
     win_redr_ruler(wp, TRUE);
   }
@@ -4927,8 +4966,7 @@ static void win_redr_status(win_T *wp, int ignore_pum)
     } else {
       fillchar = fillchar_vsep(wp, &attr);
     }
-    screen_putchar(fillchar, wp->w_winrow + wp->w_height,
-                   W_ENDCOL(wp), attr);
+    grid_putchar(&default_grid, fillchar, W_ENDROW(wp), W_ENDCOL(wp), attr);
   }
   busy = FALSE;
 }
@@ -5072,10 +5110,10 @@ win_redr_custom (
     row = 0;
     fillchar = ' ';
     attr = HL_ATTR(HLF_TPF);
-    maxwidth = Columns;
+    maxwidth = default_grid.Columns;
     use_sandbox = was_set_insecurely((char_u *)"tabline", 0);
   } else {
-    row = wp->w_winrow + wp->w_height;
+    row = W_ENDROW(wp);
     fillchar = fillchar_status(&attr, wp);
     maxwidth = wp->w_width;
 
@@ -5091,13 +5129,14 @@ win_redr_custom (
         if (*stl++ != '(')
           stl = p_ruf;
       }
-      col = ru_col - (Columns - wp->w_width);
-      if (col < (wp->w_width + 1) / 2)
+      col = ru_col - (default_grid.Columns - wp->w_width);
+      if (col < (wp->w_width + 1) / 2) {
         col = (wp->w_width + 1) / 2;
+      }
       maxwidth = wp->w_width - col;
       if (!wp->w_status_height) {
-        row = Rows - 1;
-        --maxwidth;             /* writing in last column may cause scrolling */
+        row = default_grid.Rows - 1;
+        maxwidth--;  // writing in last column may cause scrolling
         fillchar = ' ';
         attr = 0;
       }
@@ -5155,7 +5194,7 @@ win_redr_custom (
   p = buf;
   for (n = 0; hltab[n].start != NULL; n++) {
     int len = (int)(hltab[n].start - p);
-    screen_puts_len(p, len, row, col, curattr);
+    grid_puts_len(&default_grid, p, len, row, col, curattr);
     col += vim_strnsize(p, len);
     p = hltab[n].start;
 
@@ -5169,9 +5208,10 @@ win_redr_custom (
       curattr = highlight_user[hltab[n].userhl - 1];
   }
   // Make sure to use an empty string instead of p, if p is beyond buf + len.
-  screen_puts(p >= buf + len ? (char_u *)"" : p, row, col, curattr);
+  grid_puts(&default_grid, p >= buf + len ? (char_u *)"" : p, row, col,
+            curattr);
 
-  screen_puts_line_flush(false);
+  grid_puts_line_flush(&default_grid, false);
 
   if (wp == NULL) {
     // Fill the tab_page_click_defs array for clicking in the tab pages line.
@@ -5189,7 +5229,7 @@ win_redr_custom (
       p = (char_u *) tabtab[n].start;
       cur_click_def = tabtab[n].def;
     }
-    while (col < Columns) {
+    while (col < default_grid.Columns) {
       tab_page_click_defs[col++] = cur_click_def;
     }
   }
@@ -5242,43 +5282,91 @@ static void schar_copy(char_u *sc1, char_u *sc2)
   STRLCPY(sc1, sc2, sizeof(schar_T));
 }
 
+static int line_off2cells(schar_T *line, size_t off, size_t max_off)
+{
+  return (off + 1 < max_off && line[off + 1][0] == 0) ? 2 : 1;
+}
 
-/*
- * Output a single character directly to the screen and update ScreenLines.
- */
-void screen_putchar(int c, int row, int col, int attr)
+/// Return number of display cells for char at grid->chars[off].
+/// We make sure that the offset used is less than "max_off".
+static int grid_off2cells(ScreenGrid *grid, size_t off, size_t max_off)
+{
+  return line_off2cells(grid->chars, off, max_off);
+}
+
+/// Return true if the character at "row"/"col" on the screen is the left side
+/// of a double-width character.
+///
+/// Caller must make sure "row" and "col" are not invalid!
+bool grid_lefthalve(ScreenGrid *grid, int row, int col)
+{
+  if (!ui_is_external(kUIMultigrid)) {
+    row += grid->row_offset;
+    col += grid->col_offset;
+    grid = &default_grid;
+  }
+
+  return grid_off2cells(grid, grid->line_offset[row] + col,
+                        grid->line_offset[row] + grid->Columns) > 1;
+}
+
+/// Correct a position on the screen, if it's the right half of a double-wide
+/// char move it to the left half.  Returns the corrected column.
+int grid_fix_col(ScreenGrid *grid, int col, int row)
+{
+  int coloff = 0;
+  if (!ui_is_external(kUIMultigrid)) {
+    row += grid->row_offset;
+    coloff = grid->col_offset;
+    grid = &default_grid;
+  }
+
+  col += coloff;
+  if (grid->chars != NULL && col > 0
+      && grid->chars[grid->line_offset[row] + col][0] == 0) {
+    return col - 1 - coloff;
+  }
+  return col - coloff;
+}
+
+/// output a single character directly to the grid
+void grid_putchar(ScreenGrid *grid, int c, int row, int col, int attr)
 {
   char_u buf[MB_MAXBYTES + 1];
 
   buf[utf_char2bytes(c, buf)] = NUL;
-  screen_puts(buf, row, col, attr);
+  grid_puts(grid, buf, row, col, attr);
 }
 
-/*
- * Get a single character directly from ScreenLines into "bytes[]".
- * Also return its attribute in *attrp;
- */
-void screen_getbytes(int row, int col, char_u *bytes, int *attrp)
+/// get a single character directly from grid.chars into "bytes[]".
+/// Also return its attribute in *attrp;
+void grid_getbytes(ScreenGrid *grid, int row, int col, char_u *bytes,
+                   int *attrp)
 {
   unsigned off;
 
-  /* safety check */
-  if (ScreenLines != NULL && row < screen_Rows && col < screen_Columns) {
-    off = LineOffset[row] + col;
-    *attrp = ScreenAttrs[off];
-    schar_copy(bytes, ScreenLines[off]);
+  if (!ui_is_external(kUIMultigrid)) {
+    row += grid->row_offset;
+    col += grid->col_offset;
+    grid = &default_grid;
+  }
+
+  // safety check
+  if (grid->chars != NULL && row < grid->Rows && col < grid->Columns) {
+    off = grid->line_offset[row] + col;
+    *attrp = grid->attrs[off];
+    schar_copy(bytes, grid->chars[off]);
   }
 }
 
-/*
- * Put string '*text' on the screen at position 'row' and 'col', with
- * attributes 'attr', and update ScreenLines[] and ScreenAttrs[].
- * Note: only outputs within one row, message is truncated at screen boundary!
- * Note: if ScreenLines[], row and/or col is invalid, nothing is done.
- */
-void screen_puts(char_u *text, int row, int col, int attr)
+
+/// put string '*text' on the window grid at position 'row' and 'col', with
+/// attributes 'attr', and update chars[] and attrs[].
+/// Note: only outputs within one row, message is truncated at grid boundary!
+/// Note: if grid, row and/or col is invalid, nothing is done.
+void grid_puts(ScreenGrid *grid, char_u *text, int row, int col, int attr)
 {
-  screen_puts_len(text, -1, row, col, attr);
+  grid_puts_len(grid, text, -1, row, col, attr);
 }
 
 static int put_dirty_row = -1;
@@ -5295,11 +5383,10 @@ void screen_puts_line_start(int row)
   put_dirty_row = row;
 }
 
-/*
- * Like screen_puts(), but output "text[len]".  When "len" is -1 output up to
- * a NUL.
- */
-void screen_puts_len(char_u *text, int textlen, int row, int col, int attr)
+/// like grid_puts(), but output "text[len]".  When "len" is -1 output up to
+/// a NUL.
+void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row,
+                   int col, int attr)
 {
   unsigned off;
   char_u      *ptr = text;
@@ -5317,8 +5404,20 @@ void screen_puts_len(char_u *text, int textlen, int row, int col, int attr)
   int force_redraw_this;
   int force_redraw_next = FALSE;
   int need_redraw;
-
   bool do_flush = false;
+
+  // If UI is not externalized, keep working on the default grid
+  if (!ui_is_external(kUIMultigrid) && grid != &default_grid) {
+    row += grid->row_offset;
+    col += grid->col_offset;
+    grid = &default_grid;
+  }
+
+  // safety check
+  if (grid->chars == NULL || row >= grid->Rows || col >= grid->Columns) {
+    return;
+  }
+
   if (put_dirty_row == -1) {
     screen_puts_line_start(row);
     do_flush = true;
@@ -5327,16 +5426,13 @@ void screen_puts_len(char_u *text, int textlen, int row, int col, int attr)
       abort();
     }
   }
-
-  if (ScreenLines == NULL || row >= screen_Rows)        /* safety check */
-    return;
-  off = LineOffset[row] + col;
+  off = grid->line_offset[row] + col;
 
   /* When drawing over the right halve of a double-wide char clear out the
    * left halve.  Only needed in a terminal. */
-  if (col > 0 && col < screen_Columns && mb_fix_col(col, row) != col) {
-    schar_from_ascii(ScreenLines[off - 1], ' ');
-    ScreenAttrs[off - 1] = 0;
+  if (col > 0 && col < grid->Columns && grid_fix_col(grid, col, row) != col) {
+    schar_from_ascii(grid->chars[off - 1], ' ');
+    grid->attrs[off - 1] = 0;
     // redraw the previous cell, make it empty
     if (put_dirty_first == -1) {
       put_dirty_first = col-1;
@@ -5346,8 +5442,8 @@ void screen_puts_len(char_u *text, int textlen, int row, int col, int attr)
     force_redraw_next = true;
   }
 
-  max_off = LineOffset[row] + screen_Columns;
-  while (col < screen_Columns
+  max_off = grid->line_offset[row] + grid->Columns;
+  while (col < grid->Columns
          && (len < 0 || (int)(ptr - text) < len)
          && *ptr != NUL) {
     c = *ptr;
@@ -5380,7 +5476,7 @@ void screen_puts_len(char_u *text, int textlen, int row, int col, int attr)
     } else {
       prev_c = u8c;
     }
-    if (col + mbyte_cells > screen_Columns) {
+    if (col + mbyte_cells > grid->Columns) {
       // Only 1 cell left, but character requires 2 cells:
       // display a '>' in the last column to avoid wrapping. */
       c = '>';
@@ -5394,9 +5490,9 @@ void screen_puts_len(char_u *text, int textlen, int row, int col, int attr)
     force_redraw_this = force_redraw_next;
     force_redraw_next = FALSE;
 
-    need_redraw = schar_cmp(ScreenLines[off], buf)
-                  || (mbyte_cells == 2 && ScreenLines[off + 1][0] != 0)
-                  || ScreenAttrs[off] != attr
+    need_redraw = schar_cmp(grid->chars[off], buf)
+                  || (mbyte_cells == 2 && grid->chars[off + 1][0] != 0)
+                  || grid->attrs[off] != attr
                   || exmode_active;
 
     if (need_redraw || force_redraw_this) {
@@ -5409,18 +5505,19 @@ void screen_puts_len(char_u *text, int textlen, int row, int col, int attr)
         clear_next_cell = false;
       } else if ((len < 0 ? ptr[mbyte_blen] == NUL
                   : ptr + mbyte_blen >= text + len)
-                 && ((mbyte_cells == 1 && utf_off2cells(off, max_off) > 1)
+                 && ((mbyte_cells == 1
+                      && grid_off2cells(grid, off, max_off) > 1)
                      || (mbyte_cells == 2
-                         && utf_off2cells(off, max_off) == 1
-                         && utf_off2cells(off + 1, max_off) > 1))) {
+                         && grid_off2cells(grid, off, max_off) == 1
+                         && grid_off2cells(grid, off + 1, max_off) > 1))) {
         clear_next_cell = true;
       }
 
-      schar_copy(ScreenLines[off], buf);
-      ScreenAttrs[off] = attr;
+      schar_copy(grid->chars[off], buf);
+      grid->attrs[off] = attr;
       if (mbyte_cells == 2) {
-        ScreenLines[off + 1][0] = 0;
-        ScreenAttrs[off + 1] = attr;
+        grid->chars[off + 1][0] = 0;
+        grid->attrs[off + 1] = attr;
       }
       if (put_dirty_first == -1) {
         put_dirty_first = col;
@@ -5439,25 +5536,26 @@ void screen_puts_len(char_u *text, int textlen, int row, int col, int attr)
   }
 
   if (do_flush) {
-    screen_puts_line_flush(true);
+    grid_puts_line_flush(grid, true);
   }
 }
 
 /// End a group of screen_puts_len calls and send the screen buffer to the UI
 /// layer.
 ///
+/// @param grid       The grid which contains the buffer.
 /// @param set_cursor Move the visible cursor to the end of the changed region.
 ///                   This is a workaround for not yet refactored code paths
 ///                   and shouldn't be used in new code.
-void screen_puts_line_flush(bool set_cursor)
+void grid_puts_line_flush(ScreenGrid *grid, bool set_cursor)
 {
   assert(put_dirty_row != -1);
   if (put_dirty_first != -1) {
     if (set_cursor) {
-      ui_cursor_goto(put_dirty_row, put_dirty_last);
+      ui_grid_cursor_goto(grid, put_dirty_row, put_dirty_last);
     }
-    ui_line(put_dirty_row, put_dirty_first, put_dirty_last, put_dirty_last, 0,
-            false);
+    ui_line(grid, put_dirty_row, put_dirty_first, put_dirty_last,
+            put_dirty_last, 0, false);
     put_dirty_first = -1;
     put_dirty_last = 0;
   }
@@ -5760,23 +5858,35 @@ next_search_hl_pos(
 }
 
 
-/*
- * Fill the screen from 'start_row' to 'end_row', from 'start_col' to 'end_col'
- * with character 'c1' in first column followed by 'c2' in the other columns.
- * Use attributes 'attr'.
- */
-void screen_fill(int start_row, int end_row, int start_col, int end_col, int c1, int c2, int attr)
+/// Fill the grid from 'start_row' to 'end_row', from 'start_col' to 'end_col'
+/// with character 'c1' in first column followed by 'c2' in the other columns.
+/// Use attributes 'attr'.
+void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col,
+               int end_col, int c1, int c2, int attr)
 {
   schar_T sc;
 
-  if (end_row > screen_Rows)            /* safety check */
-    end_row = screen_Rows;
-  if (end_col > screen_Columns)         /* safety check */
-    end_col = screen_Columns;
-  if (ScreenLines == NULL
-      || start_row >= end_row
-      || start_col >= end_col)          /* nothing to do */
+  // if grids are not externalized, keep working on the default_grid
+  if (!ui_is_external(kUIMultigrid) && grid != &default_grid) {
+    start_row += grid->row_offset;
+    end_row += grid->row_offset;
+    start_col += grid->col_offset;
+    end_col += grid->col_offset;
+    grid = &default_grid;
+  }
+
+  // safety check
+  if (end_row > grid->Rows) {
+    end_row = grid->Rows;
+  }
+  if (end_col > grid->Columns) {
+    end_col = grid->Columns;
+  }
+
+  // nothing to do
+  if (grid->chars == NULL || start_row >= end_row || start_col >= end_col) {
     return;
+  }
 
   for (int row = start_row; row < end_row; row++) {
     if (has_mbyte) {
@@ -5784,24 +5894,30 @@ void screen_fill(int start_row, int end_row, int start_col, int end_col, int c1,
       // out the left halve.  When drawing over the left halve of a
       // double wide-char clear out the right halve.  Only needed in a
       // terminal.
-      if (start_col > 0 && mb_fix_col(start_col, row) != start_col) {
-        screen_puts_len((char_u *)" ", 1, row, start_col - 1, 0);
+      if (start_col > 0 && grid_fix_col(grid, start_col, row) != start_col) {
+        grid_puts_len(grid, (char_u *)" ", 1, row, start_col - 1, 0);
       }
-      if (end_col < screen_Columns && mb_fix_col(end_col, row) != end_col) {
-        screen_puts_len((char_u *)" ", 1, row, end_col, 0);
+      if (end_col < grid->Columns
+          && grid_fix_col(grid, end_col, row) != end_col) {
+        grid_puts_len(grid, (char_u *)" ", 1, row, end_col, 0);
       }
     }
 
+    // if grid was resized (in ext_multigrid mode), the UI has no redraw updates
+    // for the newly resized grid. It is better mark everything as dirty and
+    // send all the updates.
     int dirty_first = INT_MAX;
     int dirty_last = 0;
+
     int col = start_col;
     schar_from_char(sc, c1);
-    int lineoff = LineOffset[row];
+    int lineoff = grid->line_offset[row];
     for (col = start_col; col < end_col; col++) {
       int off = lineoff + col;
-      if (schar_cmp(ScreenLines[off], sc) || ScreenAttrs[off] != attr) {
-        schar_copy(ScreenLines[off], sc);
-        ScreenAttrs[off] = attr;
+      if (schar_cmp(grid->chars[off], sc)
+          || grid->attrs[off] != attr) {
+        schar_copy(grid->chars[off], sc);
+        grid->attrs[off] = attr;
         if (dirty_first == INT_MAX) {
           dirty_first = col;
         }
@@ -5820,16 +5936,16 @@ void screen_fill(int start_row, int end_row, int start_col, int end_col, int c1,
         put_dirty_last = MAX(put_dirty_last, dirty_last);
       } else {
         int last = c2 != ' ' ? dirty_last : dirty_first + (c1 != ' ');
-        ui_line(row, dirty_first, last, dirty_last, attr, false);
+        ui_line(grid, row, dirty_first, last, dirty_last, attr, false);
       }
     }
 
-    if (end_col == Columns) {
-      LineWraps[row] = false;
+    if (end_col == grid->Columns) {
+      grid->line_wraps[row] = false;
     }
 
     // TODO(bfredl): The relevant caller should do this
-    if (row == Rows - 1) {  // overwritten the command line
+    if (row == default_grid.Rows - 1) {  // overwritten the command line
       redraw_cmdline = true;
       if (start_col == 0 && end_col == Columns
           && c1 == ' ' && c2 == ' ' && attr == 0) {
@@ -5867,24 +5983,90 @@ void check_for_delay(int check_msg_scroll)
  */
 int screen_valid(int doclear)
 {
-  screenalloc(doclear);            /* allocate screen buffers if size changed */
-  return ScreenLines != NULL;
+  screenalloc(doclear);  // allocate screen buffers if size changed
+  return default_grid.chars != NULL;
 }
 
-/*
- * Resize the shell to Rows and Columns.
- * Allocate ScreenLines[] and associated items.
- *
- * There may be some time between setting Rows and Columns and (re)allocating
- * ScreenLines[].  This happens when starting up and when (manually) changing
- * the shell size.  Always use screen_Rows and screen_Columns to access items
- * in ScreenLines[].  Use Rows and Columns for positioning text etc. where the
- * final size of the shell is needed.
- */
+/// (Re)allocates a window grid if size changed while in ext_multigrid mode.
+/// Updates size, offsets and handle for the grid regardless.
+///
+/// If "doclear" is true, don't try to copy from the old grid rather clear the
+/// resized grid.
+void win_grid_alloc(win_T *wp)
+{
+  ScreenGrid *grid = &wp->w_grid;
+
+  int rows = grid->requested_rows;
+  if (rows == 0) {
+    rows = wp->w_height;
+  }
+
+  int columns = grid->requested_cols;
+  if (columns == 0) {
+    columns = wp->w_width;
+  }
+
+  // TODO(bfredl): floating windows should force this to true
+  bool want_allocation = ui_is_external(kUIMultigrid);
+  bool has_allocation = (grid->chars != NULL);
+
+  if (want_allocation && has_allocation && highlights_invalid) {
+    grid_invalidate(grid);
+  }
+
+  int was_resized = false;
+  if ((has_allocation != want_allocation)
+      || grid->Rows != rows
+      || grid->Columns != columns) {
+    if (want_allocation) {
+      grid_alloc(grid, rows, columns, true);
+      win_free_lsize(wp);
+      win_alloc_lines(wp);
+    } else {
+      // Single grid mode, all rendering will be redirected to default_grid.
+      // Only keep track of the size and offset of the window.
+      grid_free(grid);
+      grid->Rows = rows;
+      grid->Columns = columns;
+    }
+    was_resized = true;
+  }
+
+  grid->row_offset = wp->w_winrow;
+  grid->col_offset = wp->w_wincol;
+
+  // send grid resize event if:
+  // - a grid was just resized
+  // - screen_resize was called and all grid sizes must be sent
+  // - the UI wants multigrid event (necessary)
+  if ((send_grid_resize || was_resized) && ui_is_external(kUIMultigrid)) {
+    ui_call_grid_resize(grid->handle, grid->Columns, grid->Rows);
+  }
+}
+
+/// assign a handle to the grid. The grid need not be allocated.
+void grid_assign_handle(ScreenGrid *grid)
+{
+  static int last_grid_handle = DEFAULT_GRID_HANDLE;
+
+  // only assign a grid handle if not already
+  if (grid->handle == 0) {
+    grid->handle = ++last_grid_handle;
+  }
+}
+
+/// Resize the screen to Rows and Columns.
+///
+/// Allocate default_grid.chars[] and other grid arrays.
+///
+/// There may be some time between setting Rows and Columns and (re)allocating
+/// default_grid arrays.  This happens when starting up and when
+/// (manually) changing the shell size.  Always use default_grid.Rows and
+/// default_grid.Columns to access items in default_grid.chars[].  Use Rows
+/// and Columns for positioning text etc. where the final size of the shell is
+/// needed.
 void screenalloc(bool doclear)
 {
-  int new_row, old_row;
-  int len;
   static bool entered = false;  // avoid recursiveness
   int retry_count = 0;
 
@@ -5892,13 +6074,13 @@ retry:
   // Allocation of the screen buffers is done only when the size changes and
   // when Rows and Columns have been set and we have started doing full
   // screen stuff.
-  if ((ScreenLines != NULL
-       && Rows == screen_Rows
-       && Columns == screen_Columns
+  if ((default_grid.chars != NULL
+       && Rows == default_grid.Rows
+       && Columns == default_grid.Columns
        )
       || Rows == 0
       || Columns == 0
-      || (!full_screen && ScreenLines == NULL)) {
+      || (!full_screen && default_grid.chars == NULL)) {
     return;
   }
 
@@ -5921,30 +6103,22 @@ retry:
 
   comp_col();           /* recompute columns for shown command and ruler */
 
-  /*
-   * We're changing the size of the screen.
-   * - Allocate new arrays for ScreenLines and ScreenAttrs.
-   * - Move lines from the old arrays into the new arrays, clear extra
-   *	 lines (unless the screen is going to be cleared).
-   * - Free the old arrays.
-   *
-   * If anything fails, make ScreenLines NULL, so we don't do anything!
-   * Continuing with the old ScreenLines may result in a crash, because the
-   * size is wrong.
-   */
+  // We're changing the size of the screen.
+  // - Allocate new arrays for default_grid
+  // - Move lines from the old arrays into the new arrays, clear extra
+  //   lines (unless the screen is going to be cleared).
+  // - Free the old arrays.
+  //
+  // If anything fails, make grid arrays NULL, so we don't do anything!
+  // Continuing with the old arrays may result in a crash, because the
+  // size is wrong.
   FOR_ALL_TAB_WINDOWS(tp, wp) {
     win_free_lsize(wp);
   }
   if (aucmd_win != NULL)
     win_free_lsize(aucmd_win);
 
-  // Allocate space for an extra row as scratch space, so that a redrawn
-  // line can be compared with the previous screen line state.
-  size_t ncells = (size_t)((Rows+1) * Columns);
-  schar_T *new_ScreenLines = xmalloc(ncells * sizeof(*new_ScreenLines));
-  sattr_T *new_ScreenAttrs = xmalloc(ncells * sizeof(*new_ScreenAttrs));
-  unsigned *new_LineOffset = xmalloc((size_t)(Rows * sizeof(*new_LineOffset)));
-  char_u *new_LineWraps = xmalloc((size_t)(Rows * sizeof(*new_LineWraps)));
+  grid_alloc(&default_grid, Rows, Columns, !doclear);
   StlClickDefinition *new_tab_page_click_defs = xcalloc(
       (size_t)Columns, sizeof(*new_tab_page_click_defs));
 
@@ -5955,53 +6129,15 @@ retry:
     win_alloc_lines(aucmd_win);
   }
 
-  for (new_row = 0; new_row < Rows; new_row++) {
-    new_LineOffset[new_row] = new_row * Columns;
-    new_LineWraps[new_row] = false;
-
-    // If the screen is not going to be cleared, copy as much as
-    // possible from the old screen to the new one and clear the rest
-    // (used when resizing the window at the "--more--" prompt or when
-    // executing an external command, for the GUI).
-    if (!doclear) {
-      for (int col = 0; col < Columns; col++) {
-        schar_from_ascii(new_ScreenLines[new_row * Columns + col], ' ');
-      }
-      memset(new_ScreenAttrs + new_row * Columns,
-             0, (size_t)Columns * sizeof(*new_ScreenAttrs));
-      old_row = new_row + (screen_Rows - Rows);
-      if (old_row >= 0 && ScreenLines != NULL) {
-        if (screen_Columns < Columns) {
-          len = screen_Columns;
-        } else {
-          len = Columns;
-        }
-
-        memmove(new_ScreenLines + new_LineOffset[new_row],
-                ScreenLines + LineOffset[old_row],
-                (size_t)len * sizeof(schar_T));
-        memmove(new_ScreenAttrs + new_LineOffset[new_row],
-                ScreenAttrs + LineOffset[old_row],
-                (size_t)len * sizeof(new_ScreenAttrs[0]));
-      }
-    }
-  }
-  // Use the last line of the screen for the current line.
-  current_ScreenLine = new_ScreenLines + Rows * Columns;
-
-  free_screenlines();
+  clear_tab_page_click_defs(tab_page_click_defs, tab_page_click_defs_size);
+  xfree(tab_page_click_defs);
 
-  ScreenLines = new_ScreenLines;
-  ScreenAttrs = new_ScreenAttrs;
-  LineOffset = new_LineOffset;
-  LineWraps = new_LineWraps;
   tab_page_click_defs = new_tab_page_click_defs;
-  tab_page_click_defs_size = Columns;
+  tab_page_click_defs_size = default_grid.Columns;
 
-  /* It's important that screen_Rows and screen_Columns reflect the actual
-   * size of ScreenLines[].  Set them before calling anything. */
-  screen_Rows = Rows;
-  screen_Columns = Columns;
+  default_grid.row_offset = 0;
+  default_grid.col_offset = 0;
+  default_grid.handle = DEFAULT_GRID_HANDLE;
 
   must_redraw = CLEAR;          /* need to clear the screen later */
   if (doclear)
@@ -6023,14 +6159,75 @@ retry:
   }
 }
 
-void free_screenlines(void)
+void grid_alloc(ScreenGrid *grid, int rows, int columns, bool copy)
 {
-  xfree(ScreenLines);
-  xfree(ScreenAttrs);
-  xfree(LineOffset);
-  xfree(LineWraps);
-  clear_tab_page_click_defs(tab_page_click_defs, tab_page_click_defs_size);
-  xfree(tab_page_click_defs);
+  int new_row;
+  ScreenGrid new = *grid;
+
+  size_t ncells = (size_t)((rows+1) * columns);
+  new.chars = xmalloc(ncells * sizeof(schar_T));
+  new.attrs = xmalloc(ncells * sizeof(sattr_T));
+  new.line_offset = xmalloc((size_t)(rows * sizeof(unsigned)));
+  new.line_wraps = xmalloc((size_t)(rows * sizeof(char_u)));
+
+  new.Rows = rows;
+  new.Columns = columns;
+
+  for (new_row = 0; new_row < new.Rows; new_row++) {
+    new.line_offset[new_row] = new_row * new.Columns;
+    new.line_wraps[new_row] = false;
+
+    grid_clear_line(&new, new.line_offset[new_row], columns, true);
+
+    if (copy) {
+      // If the screen is not going to be cleared, copy as much as
+      // possible from the old screen to the new one and clear the rest
+      // (used when resizing the window at the "--more--" prompt or when
+      // executing an external command, for the GUI).
+      if (new_row < grid->Rows && grid->chars != NULL) {
+        int len = MIN(grid->Columns, new.Columns);
+        memmove(new.chars + new.line_offset[new_row],
+                grid->chars + grid->line_offset[new_row],
+                (size_t)len * sizeof(schar_T));
+        memmove(new.attrs + new.line_offset[new_row],
+                grid->attrs + grid->line_offset[new_row],
+                (size_t)len * sizeof(sattr_T));
+      }
+    }
+  }
+  grid_free(grid);
+  *grid = new;
+
+  // Share a single scratch buffer for all grids, by
+  // ensuring it is as wide as the widest grid.
+  if (linebuf_size < (size_t)columns) {
+    xfree(linebuf_char);
+    xfree(linebuf_attr);
+    linebuf_char = xmalloc(columns * sizeof(schar_T));
+    linebuf_attr = xmalloc(columns * sizeof(sattr_T));
+    linebuf_size = columns;
+  }
+}
+
+void grid_free(ScreenGrid *grid)
+{
+  xfree(grid->chars);
+  xfree(grid->attrs);
+  xfree(grid->line_offset);
+  xfree(grid->line_wraps);
+
+  grid->chars = NULL;
+  grid->attrs = NULL;
+  grid->line_offset = NULL;
+  grid->line_wraps = NULL;
+}
+
+/// Doesn't allow reinit, so must only be called by free_all_mem!
+void screen_free_all_mem(void)
+{
+  grid_free(&default_grid);
+  xfree(linebuf_char);
+  xfree(linebuf_attr);
 }
 
 /// Clear tab_page_click_defs table
@@ -6061,14 +6258,15 @@ static void screenclear2(void)
 {
   int i;
 
-  if (starting == NO_SCREEN || ScreenLines == NULL) {
+  if (starting == NO_SCREEN || default_grid.chars == NULL) {
     return;
   }
 
-  // blank out ScreenLines
-  for (i = 0; i < Rows; i++) {
-    lineclear(LineOffset[i], (int)Columns, true);
-    LineWraps[i] = false;
+  // blank out the default grid
+  for (i = 0; i < default_grid.Rows; i++) {
+    grid_clear_line(&default_grid, default_grid.line_offset[i],
+                    (int)default_grid.Columns, true);
+    default_grid.line_wraps[i] = false;
   }
 
   ui_call_grid_clear(1);  // clear the display
@@ -6089,27 +6287,33 @@ static void screenclear2(void)
   msg_didout = false;
 }
 
-/*
- * Clear one line in ScreenLines.
- */
-static void lineclear(unsigned off, int width, bool valid)
+/// clear a line in the grid starting at "off" until "width" characters
+/// are cleared.
+static void grid_clear_line(ScreenGrid *grid, unsigned off, int width,
+                            bool valid)
 {
   for (int col = 0; col < width; col++) {
-    schar_from_ascii(ScreenLines[off + col], ' ');
+    schar_from_ascii(grid->chars[off + col], ' ');
   }
   int fill = valid ? 0 : -1;
-  (void)memset(ScreenAttrs + off, fill, (size_t)width * sizeof(sattr_T));
+  (void)memset(grid->attrs + off, fill, (size_t)width * sizeof(sattr_T));
 }
 
-/// Copy part of a Screenline for vertically split window.
-static void linecopy(int to, int from, int col, int width)
+static void grid_invalidate(ScreenGrid *grid)
 {
-  unsigned off_to = LineOffset[to] + col;
-  unsigned off_from = LineOffset[from] + col;
+  (void)memset(grid->attrs, -1, grid->Rows * grid->Columns * sizeof(sattr_T));
+}
+
+
+/// Copy part of a grid line for vertically split window.
+static void linecopy(ScreenGrid *grid, int to, int from, int col, int width)
+{
+  unsigned off_to = grid->line_offset[to] + col;
+  unsigned off_from = grid->line_offset[from] + col;
 
-  memmove(ScreenLines + off_to, ScreenLines + off_from,
+  memmove(grid->chars + off_to, grid->chars + off_from,
           width * sizeof(schar_T));
-  memmove(ScreenAttrs + off_to, ScreenAttrs + off_from,
+  memmove(grid->attrs + off_to, grid->attrs + off_from,
           width * sizeof(sattr_T));
 }
 
@@ -6124,12 +6328,11 @@ void setcursor(void)
     if (curwin->w_p_rl) {
       // With 'rightleft' set and the cursor on a double-wide character,
       // position it on the leftmost column.
-      left_offset = curwin->w_width - curwin->w_wcol
+      left_offset = curwin->w_grid.Columns - curwin->w_wcol
                     - ((utf_ptr2cells(get_cursor_pos_ptr()) == 2
                         && vim_isprintc(gchar_cursor())) ? 2 : 1);
     }
-    ui_cursor_goto(curwin->w_winrow + curwin->w_wrow,
-                   curwin->w_wincol + left_offset);
+    ui_grid_cursor_goto(&curwin->w_grid, curwin->w_wrow, left_offset);
   }
 }
 
@@ -6156,7 +6359,7 @@ static int win_do_lines(win_T *wp, int row, int line_count, int del)
   }
 
   // No lines are being moved, just draw over the entire area
-  if (row + line_count >= wp->w_height) {
+  if (row + line_count >= wp->w_grid.Rows) {
     return OK;
   }
 
@@ -6165,15 +6368,12 @@ static int win_do_lines(win_T *wp, int row, int line_count, int del)
   check_for_delay(false);
   clear_cmdline = true;
   int retval;
-
   if (del) {
-    retval = screen_del_lines(wp->w_winrow + row, line_count,
-                              wp->w_winrow + wp->w_height,
-                              wp->w_wincol, wp->w_width);
+    retval = grid_del_lines(&wp->w_grid, row, line_count,
+                            wp->w_grid.Rows, 0, wp->w_grid.Columns);
   } else {
-    retval = screen_ins_lines(wp->w_winrow + row, line_count,
-                              wp->w_winrow + wp->w_height,
-                              wp->w_wincol, wp->w_width);
+    retval = grid_ins_lines(&wp->w_grid, row, line_count,
+                            wp->w_grid.Rows, 0, wp->w_grid.Columns);
   }
   return retval;
 }
@@ -6189,95 +6389,115 @@ static int win_do_lines(win_T *wp, int row, int line_count, int del)
  */
 
 
-/// insert lines on the screen and update ScreenLines[]
+/// insert lines on the screen and move the existing lines down
+/// 'line_count' is the number of lines to be inserted.
 /// 'end' is the line after the scrolled part. Normally it is Rows.
-/// When scrolling region used 'off' is the offset from the top for the region.
-/// 'row' and 'end' are relative to the start of the region.
+/// 'col' is the column from with we start inserting.
+//
+/// 'row', 'col' and 'end' are relative to the start of the region.
 ///
 /// @return FAIL for failure, OK for success.
-int screen_ins_lines(int row, int line_count, int end, int col, int width)
+int grid_ins_lines(ScreenGrid *grid, int row, int line_count, int end, int col,
+                   int width)
 {
   int i;
   int j;
   unsigned temp;
 
+  // If UI is not externalized, keep working on default grid
+  if (!ui_is_external(kUIMultigrid) && grid != &default_grid) {
+    row += grid->row_offset;
+    end += grid->row_offset;
+    col += grid->col_offset;
+    grid = &default_grid;
+  }
+
   if (!screen_valid(TRUE) || line_count <= 0) {
     return FAIL;
   }
 
-  // Shift LineOffset[] line_count down to reflect the inserted lines.
-  // Clear the inserted lines in ScreenLines[].
+  // Shift line_offset[] line_count down to reflect the inserted lines.
+  // Clear the inserted lines.
   for (i = 0; i < line_count; i++) {
-    if (width != Columns) {
+    if (width != grid->Columns) {
       // need to copy part of a line
       j = end - 1 - i;
       while ((j -= line_count) >= row) {
-        linecopy(j + line_count, j, col, width);
+        linecopy(grid, j + line_count, j, col, width);
       }
       j += line_count;
-      lineclear(LineOffset[j] + col, width, false);
-      LineWraps[j] = false;
+      grid_clear_line(grid, grid->line_offset[j] + col, width, false);
+      grid->line_wraps[j] = false;
     } else {
       j = end - 1 - i;
-      temp = LineOffset[j];
+      temp = grid->line_offset[j];
       while ((j -= line_count) >= row) {
-        LineOffset[j + line_count] = LineOffset[j];
-        LineWraps[j + line_count] = LineWraps[j];
+        grid->line_offset[j + line_count] = grid->line_offset[j];
+        grid->line_wraps[j + line_count] = grid->line_wraps[j];
       }
-      LineOffset[j + line_count] = temp;
-      LineWraps[j + line_count] = false;
-      lineclear(temp, (int)Columns, false);
+      grid->line_offset[j + line_count] = temp;
+      grid->line_wraps[j + line_count] = false;
+      grid_clear_line(grid, temp, (int)grid->Columns, false);
     }
   }
 
-  ui_call_grid_scroll(1, row, end, col, col+width, -line_count, 0);
+  ui_call_grid_scroll(grid->handle, row, end, col, col+width, -line_count, 0);
 
   return OK;
 }
 
-/// delete lines on the screen and update ScreenLines[]
+/// delete lines on the screen and move lines up.
 /// 'end' is the line after the scrolled part. Normally it is Rows.
 /// When scrolling region used 'off' is the offset from the top for the region.
 /// 'row' and 'end' are relative to the start of the region.
 ///
 /// Return OK for success, FAIL if the lines are not deleted.
-int screen_del_lines(int row, int line_count, int end, int col, int width)
+int grid_del_lines(ScreenGrid *grid, int row, int line_count, int end, int col,
+                   int width)
 {
   int j;
   int i;
   unsigned temp;
 
+  // If UI is not externalized, keep working on default grid
+  if (!ui_is_external(kUIMultigrid) && grid != &default_grid) {
+    row += grid->row_offset;
+    end += grid->row_offset;
+    col += grid->col_offset;
+    grid = &default_grid;
+  }
+
   if (!screen_valid(TRUE) || line_count <= 0) {
     return FAIL;
   }
 
-  // Now shift LineOffset[] line_count up to reflect the deleted lines.
-  // Clear the inserted lines in ScreenLines[].
+  // Now shift line_offset[] line_count up to reflect the deleted lines.
+  // Clear the inserted lines.
   for (i = 0; i < line_count; i++) {
-    if (width != Columns) {
+    if (width != grid->Columns) {
       // need to copy part of a line
       j = row + i;
       while ((j += line_count) <= end - 1) {
-        linecopy(j - line_count, j, col, width);
+        linecopy(grid, j - line_count, j, col, width);
       }
       j -= line_count;
-      lineclear(LineOffset[j] + col, width, false);
-      LineWraps[j] = false;
+      grid_clear_line(grid, grid->line_offset[j] + col, width, false);
+      grid->line_wraps[j] = false;
     } else {
       // whole width, moving the line pointers is faster
       j = row + i;
-      temp = LineOffset[j];
+      temp = grid->line_offset[j];
       while ((j += line_count) <= end - 1) {
-        LineOffset[j - line_count] = LineOffset[j];
-        LineWraps[j - line_count] = LineWraps[j];
+        grid->line_offset[j - line_count] = grid->line_offset[j];
+        grid->line_wraps[j - line_count] = grid->line_wraps[j];
       }
-      LineOffset[j - line_count] = temp;
-      LineWraps[j - line_count] = false;
-      lineclear(temp, (int)Columns, false);
+      grid->line_offset[j - line_count] = temp;
+      grid->line_wraps[j - line_count] = false;
+      grid_clear_line(grid, temp, (int)grid->Columns, false);
     }
   }
 
-  ui_call_grid_scroll(1, row, end, col, col+width, line_count, 0);
+  ui_call_grid_scroll(grid->handle, row, end, col, col+width, line_count, 0);
 
   return OK;
 }
@@ -6324,8 +6544,9 @@ int showmode(void)
 
     /* if the cmdline is more than one line high, erase top lines */
     need_clear = clear_cmdline;
-    if (clear_cmdline && cmdline_row < Rows - 1)
-      msg_clr_cmdline();                        /* will reset clear_cmdline */
+    if (clear_cmdline && cmdline_row < default_grid.Rows - 1) {
+      msg_clr_cmdline();  // will reset clear_cmdline
+    }
 
     /* Position on the last line in the window, column 0 */
     msg_pos_mode();
@@ -6343,9 +6564,10 @@ int showmode(void)
       if (edit_submode != NULL && !shortmess(SHM_COMPLETIONMENU)) {
         /* These messages can get long, avoid a wrap in a narrow
          * window.  Prefer showing edit_submode_extra. */
-        length = (Rows - msg_row) * Columns - 3;
-        if (edit_submode_extra != NULL)
+        length = (default_grid.Rows - msg_row) * default_grid.Columns - 3;
+        if (edit_submode_extra != NULL) {
           length -= vim_strsize(edit_submode_extra);
+        }
         if (length > 0) {
           if (edit_submode_pre != NULL)
             length -= vim_strsize(edit_submode_pre);
@@ -6466,7 +6688,7 @@ int showmode(void)
 static void msg_pos_mode(void)
 {
   msg_col = 0;
-  msg_row = Rows - 1;
+  msg_row = default_grid.Rows - 1;
 }
 
 /// Delete mode message.  Used when ESC is typed which is expected to end
@@ -6525,7 +6747,7 @@ static void draw_tabline(void)
   int use_sep_chars = (t_colors < 8
                        );
 
-  if (ScreenLines == NULL) {
+  if (default_grid.chars == NULL) {
     return;
   }
   redraw_tabline = false;
@@ -6540,7 +6762,7 @@ static void draw_tabline(void)
 
 
   // Init TabPageIdxs[] to zero: Clicking outside of tabs has no effect.
-  assert(Columns == tab_page_click_defs_size);
+  assert(default_grid.Columns == tab_page_click_defs_size);
   clear_tab_page_click_defs(tab_page_click_defs, tab_page_click_defs_size);
 
   /* Use the 'tabline' option if it's set. */
@@ -6562,7 +6784,7 @@ static void draw_tabline(void)
     }
 
     if (tabcount > 0) {
-      tabwidth = (Columns - 1 + tabcount / 2) / tabcount;
+      tabwidth = (default_grid.Columns - 1 + tabcount / 2) / tabcount;
     }
 
     if (tabwidth < 6) {
@@ -6573,7 +6795,7 @@ static void draw_tabline(void)
     tabcount = 0;
 
     FOR_ALL_TABS(tp) {
-      if (col >= Columns - 4) {
+      if (col >= default_grid.Columns - 4) {
         break;
       }
 
@@ -6592,14 +6814,14 @@ static void draw_tabline(void)
         attr = win_hl_attr(cwp, HLF_TPS);
       }
       if (use_sep_chars && col > 0) {
-        screen_putchar('|', 0, col++, attr);
+        grid_putchar(&default_grid, '|', 0, col++, attr);
       }
 
       if (tp->tp_topframe != topframe) {
         attr = win_hl_attr(cwp, HLF_TP);
       }
 
-      screen_putchar(' ', 0, col++, attr);
+      grid_putchar(&default_grid, ' ', 0, col++, attr);
 
       modified = false;
 
@@ -6614,15 +6836,17 @@ static void draw_tabline(void)
         if (wincount > 1) {
           vim_snprintf((char *)NameBuff, MAXPATHL, "%d", wincount);
           len = (int)STRLEN(NameBuff);
-          if (col + len >= Columns - 3)
+          if (col + len >= default_grid.Columns - 3) {
             break;
-          screen_puts_len(NameBuff, len, 0, col,
-                          hl_combine_attr(attr, win_hl_attr(cwp, HLF_T)));
+          }
+          grid_puts_len(&default_grid, NameBuff, len, 0, col,
+                        hl_combine_attr(attr, win_hl_attr(cwp, HLF_T)));
           col += len;
         }
-        if (modified)
-          screen_puts_len((char_u *)"+", 1, 0, col++, attr);
-        screen_putchar(' ', 0, col++, attr);
+        if (modified) {
+          grid_puts_len(&default_grid, (char_u *)"+", 1, 0, col++, attr);
+        }
+        grid_putchar(&default_grid, ' ', 0, col++, attr);
       }
 
       room = scol - col + tabwidth - 1;
@@ -6641,13 +6865,14 @@ static void draw_tabline(void)
           p += len - room;
           len = room;
         }
-        if (len > Columns - col - 1)
-          len = Columns - col - 1;
+        if (len > default_grid.Columns - col - 1) {
+          len = default_grid.Columns - col - 1;
+        }
 
-        screen_puts_len(p, (int)STRLEN(p), 0, col, attr);
+        grid_puts_len(&default_grid, p, (int)STRLEN(p), 0, col, attr);
         col += len;
       }
-      screen_putchar(' ', 0, col++, attr);
+      grid_putchar(&default_grid, ' ', 0, col++, attr);
 
       // Store the tab page number in tab_page_click_defs[], so that
       // jump_to_mouse() knows where each one is.
@@ -6665,12 +6890,14 @@ static void draw_tabline(void)
       c = '_';
     else
       c = ' ';
-    screen_fill(0, 1, col, (int)Columns, c, c, attr_fill);
+    grid_fill(&default_grid, 0, 1, col, (int)default_grid.Columns, c, c,
+              attr_fill);
 
     /* Put an "X" for closing the current tab if there are several. */
     if (first_tabpage->tp_next != NULL) {
-      screen_putchar('X', 0, (int)Columns - 1, attr_nosel);
-      tab_page_click_defs[Columns - 1] = (StlClickDefinition) {
+      grid_putchar(&default_grid, 'X', 0, (int)default_grid.Columns - 1,
+                   attr_nosel);
+      tab_page_click_defs[default_grid.Columns - 1] = (StlClickDefinition) {
         .type = kStlClickTabClose,
         .tabnr = 999,
         .func = NULL,
@@ -6861,15 +7088,15 @@ static void win_redr_ruler(win_T *wp, int always)
     int off;
 
     if (wp->w_status_height) {
-      row = wp->w_winrow + wp->w_height;
+      row = W_ENDROW(wp);
       fillchar = fillchar_status(&attr, wp);
       off = wp->w_wincol;
       width = wp->w_width;
     } else {
-      row = Rows - 1;
+      row = default_grid.Rows - 1;
       fillchar = ' ';
       attr = 0;
-      width = Columns;
+      width = default_grid.Columns;
       off = 0;
     }
 
@@ -6904,15 +7131,18 @@ static void win_redr_ruler(win_T *wp, int always)
     int i = (int)STRLEN(buffer);
     get_rel_pos(wp, buffer + i + 1, RULER_BUF_LEN - i - 1);
     int o = i + vim_strsize(buffer + i + 1);
-    if (wp->w_status_height == 0)       /* can't use last char of screen */
-      ++o;
-    int this_ru_col = ru_col - (Columns - width);
-    if (this_ru_col < 0)
+    if (wp->w_status_height == 0) {  // can't use last char of screen
+      o++;
+    }
+    int this_ru_col = ru_col - (default_grid.Columns - width);
+    if (this_ru_col < 0) {
       this_ru_col = 0;
-    /* Never use more than half the window/screen width, leave the other
-     * half for the filename. */
-    if (this_ru_col < (width + 1) / 2)
+    }
+    // Never use more than half the window/screen width, leave the other half
+    // for the filename.
+    if (this_ru_col < (width + 1) / 2) {
       this_ru_col = (width + 1) / 2;
+    }
     if (this_ru_col + o < width) {
       // Need at least 3 chars left for get_rel_pos() + NUL.
       while (this_ru_col + o < width && RULER_BUF_LEN > i + 4) {
@@ -6931,13 +7161,12 @@ static void win_redr_ruler(win_T *wp, int always)
       }
     }
 
-    screen_puts(buffer, row, this_ru_col + off, attr);
+    grid_puts(&default_grid, buffer, row, this_ru_col + off, attr);
     i = redraw_cmdline;
-    screen_fill(row, row + 1,
-        this_ru_col + off + (int)STRLEN(buffer),
-        off + width,
-        fillchar, fillchar, attr);
-    /* don't redraw the cmdline because of showing the ruler */
+    grid_fill(&default_grid, row, row + 1,
+              this_ru_col + off + (int)STRLEN(buffer), off + width, fillchar,
+              fillchar, attr);
+    // don't redraw the cmdline because of showing the ruler
     redraw_cmdline = i;
     wp->w_ru_cursor = wp->w_cursor;
     wp->w_ru_virtcol = wp->w_virtcol;
@@ -6958,12 +7187,13 @@ int number_width(win_T *wp)
   int n;
   linenr_T lnum;
 
-  if (wp->w_p_rnu && !wp->w_p_nu)
-    /* cursor line shows "0" */
-    lnum = wp->w_height;
-  else
-    /* cursor line shows absolute line number */
+  if (wp->w_p_rnu && !wp->w_p_nu) {
+    // cursor line shows "0"
+    lnum = wp->w_grid.Rows;
+  } else {
+    // cursor line shows absolute line number
     lnum = wp->w_buffer->b_ml.ml_line_count;
+  }
 
   if (lnum == wp->w_nrwidth_line_count)
     return wp->w_nrwidth_width;
@@ -7019,6 +7249,8 @@ void screen_resize(int width, int height)
   width = Columns;
   ui_resize(width, height);
 
+  send_grid_resize = true;
+
   /* The window layout used to be adjusted here, but it now happens in
    * screenalloc() (also invoked from screenclear()).  That is because the
    * "busy" check above may skip this, but not screenalloc(). */
@@ -7040,7 +7272,7 @@ void screen_resize(int width, int height)
      * - in Ex mode, don't redraw anything.
      * - Otherwise, redraw right now, and position the cursor.
      * Always need to call update_screen() or screenalloc(), to make
-     * sure Rows/Columns and the size of ScreenLines[] is correct!
+     * sure Rows/Columns and the size of the screen is correct!
      */
     if (State == ASKMORE || State == EXTERNCMD || State == CONFIRM
         || exmode_active) {
@@ -7112,3 +7344,13 @@ void win_new_shellsize(void)
     shell_new_columns();  // update window sizes
   }
 }
+
+win_T *get_win_by_grid_handle(handle_T handle)
+{
+  FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+    if (wp->w_grid.handle == handle) {
+      return wp;
+    }
+  }
+  return NULL;
+}
diff --git a/src/nvim/screen.h b/src/nvim/screen.h
index 17515d4253..109541ef07 100644
--- a/src/nvim/screen.h
+++ b/src/nvim/screen.h
@@ -5,6 +5,7 @@
 
 #include "nvim/types.h"
 #include "nvim/buffer_defs.h"
+#include "nvim/grid_defs.h"
 #include "nvim/pos.h"
 
 /*
@@ -20,6 +21,18 @@
 #define NOT_VALID               40  /* buffer needs complete redraw */
 #define CLEAR                   50  /* screen messed up, clear it */
 
+/// By default, all widows are draw on a single rectangular grid, represented by
+/// this ScreenGrid instance. In multigrid mode each window will have its own
+/// grid, then this is only used for global screen elements that hasn't been
+/// externalized.
+///
+/// Note: before the screen is initialized and when out of memory these can be
+/// NULL.
+EXTERN ScreenGrid default_grid INIT(= { 0, NULL, NULL, NULL, NULL, 0, 0, 0, 0,
+                                        0, 0, 0 });
+
+#define DEFAULT_GRID_HANDLE 1  // handle for the default_grid
+
 /// Status line click definition
 typedef struct {
   enum {
diff --git a/src/nvim/search.c b/src/nvim/search.c
index f31ec7170b..cf0f1ea287 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -2166,9 +2166,10 @@ showmatch(
     if (!curwin->w_p_wrap) {
       getvcol(curwin, lpos, NULL, &vcol, NULL);
     }
-    if (curwin->w_p_wrap || (vcol >= curwin->w_leftcol
-                             && vcol < curwin->w_leftcol + curwin->w_width)) {
-      mpos = *lpos;          /* save the pos, update_screen() may change it */
+    if (curwin->w_p_wrap
+        || (vcol >= curwin->w_leftcol
+            && vcol < curwin->w_leftcol + curwin->w_grid.Columns)) {
+      mpos = *lpos;  // save the pos, update_screen() may change it
       save_cursor = curwin->w_cursor;
       save_so = p_so;
       save_siso = p_siso;
diff --git a/src/nvim/types.h b/src/nvim/types.h
index 317bead3bb..f803b45e27 100644
--- a/src/nvim/types.h
+++ b/src/nvim/types.h
@@ -13,6 +13,9 @@ typedef unsigned char char_u;
 // Can hold one decoded UTF-8 character.
 typedef uint32_t u8char_T;
 
+// Opaque handle used by API clients to refer to various objects in vim
+typedef int handle_T;
+
 typedef struct expand expand_T;
 
 #endif  // NVIM_TYPES_H
diff --git a/src/nvim/ui.c b/src/nvim/ui.c
index 0c69e94e5d..dc81c18b0b 100644
--- a/src/nvim/ui.c
+++ b/src/nvim/ui.c
@@ -57,6 +57,7 @@ static int busy = 0;
 static int mode_idx = SHAPE_IDX_N;
 static bool pending_mode_info_update = false;
 static bool pending_mode_update = false;
+static handle_T cursor_grid_handle = DEFAULT_GRID_HANDLE;
 
 #if MIN_LOG_LEVEL > DEBUG_LOG_LEVEL
 # define UI_LOG(funname, ...)
@@ -196,13 +197,6 @@ void ui_refresh(void)
   row = col = 0;
   pending_cursor_update = true;
 
-  ui_default_colors_set();
-
-  int save_p_lz = p_lz;
-  p_lz = false;  // convince redrawing() to return true ...
-  screen_resize(width, height);
-  p_lz = save_p_lz;
-
   for (UIExtension i = 0; (int)i < kUIExtCount; i++) {
     ui_ext[i] = ext_widgets[i];
     if (i < kUIGlobalCount) {
@@ -210,6 +204,14 @@ void ui_refresh(void)
                          BOOLEAN_OBJ(ext_widgets[i]));
     }
   }
+
+  ui_default_colors_set();
+
+  int save_p_lz = p_lz;
+  p_lz = false;  // convince redrawing() to return true ...
+  screen_resize(width, height);
+  p_lz = save_p_lz;
+
   ui_mode_info_set();
   pending_mode_update = true;
   ui_cursor_shape();
@@ -315,12 +317,18 @@ void ui_set_ext_option(UI *ui, UIExtension ext, bool active)
   }
 }
 
-void ui_line(int row, int startcol, int endcol, int clearcol, int clearattr,
-             bool wrap)
+void ui_line(ScreenGrid *grid, int row, int startcol, int endcol, int clearcol,
+             int clearattr, bool wrap)
 {
-  size_t off = LineOffset[row]+(size_t)startcol;
-  UI_CALL(raw_line, 1, row, startcol, endcol, clearcol, clearattr, wrap,
-          (const schar_T *)ScreenLines+off, (const sattr_T *)ScreenAttrs+off);
+  size_t off = grid->line_offset[row] + (size_t)startcol;
+  int row_off = ui_is_external(kUIMultigrid) ? 0 : grid->row_offset;
+  int col_off = ui_is_external(kUIMultigrid) ? 0 : grid->col_offset;
+
+  UI_CALL(raw_line, grid->handle, row_off + row, col_off + startcol,
+          col_off + endcol, col_off + clearcol, clearattr, wrap,
+          (const schar_T *)grid->chars + off,
+          (const sattr_T *)grid->attrs + off);
+
   if (p_wd) {  // 'writedelay': flush & delay each time.
     int old_row = row, old_col = col;
     // If'writedelay is active, we set the cursor to highlight what was drawn
@@ -334,11 +342,23 @@ void ui_line(int row, int startcol, int endcol, int clearcol, int clearattr,
 
 void ui_cursor_goto(int new_row, int new_col)
 {
-  if (new_row == row && new_col == col) {
+  ui_grid_cursor_goto(&default_grid, new_row, new_col);
+}
+
+void ui_grid_cursor_goto(ScreenGrid *grid, int new_row, int new_col)
+{
+  new_row += ui_is_external(kUIMultigrid) ? 0 : grid->row_offset;
+  new_col += ui_is_external(kUIMultigrid) ? 0 : grid->col_offset;
+  int handle = ui_is_external(kUIMultigrid) ? grid->handle
+                                            : DEFAULT_GRID_HANDLE;
+
+  if (new_row == row && new_col == col && handle == cursor_grid_handle) {
     return;
   }
+
   row = new_row;
   col = new_col;
+  cursor_grid_handle = handle;
   pending_cursor_update = true;
 }
 
@@ -360,8 +380,9 @@ int ui_current_col(void)
 void ui_flush(void)
 {
   cmdline_ui_flush();
+  win_ui_flush();
   if (pending_cursor_update) {
-    ui_call_grid_cursor_goto(1, row, col);
+    ui_call_grid_cursor_goto(cursor_grid_handle, row, col);
     pending_cursor_update = false;
   }
   if (pending_mode_info_update) {
@@ -421,3 +442,22 @@ Array ui_array(void)
   }
   return all_uis;
 }
+
+void ui_grid_resize(handle_T grid_handle, int width, int height, Error *error)
+{
+  if (grid_handle == DEFAULT_GRID_HANDLE) {
+    screen_resize(width, height);
+    return;
+  }
+
+  win_T *wp = get_win_by_grid_handle(grid_handle);
+  if (wp == NULL) {
+    api_set_error(error, kErrorTypeValidation,
+                  "No window with the given handle");
+    return;
+  }
+
+  wp->w_grid.requested_rows = (int)height;
+  wp->w_grid.requested_cols = (int)width;
+  redraw_win_later(wp, SOME_VALID);
+}
diff --git a/src/nvim/ui.h b/src/nvim/ui.h
index d89ad60ce7..16237214cb 100644
--- a/src/nvim/ui.h
+++ b/src/nvim/ui.h
@@ -16,6 +16,7 @@ typedef enum {
   kUIWildmenu,
 #define kUIGlobalCount (kUIWildmenu+1)
   kUILinegrid,
+  kUIMultigrid,
   kUIHlState,
   kUIExtCount,
 } UIExtension;
@@ -26,6 +27,7 @@ EXTERN const char *ui_ext_names[] INIT(= {
   "ext_tabline",
   "ext_wildmenu",
   "ext_linegrid",
+  "ext_multigrid",
   "ext_hlstate",
 });
 
diff --git a/src/nvim/version.c b/src/nvim/version.c
index 11dc813997..9b9053d7a9 100644
--- a/src/nvim/version.c
+++ b/src/nvim/version.c
@@ -2271,8 +2271,8 @@ static void do_intro_line(long row, char_u *mesg, int attr)
       }
     }
     assert(row <= INT_MAX && col <= INT_MAX);
-    screen_puts_len(p, l, (int)row, (int)col,
-                    *p == '<' ? HL_ATTR(HLF_8) : attr);
+    grid_puts_len(&default_grid, p, l, (int)row, (int)col,
+                  *p == '<' ? HL_ATTR(HLF_8) : attr);
     col += clen;
   }
 }
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 8be79f0cff..1b7318dd8c 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -997,6 +997,9 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
     p_wh = i;
   }
 
+  // Send the window positions to the UI
+  oldwin->w_pos_changed = true;
+
   return OK;
 }
 
@@ -1341,6 +1344,9 @@ static void win_rotate(int upwards, int count)
     (void)win_comp_pos();
   }
 
+  wp1->w_pos_changed = true;
+  wp2->w_pos_changed = true;
+
   redraw_all_later(NOT_VALID);
 }
 
@@ -1423,6 +1429,9 @@ void win_move_after(win_T *win1, win_T *win2)
     redraw_later(NOT_VALID);
   }
   win_enter(win1, false);
+
+  win1->w_pos_changed = true;
+  win2->w_pos_changed = true;
 }
 
 /*
@@ -2059,6 +2068,7 @@ int win_close(win_T *win, bool free_buf)
   if (help_window)
     restore_snapshot(SNAP_HELP_IDX, close_curwin);
 
+  curwin->w_pos_changed = true;
   redraw_all_later(NOT_VALID);
   return OK;
 }
@@ -3108,6 +3118,10 @@ int win_new_tabpage(int after, char_u *filename)
 
     redraw_all_later(NOT_VALID);
 
+    if (ui_is_external(kUIMultigrid)) {
+        tabpage_check_windows(tp);
+    }
+
     apply_autocmds(EVENT_WINNEW, NULL, NULL, false, curbuf);
     apply_autocmds(EVENT_WINENTER, NULL, NULL, false, curbuf);
     apply_autocmds(EVENT_TABNEW, filename, filename, false, curbuf);
@@ -3299,11 +3313,16 @@ static void enter_tabpage(tabpage_T *tp, buf_T *old_curbuf, int trigger_enter_au
   int old_off = tp->tp_firstwin->w_winrow;
   win_T       *next_prevwin = tp->tp_prevwin;
 
+  tabpage_T *old_curtab = curtab;
   curtab = tp;
   firstwin = tp->tp_firstwin;
   lastwin = tp->tp_lastwin;
   topframe = tp->tp_topframe;
 
+  if (old_curtab != curtab && ui_is_external(kUIMultigrid)) {
+     tabpage_check_windows(old_curtab);
+  }
+
   /* We would like doing the TabEnter event first, but we don't have a
    * valid current window yet, which may break some commands.
    * This triggers autocommands, thus may make "tp" invalid. */
@@ -3339,6 +3358,20 @@ static void enter_tabpage(tabpage_T *tp, buf_T *old_curbuf, int trigger_enter_au
   must_redraw = NOT_VALID;
 }
 
+/// called when changing current tabpage from old_curtab to curtab
+static void tabpage_check_windows(tabpage_T *old_curtab)
+{
+  win_T *next_wp;
+  for (win_T *wp = old_curtab->tp_firstwin; wp; wp = next_wp) {
+    next_wp = wp->w_next;
+    wp->w_pos_changed = true;
+  }
+
+  for (win_T *wp = firstwin; wp; wp = wp->w_next) {
+    wp->w_pos_changed = true;
+  }
+}
+
 /*
  * Go to tab page "n".  For ":tab N" and "Ngt".
  * When "n" is 9999 go to the last tab page.
@@ -3860,6 +3893,8 @@ static win_T *win_alloc(win_T *after, int hidden)
   new_wp->handle = ++last_win_id;
   handle_register_window(new_wp);
 
+  grid_assign_handle(&new_wp->w_grid);
+
   // Init w: variables.
   new_wp->w_vars = tv_dict_alloc();
   init_var_dict(new_wp->w_vars, &new_wp->w_winvar, VAR_SCOPE);
@@ -3958,6 +3993,8 @@ win_free (
 
   xfree(wp->w_p_cc_cols);
 
+  win_free_grid(wp, false);
+
   if (wp != aucmd_win)
     win_remove(wp, tp);
   if (autocmd_busy) {
@@ -3970,6 +4007,20 @@ win_free (
   unblock_autocmds();
 }
 
+void win_free_grid(win_T *wp, bool reinit)
+{
+  if (wp->w_grid.handle != 0 && ui_is_external(kUIMultigrid)) {
+    ui_call_grid_destroy(wp->w_grid.handle);
+    wp->w_grid.handle = 0;
+  }
+  grid_free(&wp->w_grid);
+  if (reinit) {
+    // if a float is turned into a split and back into a float, the grid
+    // data structure will be reused
+    memset(&wp->w_grid, 0, sizeof(wp->w_grid));
+  }
+}
+
 /*
  * Append window "wp" in the window list after window "after".
  */
@@ -4071,8 +4122,8 @@ static void frame_remove(frame_T *frp)
 void win_alloc_lines(win_T *wp)
 {
   wp->w_lines_valid = 0;
-  assert(Rows >= 0);
-  wp->w_lines = xcalloc(Rows, sizeof(wline_T));
+  assert(wp->w_grid.Rows >= 0);
+  wp->w_lines = xcalloc(MAX(wp->w_grid.Rows + 1, Rows), sizeof(wline_T));
 }
 
 /*
@@ -4202,7 +4253,8 @@ static void frame_comp_pos(frame_T *topfrp, int *row, int *col)
       wp->w_winrow = *row;
       wp->w_wincol = *col;
       redraw_win_later(wp, NOT_VALID);
-      wp->w_redr_status = TRUE;
+      wp->w_redr_status = true;
+      wp->w_pos_changed = true;
     }
     *row += wp->w_height + wp->w_status_height;
     *col += wp->w_width + wp->w_vsep_width;
@@ -4255,8 +4307,9 @@ void win_setheight_win(int height, win_T *win)
    * If there is extra space created between the last window and the command
    * line, clear it.
    */
-  if (full_screen && msg_scrolled == 0 && row < cmdline_row)
-    screen_fill(row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
+  if (full_screen && msg_scrolled == 0 && row < cmdline_row) {
+    grid_fill(&default_grid, row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
+  }
   cmdline_row = row;
   msg_row = row;
   msg_col = 0;
@@ -4706,7 +4759,7 @@ void win_drag_status_line(win_T *dragwin, int offset)
       fr = fr->fr_next;
   }
   row = win_comp_pos();
-  screen_fill(row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
+  grid_fill(&default_grid, row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
   cmdline_row = row;
   p_ch = Rows - cmdline_row;
   if (p_ch < 1)
@@ -4866,6 +4919,8 @@ void win_new_height(win_T *wp, int height)
   if (!exiting) {
     scroll_to_fraction(wp, prev_height);
   }
+
+  wp->w_pos_changed = true;
 }
 
 void scroll_to_fraction(win_T *wp, int prev_height)
@@ -4996,6 +5051,7 @@ void win_new_width(win_T *wp, int width)
                       0);
     }
   }
+  wp->w_pos_changed = true;
 }
 
 void win_comp_scroll(win_T *wp)
@@ -5052,10 +5108,11 @@ void command_height(void)
       /* Recompute window positions. */
       (void)win_comp_pos();
 
-      /* clear the lines added to cmdline */
-      if (full_screen)
-        screen_fill(cmdline_row, (int)Rows, 0,
-            (int)Columns, ' ', ' ', 0);
+      // clear the lines added to cmdline
+      if (full_screen) {
+        grid_fill(&default_grid, cmdline_row, (int)Rows, 0, (int)Columns, ' ',
+                  ' ', 0);
+      }
       msg_row = cmdline_row;
       redraw_cmdline = TRUE;
       return;
@@ -6031,3 +6088,23 @@ void win_findbuf(typval_T *argvars, list_T *list)
     }
   }
 }
+
+void win_ui_flush(void)
+{
+  if (!ui_is_external(kUIMultigrid)) {
+    return;
+  }
+
+  FOR_ALL_TAB_WINDOWS(tp, wp) {
+    if (wp->w_pos_changed && wp->w_grid.chars != NULL) {
+      if (tp == curtab) {
+        ui_call_win_pos(wp->w_grid.handle, wp->handle, wp->w_winrow,
+                        wp->w_wincol, wp->w_width, wp->w_height);
+      } else {
+        ui_call_win_hide(wp->w_grid.handle);
+      }
+      wp->w_pos_changed = false;
+    }
+  }
+
+}
diff --git a/test/functional/api/vim_spec.lua b/test/functional/api/vim_spec.lua
index ddf5575e31..52e41ca856 100644
--- a/test/functional/api/vim_spec.lua
+++ b/test/functional/api/vim_spec.lua
@@ -1261,6 +1261,7 @@ describe('API', function()
           ext_tabline = false,
           ext_wildmenu = false,
           ext_linegrid = screen._options.ext_linegrid or false,
+          ext_multigrid = false,
           ext_hlstate=false,
           height = 4,
           rgb = true,
diff --git a/test/functional/helpers.lua b/test/functional/helpers.lua
index 272b80466c..851f3e720e 100644
--- a/test/functional/helpers.lua
+++ b/test/functional/helpers.lua
@@ -84,6 +84,10 @@ end
 
 local session, loop_running, last_error
 
+local function get_session()
+  return session
+end
+
 local function set_session(s, keep)
   if session and not keep then
     session:close()
@@ -164,34 +168,34 @@ local function expect_msg_seq(...)
   error(final_error)
 end
 
-local function call_and_stop_on_error(...)
+local function call_and_stop_on_error(lsession, ...)
   local status, result = copcall(...)  -- luacheck: ignore
   if not status then
-    session:stop()
+    lsession:stop()
     last_error = result
     return ''
   end
   return result
 end
 
-local function run(request_cb, notification_cb, setup_cb, timeout)
+local function run_session(lsession, request_cb, notification_cb, setup_cb, timeout)
   local on_request, on_notification, on_setup
 
   if request_cb then
     function on_request(method, args)
-      return call_and_stop_on_error(request_cb, method, args)
+      return call_and_stop_on_error(lsession, request_cb, method, args)
     end
   end
 
   if notification_cb then
     function on_notification(method, args)
-      call_and_stop_on_error(notification_cb, method, args)
+      call_and_stop_on_error(lsession, notification_cb, method, args)
     end
   end
 
   if setup_cb then
     function on_setup()
-      call_and_stop_on_error(setup_cb)
+      call_and_stop_on_error(lsession, setup_cb)
     end
   end
 
@@ -205,6 +209,10 @@ local function run(request_cb, notification_cb, setup_cb, timeout)
   end
 end
 
+local function run(request_cb, notification_cb, setup_cb, timeout)
+  run_session(session, request_cb, notification_cb, setup_cb, timeout)
+end
+
 local function stop()
   session:stop()
 end
@@ -677,6 +685,7 @@ local module = {
   buffer = buffer,
   bufmeths = bufmeths,
   call = nvim_call,
+  create_callindex = create_callindex,
   clear = clear,
   command = nvim_command,
   connect = connect,
@@ -701,6 +710,7 @@ local module = {
   filter = filter,
   funcs = funcs,
   get_pathsep = get_pathsep,
+  get_session = get_session,
   insert = insert,
   iswin = iswin,
   map = map,
@@ -732,6 +742,7 @@ local module = {
   retry = retry,
   rmdir = rmdir,
   run = run,
+  run_session = run_session,
   set_session = set_session,
   set_shell_powershell = set_shell_powershell,
   skip_fragile = skip_fragile,
diff --git a/test/functional/terminal/helpers.lua b/test/functional/terminal/helpers.lua
index ae8d4704e4..7de0152de0 100644
--- a/test/functional/terminal/helpers.lua
+++ b/test/functional/terminal/helpers.lua
@@ -72,10 +72,10 @@ local function screen_setup(extra_rows, command, cols)
   if command == default_command then
     -- Wait for "tty ready" to be printed before each test or the terminal may
     -- still be in canonical mode (will echo characters for example).
-    local empty_line = (' '):rep(cols + 1)
+    local empty_line = (' '):rep(cols)
     local expected = {
-      'tty ready'..(' '):rep(cols - 8),
-      '{1: }'    ..(' '):rep(cols),
+      'tty ready'..(' '):rep(cols - 9),
+      '{1: }'    ..(' '):rep(cols - 1),
       empty_line,
       empty_line,
       empty_line,
@@ -85,8 +85,8 @@ local function screen_setup(extra_rows, command, cols)
       table.insert(expected, empty_line)
     end
 
-    table.insert(expected, '{3:-- TERMINAL --}' .. ((' '):rep(cols - 13)))
-    screen:expect(table.concat(expected, '\n'))
+    table.insert(expected, '{3:-- TERMINAL --}' .. ((' '):rep(cols - 14)))
+    screen:expect(table.concat(expected, '|\n')..'|')
   else
     -- This eval also acts as a wait().
     if 0 == nvim('eval', "exists('b:terminal_job_id')") then
diff --git a/test/functional/terminal/tui_spec.lua b/test/functional/terminal/tui_spec.lua
index 0b47314be7..68652bfb7f 100644
--- a/test/functional/terminal/tui_spec.lua
+++ b/test/functional/terminal/tui_spec.lua
@@ -259,10 +259,10 @@ describe('tui', function()
     feed_data(':echo map(nvim_list_uis(), {k,v -> sort(items(v))})\013')
     screen:expect([=[
       [[['ext_cmdline', v:false], ['ext_hlstate', v:fals|
-      e], ['ext_linegrid', v:true], ['ext_popupmenu', v:|
-      false], ['ext_tabline', v:false], ['ext_wildmenu',|
-       v:false], ['height', 6], ['rgb', v:false], ['widt|
-      h', 50]]]                                         |
+      e], ['ext_linegrid', v:true], ['ext_multigrid', v:|
+      false], ['ext_popupmenu', v:false], ['ext_tabline'|
+      , v:false], ['ext_wildmenu', v:false], ['height', |
+      6], ['rgb', v:false], ['width', 50]]]             |
       {10:Press ENTER or type command to continue}{1: }          |
       {3:-- TERMINAL --}                                    |
     ]=])
@@ -401,7 +401,7 @@ describe('tui FocusGained/FocusLost', function()
       -- Exit cmdline-mode. Redraws from timers/events are blocked during
       -- cmdline-mode, so the buffer won't be updated until we exit cmdline-mode.
       feed_data('\n')
-      screen:expect{any='lost'..(' '):rep(46)..'\ngained'}
+      screen:expect{any='lost'..(' '):rep(46)..'|\ngained'}
     end)
   end)
 
diff --git a/test/functional/ui/multigrid_spec.lua b/test/functional/ui/multigrid_spec.lua
new file mode 100644
index 0000000000..a5d4e34000
--- /dev/null
+++ b/test/functional/ui/multigrid_spec.lua
@@ -0,0 +1,1524 @@
+local helpers = require('test.functional.helpers')(after_each)
+local Screen = require('test.functional.ui.screen')
+local clear = helpers.clear
+local feed, command, insert = helpers.feed, helpers.command, helpers.insert
+local eq = helpers.eq
+
+
+describe('multigrid screen', function()
+  local screen
+
+  before_each(function()
+    clear{headless=false, args={'--cmd', 'set laststatus=2'}}
+    screen = Screen.new(53,14)
+    screen:attach({ext_multigrid=true})
+    screen:set_default_attr_ids({
+      [1] = {bold = true, foreground = Screen.colors.Blue1},
+      [2] = {foreground = Screen.colors.Magenta},
+      [3] = {foreground = Screen.colors.Brown, bold = true},
+      [4] = {foreground = Screen.colors.SlateBlue},
+      [5] = {bold = true, foreground = Screen.colors.SlateBlue},
+      [6] = {foreground = Screen.colors.Cyan4},
+      [7] = {bold = true},
+      [8] = {underline = true, bold = true, foreground = Screen.colors.SlateBlue},
+      [9] = {foreground = Screen.colors.SlateBlue, underline = true},
+      [10] = {foreground = Screen.colors.Red},
+      [11] = {bold = true, reverse = true},
+      [12] = {reverse = true},
+      [13] = {foreground = Screen.colors.DarkBlue, background = Screen.colors.LightGrey},
+      [14] = {foreground = Screen.colors.Grey100, background = Screen.colors.Red},
+      [15] = {bold = true, foreground = Screen.colors.SeaGreen4},
+      [16] = {background = Screen.colors.LightGrey, underline = true},
+      [17] = {background = Screen.colors.LightGrey, underline = true, bold = true, foreground = Screen.colors.Magenta},
+      [18] = {bold = true, foreground = Screen.colors.Magenta},
+      [19] = {foreground = Screen.colors.Brown},
+    })
+  end)
+
+  after_each(function()
+    screen:detach()
+  end)
+
+  it('default initial screen', function()
+    screen:expect([[
+    ## grid 1
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      {11:[No Name]                                            }|
+                                                           |
+    ## grid 2
+      ^                                                     |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ]])
+  end)
+
+  it('positions windows correctly', function()
+    command('vsplit')
+    screen:expect([[
+    ## grid 1
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      {11:[No Name]                  }{12:[No Name]                 }|
+                                                           |
+    ## grid 2
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 3
+      ^                          |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ]], nil, nil, function()
+      eq({
+        [2] = { win = 1000, startrow = 0, startcol = 27, width = 26, height = 12 },
+        [3] = { win = 1001, startrow = 0, startcol =  0, width = 26, height = 12 }
+      }, screen.win_position)
+    end)
+    command('wincmd l')
+    command('split')
+    screen:expect([[
+    ## grid 1
+      [3:--------------------------]{12:│}[4:--------------------------]|
+      [3:--------------------------]{12:│}[4:--------------------------]|
+      [3:--------------------------]{12:│}[4:--------------------------]|
+      [3:--------------------------]{12:│}[4:--------------------------]|
+      [3:--------------------------]{12:│}[4:--------------------------]|
+      [3:--------------------------]{12:│}[4:--------------------------]|
+      [3:--------------------------]{12:│}{11:[No Name]                 }|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      {12:[No Name]                  [No Name]                 }|
+                                                           |
+    ## grid 2
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 3
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+      ^                          |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ]], nil, nil, function()
+      eq({
+        [2] = { win = 1000, startrow = 7, startcol = 27, width = 26, height =  5 },
+        [3] = { win = 1001, startrow = 0, startcol =  0, width = 26, height = 12 },
+        [4] = { win = 1002, startrow = 0, startcol = 27, width = 26, height =  6 }
+      }, screen.win_position)
+    end)
+    command('wincmd h')
+    command('q')
+    screen:expect([[
+    ## grid 1
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      {11:[No Name]                                            }|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      {12:[No Name]                                            }|
+                                                           |
+    ## grid 2
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ## grid 4
+      ^                                                     |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ]], nil, nil, function()
+      eq({
+        [2] = { win = 1000, startrow = 7, startcol = 0, width = 53, height =  5 },
+        [4] = { win = 1002, startrow = 0, startcol = 0, width = 53, height =  6 }
+      }, screen.win_position)
+    end)
+  end)
+
+  describe('split', function ()
+    describe('horizontally', function ()
+      it('allocates grids', function ()
+        command('sp')
+        screen:expect([[
+        ## grid 1
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          {11:[No Name]                                            }|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          {12:[No Name]                                            }|
+                                                               |
+        ## grid 2
+                                                               |
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ## grid 3
+          ^                                                     |
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ]])
+      end)
+
+      it('resizes grids', function ()
+        command('sp')
+        command('resize 8')
+        screen:expect([[
+        ## grid 1
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          {11:[No Name]                                            }|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          {12:[No Name]                                            }|
+                                                               |
+        ## grid 2
+                                                               |
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ## grid 3
+          ^                                                     |
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ]])
+      end)
+
+      it('splits vertically', function()
+        command('sp')
+        command('vsp')
+        command('vsp')
+        screen:expect([[
+        ## grid 1
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          {11:[No Name]            }{12:[No Name]        [No Name]      }|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          {12:[No Name]                                            }|
+                                                               |
+        ## grid 2
+                                                               |
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ## grid 3
+                         |
+          {1:~              }|
+          {1:~              }|
+          {1:~              }|
+          {1:~              }|
+          {1:~              }|
+        ## grid 4
+                          |
+          {1:~               }|
+          {1:~               }|
+          {1:~               }|
+          {1:~               }|
+          {1:~               }|
+        ## grid 5
+          ^                    |
+          {1:~                   }|
+          {1:~                   }|
+          {1:~                   }|
+          {1:~                   }|
+          {1:~                   }|
+        ]])
+        insert('hello')
+        screen:expect([[
+        ## grid 1
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          [5:--------------------]{12:│}[4:----------------]{12:│}[3:---------------]|
+          {11:[No Name] [+]        }{12:[No Name] [+]    [No Name] [+]  }|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          {12:[No Name] [+]                                        }|
+                                                               |
+        ## grid 2
+          hello                                                |
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ## grid 3
+          hello          |
+          {1:~              }|
+          {1:~              }|
+          {1:~              }|
+          {1:~              }|
+          {1:~              }|
+        ## grid 4
+          hello           |
+          {1:~               }|
+          {1:~               }|
+          {1:~               }|
+          {1:~               }|
+          {1:~               }|
+        ## grid 5
+          hell^o               |
+          {1:~                   }|
+          {1:~                   }|
+          {1:~                   }|
+          {1:~                   }|
+          {1:~                   }|
+        ]])
+      end)
+      it('closes splits', function ()
+        command('sp')
+        screen:expect([[
+        ## grid 1
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          [3:-----------------------------------------------------]|
+          {11:[No Name]                                            }|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          {12:[No Name]                                            }|
+                                                               |
+        ## grid 2
+                                                               |
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ## grid 3
+          ^                                                     |
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ]])
+        command('q')
+        screen:expect([[
+        ## grid 1
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          {11:[No Name]                                            }|
+                                                               |
+        ## grid 2
+          ^                                                     |
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ]])
+      end)
+    end)
+
+    describe('vertically', function ()
+      it('allocates grids', function ()
+        command('vsp')
+        screen:expect([[
+        ## grid 1
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          {11:[No Name]                  }{12:[No Name]                 }|
+                                                               |
+        ## grid 2
+                                    |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ## grid 3
+          ^                          |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ]])
+      end)
+      it('resizes grids', function ()
+        command('vsp')
+        command('vertical resize 10')
+        -- see "Note 1" for info about why there are two vseps
+        screen:expect([[
+        ## grid 1
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          [3:----------]{12:│}[2:------------------------------------------]|
+          {11:<No Name]  }{12:[No Name]                                 }|
+                                                               |
+        ## grid 2
+                                                    |
+          {1:~                                         }|
+          {1:~                                         }|
+          {1:~                                         }|
+          {1:~                                         }|
+          {1:~                                         }|
+          {1:~                                         }|
+          {1:~                                         }|
+          {1:~                                         }|
+          {1:~                                         }|
+          {1:~                                         }|
+          {1:~                                         }|
+        ## grid 3
+          ^          |
+          {1:~         }|
+          {1:~         }|
+          {1:~         }|
+          {1:~         }|
+          {1:~         }|
+          {1:~         }|
+          {1:~         }|
+          {1:~         }|
+          {1:~         }|
+          {1:~         }|
+          {1:~         }|
+        ]])
+      end)
+      it('splits horizontally', function ()
+        command('vsp')
+        command('sp')
+        screen:expect([[
+        ## grid 1
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          {11:[No Name]                 }{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          {12:[No Name]                  [No Name]                 }|
+                                                               |
+        ## grid 2
+                                    |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ## grid 3
+                                    |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ## grid 4
+          ^                          |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ]])
+        insert('hello')
+        screen:expect([[
+        ## grid 1
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          [4:--------------------------]{12:│}[2:--------------------------]|
+          {11:[No Name] [+]             }{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          {12:[No Name] [+]              [No Name] [+]             }|
+                                                               |
+        ## grid 2
+          hello                     |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ## grid 3
+          hello                     |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ## grid 4
+          hell^o                     |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ]])
+      end)
+      it('closes splits', function ()
+        command('vsp')
+        screen:expect([[
+        ## grid 1
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          [3:--------------------------]{12:│}[2:--------------------------]|
+          {11:[No Name]                  }{12:[No Name]                 }|
+                                                               |
+        ## grid 2
+                                    |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ## grid 3
+          ^                          |
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+          {1:~                         }|
+        ]])
+        command('q')
+        screen:expect([[
+        ## grid 1
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          [2:-----------------------------------------------------]|
+          {11:[No Name]                                            }|
+                                                               |
+        ## grid 2
+          ^                                                     |
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+          {1:~                                                    }|
+        ]])
+      end)
+    end)
+  end)
+
+  describe('on resize', function ()
+    it('rebuilds all grids', function ()
+      screen:try_resize(25, 6)
+      screen:expect([[
+      ## grid 1
+        [2:-------------------------]|
+        [2:-------------------------]|
+        [2:-------------------------]|
+        [2:-------------------------]|
+        {11:[No Name]                }|
+                                 |
+      ## grid 2
+        ^                         |
+        {1:~                        }|
+        {1:~                        }|
+        {1:~                        }|
+      ]])
+    end)
+
+    it('has minimum width/height values', function()
+      screen:try_resize(1, 1)
+      screen:expect([[
+      ## grid 1
+        [2:------------]|
+        {11:[No Name]   }|
+                    |
+      ## grid 2
+        ^            |
+      ]])
+
+      feed('<esc>:ls')
+      screen:expect([[
+      ## grid 1
+        [2:------------]|
+        {11:[No Name]   }|
+        :ls^         |
+      ## grid 2
+                    |
+      ]])
+    end)
+  end)
+
+  describe('grid of smaller inner size', function()
+    it('is rendered correctly', function()
+      screen:try_resize_grid(2, 8, 5)
+      screen:expect([[
+      ## grid 1
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        {11:[No Name]                                            }|
+                                                             |
+      ## grid 2
+        ^        |
+        {1:~       }|
+        {1:~       }|
+        {1:~       }|
+        {1:~       }|
+      ]])
+    end)
+  end)
+
+  describe('grid of bigger inner size', function()
+    it('is rendered correctly', function()
+      screen:try_resize_grid(2, 80, 20)
+      screen:expect([[
+      ## grid 1
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        {11:[No Name]                                            }|
+                                                             |
+      ## grid 2
+        ^                                                                                |
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+        {1:~                                                                               }|
+      ]])
+    end)
+  end)
+
+
+  describe('with resized grid', function()
+    before_each(function()
+      screen:try_resize_grid(2, 60, 20)
+    end)
+    it('gets written till grid width', function()
+      insert(('a'):rep(60).."\n")
+      screen:expect([[
+      ## grid 1
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        {11:[No Name] [+]                                        }|
+                                                             |
+      ## grid 2
+        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa|
+        ^                                                            |
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+      ]])
+    end)
+
+    it('wraps with grid width', function()
+      insert(('b'):rep(80).."\n")
+      screen:expect([[
+      ## grid 1
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        {11:[No Name] [+]                                        }|
+                                                             |
+      ## grid 2
+        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb|
+        bbbbbbbbbbbbbbbbbbbb                                        |
+        ^                                                            |
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+      ]])
+    end)
+
+    it('displays messages with default grid width', function()
+      command('echomsg "this is a very very very very very very very very'..
+        ' long message"')
+      screen:expect([[
+      ## grid 1
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        {11:[No Name]                                            }|
+        this is a very very very...ry very very long message |
+      ## grid 2
+        ^                                                            |
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+      ]])
+    end)
+
+    it('creates folds with grid width', function()
+      insert('this is a fold\nthis is inside fold\nthis is outside fold')
+      feed('kzfgg')
+      screen:expect([[
+      ## grid 1
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        [2:-----------------------------------------------------]|
+        {11:[No Name] [+]                                        }|
+                                                             |
+      ## grid 2
+        {13:^+--  2 lines: this is a fold································}|
+        this is outside fold                                        |
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+        {1:~                                                           }|
+      ]])
+    end)
+  end)
+
+  it('multiline messages scroll over windows', function()
+    command('sp')
+    command('vsp')
+    screen:expect([[
+    ## grid 1
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      {11:[No Name]                  }{12:[No Name]                 }|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      {12:[No Name]                                            }|
+                                                           |
+    ## grid 2
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ## grid 3
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+      ^                          |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ]])
+
+    feed(":echoerr 'very' | echoerr 'much' | echoerr 'fail'<cr>")
+    screen:expect([[
+    ## grid 1
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      {11:[No Name]                  }{12:[No Name]                 }|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      {11:                                                     }|
+      {14:very}                                                 |
+      {14:much}                                                 |
+      {14:fail}                                                 |
+      {15:Press ENTER or type command to continue}^              |
+    ## grid 2
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ## grid 3
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ]])
+
+    feed('<cr>')
+    screen:expect([[
+    ## grid 1
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      {11:[No Name]                  }{12:[No Name]                 }|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      {12:[No Name]                                            }|
+                                                           |
+    ## grid 2
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ## grid 3
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+      ^                          |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ]])
+
+    command([[
+      func! ErrMsg()
+        for i in range(11)
+          echoerr "error ".i
+        endfor
+      endfunc]])
+    feed(":call ErrMsg()<cr>")
+    screen:expect([[
+    ## grid 1
+      {14:Error detected while processing function ErrMsg:}     |
+      {19:line    2:}                                           |
+      {14:error 0}                                              |
+      {14:error 1}                                              |
+      {14:error 2}                                              |
+      {14:error 3}                                              |
+      {14:error 4}                                              |
+      {14:error 5}                                              |
+      {14:error 6}                                              |
+      {14:error 7}                                              |
+      {14:error 8}                                              |
+      {14:error 9}                                              |
+      {14:error 10}                                             |
+      {15:Press ENTER or type command to continue}^              |
+    ## grid 2
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ## grid 3
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ]])
+
+    feed("<c-c>")
+    screen:expect([[
+    ## grid 1
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      [4:--------------------------]{12:│}[3:--------------------------]|
+      {11:[No Name]                  }{12:[No Name]                 }|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      [2:-----------------------------------------------------]|
+      {12:[No Name]                                            }|
+                                                           |
+    ## grid 2
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ## grid 3
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+      ^                          |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ]])
+  end)
+
+  it('handles switich tabs', function()
+    command('vsp')
+    screen:expect([[
+    ## grid 1
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      {11:[No Name]                  }{12:[No Name]                 }|
+                                                           |
+    ## grid 2
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 3
+      ^                          |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ]])
+
+
+    command('tabnew')
+    -- note the old grids aren't resized yet
+    screen:expect([[
+    ## grid 1
+      {16: }{17:2}{16: [No Name] }{7: [No Name] }{12:                            }{16:X}|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      {11:[No Name]                                            }|
+                                                           |
+    ## grid 2
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 3
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+      ^                                                     |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ]])
+
+    command('sp')
+    screen:expect([[
+    ## grid 1
+      {16: }{17:2}{16: [No Name] }{7: }{18:2}{7: [No Name] }{12:                          }{16:X}|
+      [5:-----------------------------------------------------]|
+      [5:-----------------------------------------------------]|
+      [5:-----------------------------------------------------]|
+      [5:-----------------------------------------------------]|
+      [5:-----------------------------------------------------]|
+      {11:[No Name]                                            }|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      {12:[No Name]                                            }|
+                                                           |
+    ## grid 2
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 3
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ## grid 5
+      ^                                                     |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ]])
+
+    command('tabnext')
+    screen:expect([[
+    ## grid 1
+      {7: }{18:2}{7: [No Name] }{16: }{17:2}{16: [No Name] }{12:                          }{16:X}|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      {11:[No Name]                  }{12:[No Name]                 }|
+                                                           |
+    ## grid 2
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 3
+      ^                          |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ## grid 5
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ]])
+
+    command('tabnext')
+    screen:expect([[
+    ## grid 1
+      {16: }{17:2}{16: [No Name] }{7: }{18:2}{7: [No Name] }{12:                          }{16:X}|
+      [5:-----------------------------------------------------]|
+      [5:-----------------------------------------------------]|
+      [5:-----------------------------------------------------]|
+      [5:-----------------------------------------------------]|
+      [5:-----------------------------------------------------]|
+      {11:[No Name]                                            }|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      [4:-----------------------------------------------------]|
+      {12:[No Name]                                            }|
+                                                           |
+    ## grid 2
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 3
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 4
+                                                           |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ## grid 5
+      ^                                                     |
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+      {1:~                                                    }|
+    ]])
+
+    command('tabclose')
+    screen:expect([[
+    ## grid 1
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      [3:--------------------------]{12:│}[2:--------------------------]|
+      {11:[No Name]                  }{12:[No Name]                 }|
+                                                           |
+    ## grid 2
+                                |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ## grid 3
+      ^                          |
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+      {1:~                         }|
+    ]])
+  end)
+end)
diff --git a/test/functional/ui/options_spec.lua b/test/functional/ui/options_spec.lua
index 32e8faf7d3..c26fa5e29b 100644
--- a/test/functional/ui/options_spec.lua
+++ b/test/functional/ui/options_spec.lua
@@ -26,6 +26,7 @@ describe('ui receives option updates', function()
       ext_wildmenu=false,
       ext_linegrid=false,
       ext_hlstate=false,
+      ext_multigrid=false,
     }
 
     clear(...)
diff --git a/test/functional/ui/screen.lua b/test/functional/ui/screen.lua
index 75eb5bb4e3..69f4a44dd8 100644
--- a/test/functional/ui/screen.lua
+++ b/test/functional/ui/screen.lua
@@ -75,9 +75,11 @@ local global_helpers = require('test.helpers')
 local deepcopy = global_helpers.deepcopy
 local shallowcopy = global_helpers.shallowcopy
 local helpers = require('test.functional.helpers')(nil)
-local request, run, uimeths = helpers.request, helpers.run, helpers.uimeths
+local request, run_session = helpers.request, helpers.run_session
 local eq = helpers.eq
 local dedent = helpers.dedent
+local get_session = helpers.get_session
+local create_callindex = helpers.create_callindex
 
 local inspect = require('inspect')
 
@@ -155,6 +157,8 @@ function Screen.new(width, height)
     cmdline_block = {},
     wildmenu_items = nil,
     wildmenu_selected = nil,
+    win_position = {},
+    _session = nil,
     _default_attr_ids = nil,
     _default_attr_ignore = nil,
     _mouse_enabled = true,
@@ -165,11 +169,19 @@ function Screen.new(width, height)
     _new_attrs = false,
     _width = width,
     _height = height,
+    _grids = {},
     _cursor = {
-      row = 1, col = 1
+      grid = 1, row = 1, col = 1
     },
-    _busy = false
+    _busy = false,
   }, Screen)
+  local function ui(method, ...)
+    local status, rv = self._session:request('nvim_ui_'..method, ...)
+    if not status then
+      error(rv[2])
+    end
+  end
+  self.uimeths = create_callindex(ui)
   return self
 end
 
@@ -189,34 +201,50 @@ function Screen:set_hlstate_cterm(val)
   self._hlstate_cterm = val
 end
 
-function Screen:attach(options)
+function Screen:attach(options, session)
+  if session == nil then
+    session = get_session()
+  end
   if options == nil then
     options = {}
   end
   if options.ext_linegrid == nil then
     options.ext_linegrid = true
   end
+
+  self._session = session
   self._options = options
   self._clear_attrs = (options.ext_linegrid and {{},{}}) or {}
   self:_handle_resize(self._width, self._height)
-  uimeths.attach(self._width, self._height, options)
+  self.uimeths.attach(self._width, self._height, options)
   if self._options.rgb == nil then
     -- nvim defaults to rgb=true internally,
     -- simplify test code by doing the same.
     self._options.rgb = true
   end
+  if self._options.ext_multigrid then
+    self._options.ext_linegrid = true
+  end
+  self._session = session
 end
 
 function Screen:detach()
-  uimeths.detach()
+  self.uimeths.detach()
+  self._session = nil
 end
 
 function Screen:try_resize(columns, rows)
-  uimeths.try_resize(columns, rows)
+  self._width = columns
+  self._height = rows
+  self.uimeths.try_resize(columns, rows)
+end
+
+function Screen:try_resize_grid(grid, columns, rows)
+  self.uimeths.try_resize_grid(grid, columns, rows)
 end
 
 function Screen:set_option(option, value)
-  uimeths.set_option(option, value)
+  self.uimeths.set_option(option, value)
   self._options[option] = value
 end
 
@@ -321,7 +349,6 @@ function Screen:expect(expected, attr_ids, attr_ignore)
     -- value.
     grid = dedent(grid:gsub('\n[ ]+$', ''), 0)
     for row in grid:gmatch('[^\n]+') do
-      row = row:sub(1, #row - 1) -- Last char must be the screen delimiter.
       table.insert(expected_rows, row)
     end
   end
@@ -341,19 +368,11 @@ function Screen:expect(expected, attr_ids, attr_ignore)
       end
     end
 
-    if grid ~= nil and self._height ~= #expected_rows then
-      return ("Expected screen state's row count(" .. #expected_rows
-              .. ') differs from configured height(' .. self._height .. ') of Screen.')
-    end
-
     if self._options.ext_hlstate and self._new_attrs then
       attr_state.id_to_index = self:hlstate_check_attrs(attr_state.ids or {})
     end
 
-    local actual_rows = {}
-    for i = 1, self._height do
-      actual_rows[i] = self:_row_repr(self._rows[i], attr_state)
-    end
+    local actual_rows = self:render(not expected.any, attr_state)
 
     if expected.any ~= nil then
       -- Search for `any` anywhere in the screen lines.
@@ -362,13 +381,17 @@ function Screen:expect(expected, attr_ids, attr_ignore)
         return (
           'Failed to match any screen lines.\n'
           .. 'Expected (anywhere): "' .. expected.any .. '"\n'
-          .. 'Actual:\n  |' .. table.concat(actual_rows, '|\n  |') .. '|\n\n')
+          .. 'Actual:\n  |' .. table.concat(actual_rows, '\n  |') .. '\n\n')
       end
     end
 
     if grid ~= nil then
       -- `expected` must match the screen lines exactly.
-      for i = 1, self._height do
+      if #actual_rows ~= #expected_rows then
+        return "Expected screen state's row count(" .. #expected_rows
+        .. ') differs from configured height(' .. #actual_rows .. ') of Screen.'
+      end
+      for i = 1, #actual_rows do
         if expected_rows[i] ~= actual_rows[i] then
           local msg_expected_rows = {}
           for j = 1, #expected_rows do
@@ -378,8 +401,8 @@ function Screen:expect(expected, attr_ids, attr_ignore)
           actual_rows[i] = '*' .. actual_rows[i]
           return (
             'Row ' .. tostring(i) .. ' did not match.\n'
-            ..'Expected:\n  |'..table.concat(msg_expected_rows, '|\n  |')..'|\n'
-            ..'Actual:\n  |'..table.concat(actual_rows, '|\n  |')..'|\n\n'..[[
+            ..'Expected:\n  |'..table.concat(msg_expected_rows, '\n  |')..'\n'
+            ..'Actual:\n  |'..table.concat(actual_rows, '\n  |')..'\n\n'..[[
 To print the expect() call that would assert the current screen state, use
 screen:snapshot_util(). In case of non-deterministic failures, use
 screen:redraw_debug() to show all intermediate screen states.  ]])
@@ -465,7 +488,7 @@ function Screen:_wait(check, flags)
     if not err then
       success_seen = true
       if did_miminal_timeout then
-        helpers.stop()
+        self._session:stop()
       end
     elseif success_seen and #args > 0 then
       failure_after_success = true
@@ -474,7 +497,7 @@ function Screen:_wait(check, flags)
 
     return true
   end
-  run(nil, notification_cb, nil, minimal_timeout)
+  run_session(self._session, nil, notification_cb, nil, minimal_timeout)
   if not did_flush then
     err = "no flush received"
   elseif not checked then
@@ -487,7 +510,7 @@ function Screen:_wait(check, flags)
 
   if not success_seen then
     did_miminal_timeout = true
-    run(nil, notification_cb, nil, timeout-minimal_timeout)
+    run_session(self._session, nil, notification_cb, nil, timeout-minimal_timeout)
   end
 
   local did_warn = false
@@ -547,7 +570,7 @@ function Screen:sleep(ms)
     assert(method == 'redraw')
     self:_redraw(args)
   end
-  run(nil, notification_cb, nil, ms)
+  run_session(self._session, nil, notification_cb, nil, ms)
 end
 
 function Screen:_redraw(updates)
@@ -579,6 +602,22 @@ function Screen:set_on_event_handler(callback)
 end
 
 function Screen:_handle_resize(width, height)
+  self:_handle_grid_resize(1, width, height)
+  self._scroll_region = {
+    top = 1, bot = height, left = 1, right = width
+  }
+  self._grid = self._grids[1]
+end
+
+local function min(x,y)
+  if x < y then
+    return x
+  else
+    return y
+  end
+end
+
+function Screen:_handle_grid_resize(grid, width, height)
   local rows = {}
   for _ = 1, height do
     local cols = {}
@@ -587,22 +626,36 @@ function Screen:_handle_resize(width, height)
     end
     table.insert(rows, cols)
   end
-  self._cursor.row = 1
-  self._cursor.col = 1
-  self._rows = rows
-  self._width = width
-  self._height = height
-  self._scroll_region = {
-    top = 1, bot = height, left = 1, right = width
+  if grid > 1 and self._grids[grid] ~= nil then
+    local old = self._grids[grid]
+    for i = 1, min(height,old.height) do
+      for j = 1, min(width,old.width) do
+        rows[i][j] = old.rows[i][j]
+      end
+    end
+  end
+
+  if self._cursor.grid == grid then
+    self._cursor.row = 1
+    self._cursor.col = 1
+  end
+  self._grids[grid] = {
+    rows=rows,
+    width=width,
+    height=height,
   }
 end
 
-function Screen:_handle_flush()
+function Screen:_handle_win_scroll_over_start()
+   self.scroll_over = true
+   self.scroll_over_pos = self._grids[1].height
 end
 
-function Screen:_handle_grid_resize(grid, width, height)
-  assert(grid == 1)
-  self:_handle_resize(width, height)
+function Screen:_handle_win_scroll_over_reset()
+   self.scroll_over = false
+end
+
+function Screen:_handle_flush()
 end
 
 function Screen:_reset()
@@ -641,20 +694,27 @@ function Screen:_handle_clear()
   -- newer clients, to check we remain compatible with both kind of clients,
   -- ensure the scroll region is in a reset state.
   local expected_region = {
-    top = 1, bot = self._height, left = 1, right = self._width
+    top = 1, bot = self._grid.height, left = 1, right = self._grid.width
   }
   eq(expected_region, self._scroll_region)
-  self:_clear_block(1, self._height, 1, self._width)
+  self:_handle_grid_clear(1)
 end
 
 function Screen:_handle_grid_clear(grid)
-  assert(grid == 1)
-  self:_clear_block(1, self._height, 1, self._width)
+  self:_clear_block(self._grids[grid], 1, self._grids[grid].height, 1, self._grids[grid].width)
+end
+
+function Screen:_handle_grid_destroy(grid)
+  self._grids[grid] = nil
+  if self._options.ext_multigrid then
+    assert(self.win_position[grid])
+    self.win_position[grid] = nil
+  end
 end
 
 function Screen:_handle_eol_clear()
   local row, col = self._cursor.row, self._cursor.col
-  self:_clear_block(row, row, col, self._scroll_region.right)
+  self:_clear_block(self._grid, row, row, col, self._grid.width)
 end
 
 function Screen:_handle_cursor_goto(row, col)
@@ -663,7 +723,7 @@ function Screen:_handle_cursor_goto(row, col)
 end
 
 function Screen:_handle_grid_cursor_goto(grid, row, col)
-  assert(grid == 1)
+  self._cursor.grid = grid
   self._cursor.row = row + 1
   self._cursor.col = col + 1
 end
@@ -704,13 +764,18 @@ function Screen:_handle_scroll(count)
   self:_handle_grid_scroll(1, top-1, bot, left-1, right, count, 0)
 end
 
-function Screen:_handle_grid_scroll(grid, top, bot, left, right, rows, cols)
+function Screen:_handle_grid_scroll(g, top, bot, left, right, rows, cols)
+  if self.scroll_over and g == 1 and top < self.scroll_over_pos then
+    self.scroll_over_pos = top
+  end
+
   top = top+1
   left = left+1
-  assert(grid == 1)
   assert(cols == 0)
+  local grid = self._grids[g]
   local start, stop, step
 
+
   if rows > 0 then
     start = top
     stop = bot - rows
@@ -723,8 +788,8 @@ function Screen:_handle_grid_scroll(grid, top, bot, left, right, rows, cols)
 
   -- shift scroll region
   for i = start, stop, step do
-    local target = self._rows[i]
-    local source = self._rows[i + rows]
+    local target = grid.rows[i]
+    local source = grid.rows[i + rows]
     for j = left, right do
       target[j].text = source[j].text
       target[j].attrs = source[j].attrs
@@ -734,7 +799,7 @@ function Screen:_handle_grid_scroll(grid, top, bot, left, right, rows, cols)
 
   -- clear invalid rows
   for i = stop + step, stop + rows, step do
-    self:_clear_row_section(i, left, right)
+    self:_clear_row_section(grid, i, left, right)
   end
 end
 
@@ -744,13 +809,35 @@ function Screen:_handle_hl_attr_define(id, rgb_attrs, cterm_attrs, info)
   self._new_attrs = true
 end
 
+function Screen:_handle_win_pos(grid, win, startrow, startcol, width, height)
+    self.win_position[grid] = {
+        win = win,
+        startrow = startrow,
+        startcol = startcol,
+        width = width,
+        height = height
+    }
+end
+
+function Screen:_handle_win_hide(grid)
+  self.win_position[grid] = nil
+end
+
+function Screen:get_hl(val)
+  if self._options.ext_newgrid then
+    return self._attr_table[val][1]
+  else
+    return val
+  end
+end
+
 function Screen:_handle_highlight_set(attrs)
   self._attrs = attrs
 end
 
 function Screen:_handle_put(str)
   assert(not self._options.ext_linegrid)
-  local cell = self._rows[self._cursor.row][self._cursor.col]
+  local cell = self._grid.rows[self._cursor.row][self._cursor.col]
   cell.text = str
   cell.attrs = self._attrs
   cell.hl_id = -1
@@ -759,8 +846,7 @@ end
 
 function Screen:_handle_grid_line(grid, row, col, items)
   assert(self._options.ext_linegrid)
-  assert(grid == 1)
-  local line = self._rows[row+1]
+  local line = self._grids[grid].rows[row+1]
   local colpos = col+1
   local hl = self._clear_attrs
   local hl_id = 0
@@ -887,45 +973,68 @@ function Screen:_handle_wildmenu_hide()
   self.wildmenu_items, self.wildmenu_pos = nil, nil
 end
 
-function Screen:_clear_block(top, bot, left, right)
+function Screen:_clear_block(grid, top, bot, left, right)
   for i = top, bot do
-    self:_clear_row_section(i, left, right)
+    self:_clear_row_section(grid, i, left, right)
   end
 end
 
-function Screen:_clear_row_section(rownum, startcol, stopcol)
-  local row = self._rows[rownum]
+function Screen:_clear_row_section(grid, rownum, startcol, stopcol)
+  local row = grid.rows[rownum]
   for i = startcol, stopcol do
     row[i].text = ' '
     row[i].attrs = self._clear_attrs
   end
 end
 
-function Screen:_row_repr(row, attr_state)
+function Screen:_row_repr(gridnr, rownr, attr_state, cursor)
   local rv = {}
   local current_attr_id
-  for i = 1, self._width do
-    local attrs = row[i].attrs
-    if self._options.ext_linegrid then
-      attrs = attrs[(self._options.rgb and 1) or 2]
-    end
-    local attr_id = self:_get_attr_id(attr_state, attrs, row[i].hl_id)
-    if current_attr_id and attr_id ~= current_attr_id then
-      -- close current attribute bracket, add it before any whitespace
-      -- up to the current cell
-      -- table.insert(rv, backward_find_meaningful(rv, i), '}')
-      table.insert(rv, '}')
-      current_attr_id = nil
-    end
-    if not current_attr_id and attr_id then
-      -- open a new attribute bracket
-      table.insert(rv, '{' .. attr_id .. ':')
-      current_attr_id = attr_id
+  local i = 1
+  local has_windows = self._options.ext_multigrid and gridnr == 1
+  if self.scroll_over and self.scroll_over_pos < rownr then
+    has_windows = false
+  end
+  local row = self._grids[gridnr].rows[rownr]
+  while i <= #row do
+    local did_window = false
+    if has_windows then
+      for id,pos in pairs(self.win_position) do
+        if i-1 == pos.startcol and pos.startrow <= rownr-1 and rownr-1 < pos.startrow + pos.height then
+          if current_attr_id then
+            -- close current attribute bracket
+            table.insert(rv, '}')
+            current_attr_id = nil
+          end
+          table.insert(rv, '['..id..':'..string.rep('-',pos.width)..']')
+          i = i + pos.width
+          did_window = true
+        end
+      end
     end
-    if not self._busy and self._rows[self._cursor.row] == row and self._cursor.col == i then
-      table.insert(rv, '^')
+
+    if not did_window then
+      local attrs = row[i].attrs
+      if self._options.ext_linegrid then
+        attrs = attrs[(self._options.rgb and 1) or 2]
+      end
+      local attr_id = self:_get_attr_id(attr_state, attrs, row[i].hl_id)
+      if current_attr_id and attr_id ~= current_attr_id then
+        -- close current attribute bracket
+        table.insert(rv, '}')
+        current_attr_id = nil
+      end
+      if not current_attr_id and attr_id then
+        -- open a new attribute bracket
+        table.insert(rv, '{' .. attr_id .. ':')
+        current_attr_id = attr_id
+      end
+      if not self._busy and cursor and self._cursor.col == i then
+        table.insert(rv, '^')
+      end
+      table.insert(rv, row[i].text)
+      i = i + 1
     end
-    table.insert(rv, row[i].text)
   end
   if current_attr_id then
     table.insert(rv, '}')
@@ -997,7 +1106,23 @@ function Screen:redraw_debug(attrs, ignore, timeout)
   if timeout == nil then
     timeout = 250
   end
-  run(nil, notification_cb, nil, timeout)
+  run_session(self._session, nil, notification_cb, nil, timeout)
+end
+
+function Screen:render(headers, attr_state, preview)
+  headers = headers and self._options.ext_multigrid
+  local rv = {}
+  for igrid,grid in pairs(self._grids) do
+    if headers then
+      table.insert(rv, "## grid "..igrid)
+    end
+    for i = 1, grid.height do
+      local cursor = self._cursor.grid == igrid and self._cursor.row == i
+      local prefix = (headers or preview) and "  " or ""
+      table.insert(rv, prefix..self:_row_repr(igrid, i, attr_state, cursor).."|")
+    end
+  end
+  return rv
 end
 
 function Screen:print_snapshot(attrs, ignore)
@@ -1020,10 +1145,7 @@ function Screen:print_snapshot(attrs, ignore)
     attr_state.id_to_index = self:hlstate_check_attrs(attr_state.ids)
   end
 
-  local lines = {}
-  for i = 1, self._height do
-    table.insert(lines, "  "..self:_row_repr(self._rows[i], attr_state).."|")
-  end
+  local lines = self:render(true, attr_state, true)
 
   local ext_state = self:_extstate_repr(attr_state)
   local keys = false
diff --git a/test/functional/ui/wildmode_spec.lua b/test/functional/ui/wildmode_spec.lua
index 8931d9245b..ffe71cfadf 100644
--- a/test/functional/ui/wildmode_spec.lua
+++ b/test/functional/ui/wildmode_spec.lua
@@ -165,7 +165,7 @@ describe("'wildmenu'", function()
     feed([[:<Tab>]])      -- Invoke wildmenu.
     -- Check only the last 2 lines, because the shell output is
     -- system-dependent.
-    expect_stay_unchanged{any='!  #  &  <  =  >  @  >   \n:!^'}
+    expect_stay_unchanged{any='!  #  &  <  =  >  @  >   |\n:!^'}
   end)
 end)
 
diff --git a/test/helpers.lua b/test/helpers.lua
index 6ef7a456f4..a6ed312213 100644
--- a/test/helpers.lua
+++ b/test/helpers.lua
@@ -49,8 +49,8 @@ local check_logs_useless_lines = {
 local function eq(expected, actual, ctx)
   return assert.are.same(expected, actual, ctx)
 end
-local function neq(expected, actual)
-  return assert.are_not.same(expected, actual)
+local function neq(expected, actual, context)
+  return assert.are_not.same(expected, actual, context)
 end
 local function ok(res)
   return assert.is_true(res)