diff --git a/bview.c b/bview.c
index 4031c25..fe4ea68 100644
--- a/bview.c
+++ b/bview.c
@@ -4,7 +4,7 @@
 #include "mle.h"
 
 static int _bview_pop_kmap(bview_t *bview, kmap_t **optret_kmap, int allow_pop_root);
-static int _bview_rectify_viewport_dim(bview_t *self, bline_t *bline, bint_t vpos, int dim_scope, int dim_size, bint_t *view_vpos);
+static int _bview_viewport_rectify_dim(bint_t w, int scope, int size, bint_t *inout_viewport_w);
 static void _bview_init(bview_t *self, buffer_t *buffer);
 static void _bview_init_resized(bview_t *self);
 static kmap_t *_bview_get_init_kmap(editor_t *editor);
@@ -17,9 +17,13 @@ static buffer_t *_bview_open_buffer(bview_t *self, char *opt_path, int opt_path_
 static void _bview_draw_prompt(bview_t *self);
 static void _bview_draw_status(bview_t *self);
 static void _bview_draw_edit(bview_t *self, int x, int y, int w, int h);
-static void _bview_draw_bline(bview_t *self, bline_t *bline, int rect_y, bline_t **optret_bline, int *optret_rect_y);
+static void _bview_draw_bline(bview_t *self, bline_t **inout_bline, bint_t col, int *inout_rect_y);
 static void _bview_highlight_bracket_pair(bview_t *self, mark_t *mark);
-static bint_t _bview_get_viewport_col(bview_t *self, bline_t *bline);
+static int _bview_rect_to_bline_col(bview_t *self, int rx, int ry, bline_t **ret_bline, bint_t *ret_col);
+static int _bview_wrow_to_bline(bview_t *self, bint_t wrow, bline_t **ret_bline, bint_t *ret_bline_wrow, bint_t *ret_bline_wend);
+static int _bview_mark_to_wcoord(bview_t *self, mark_t *mark, bint_t *ret_wcol, bint_t *ret_wrow);
+static int _bview_bline_col_to_wcoord(bview_t *self, bline_t *bline, bint_t col, bint_t *ret_wcol, bint_t *ret_wrow);
+static bint_t _bview_get_viewport_vcol(bview_t *self, bline_t *bline);
 static int _bview_is_cursor_line(bview_t *self, bline_t *bline);
 static int _bview_get_soft_wrap_type(bview_t *self, bline_t *bline);
 static int _bview_is_in_range(bline_t *bline, bint_t col, int is_block, srule_t **ret_srule);
@@ -148,7 +152,7 @@ int bview_resize(bview_t *self, int x, int y, int w, int h) {
         self->is_resized = 1;
     }
 
-    bview_rectify_viewport(self);
+    bview_viewport_rectify(self);
 
     return MLE_OK;
 }
@@ -236,7 +240,7 @@ int bview_split(bview_t *self, int is_vertical, float factor, bview_t **optret_b
 
     // Move cursor to same position
     mark_move_to(child->active_cursor->mark, self->active_cursor->mark->bline->line_index, self->active_cursor->mark->col);
-    bview_center_viewport_y(child);
+    bview_viewport_center(child);
 
     // Resize self
     bview_resize(self, self->x, self->y, self->w, self->h);
@@ -333,57 +337,57 @@ int bview_remove_cursor(bview_t *self, cursor_t *cursor) {
 }
 
 // Set viewport y safely
-int bview_set_viewport_y(bview_t *self, bint_t y, int do_rectify) {
-    if (y < 0) {
-        y = 0;
-    } else if (y >= self->buffer->line_count) {
-        y = self->buffer->line_count - 1;
-    }
-    mark_move_to(self->viewport_mark, y, 0);
-    if (do_rectify) bview_rectify_viewport(self);
+int bview_viewport_set(bview_t *self, bint_t wrow, int do_rectify) {
+    bline_t *last;
+    bint_t max_wrow, ig;
+
+    last = self->buffer->last_line;
+    _bview_bline_col_to_wcoord(self, last, last->char_count, &ig, &max_wrow);
+
+    if (wrow < 0) {
+        wrow = 0;
+    } else if (wrow > max_wrow) {
+        wrow = max_wrow;
+    }
+
+    self->viewport_wrow = wrow;
+    if (do_rectify) bview_viewport_rectify(self);
     return MLE_OK;
 }
 
 // Center the viewport vertically
-int bview_center_viewport_y(bview_t *self) {
-    bint_t center;
-    center = self->active_cursor->mark->bline->line_index - self->rect_buffer.h/2;
-    if (center < 0) center = 0;
-    return bview_set_viewport_y(self, center, 1);
+int bview_viewport_center(bview_t *self) {
+    bint_t wrow, center, ig;
+    _bview_mark_to_wcoord(self, self->active_cursor->mark, &ig, &wrow);
+    center = wrow - self->rect_buffer.h / 2;
+    return bview_viewport_set(self, center, 1);
 }
 
 // Zero the viewport vertically
-int bview_zero_viewport_y(bview_t *self) {
-    return bview_set_viewport_y(self, self->active_cursor->mark->bline->line_index, 1);
+int bview_viewport_zero(bview_t *self) {
+    bint_t wrow, ig;
+    _bview_mark_to_wcoord(self, self->active_cursor->mark, &ig, &wrow);
+    return bview_viewport_set(self, wrow, 1);
 }
 
 // Maximize the viewport vertically
-int bview_max_viewport_y(bview_t *self) {
-    bint_t max;
-    max = self->active_cursor->mark->bline->line_index - self->rect_buffer.h;
-    if (max < 0) max = 0;
-    return bview_set_viewport_y(self, max, 1);
+int bview_viewport_max(bview_t *self) {
+    bint_t wrow, max, ig;
+    _bview_mark_to_wcoord(self, self->active_cursor->mark, &ig, &wrow);
+    max = wrow - self->rect_buffer.h;
+    return bview_viewport_set(self, max, 1);
 }
 
-// Rectify the viewport
-int bview_rectify_viewport(bview_t *self) {
-    mark_t *mark;
-    bint_t viewport_y;
+// Adjust the viewport so the active mark is "in scope" according to self->viewport_scope_*
+int bview_viewport_rectify(bview_t *self) {
+    bint_t cmark_wcol, cmark_wrow;
 
-    mark = self->active_cursor->mark;
-    viewport_y = self->viewport_mark->bline->line_index;
     if (!self->is_resized) return MLE_OK;
 
-    // Rectify each dimension of the viewport
-    MLBUF_BLINE_ENSURE_CHARS(mark->bline);
-    _bview_rectify_viewport_dim(self, mark->bline, MLE_MARK_COL_TO_VCOL(mark), self->viewport_scope_x, self->rect_buffer.w, &self->viewport_vcol);
-    bline_get_col_from_vcol(mark->bline, self->viewport_vcol, &(self->viewport_col));
+    _bview_mark_to_wcoord(self, self->active_cursor->mark, &cmark_wcol, &cmark_wrow);
 
-    if (_bview_rectify_viewport_dim(self, mark->bline, mark->bline->line_index, self->viewport_scope_y, self->rect_buffer.h, &viewport_y)) {
-        // TODO viewport_y_vrow (soft-wrapped lines, code folding, etc)
-        // Adjust viewport_mark
-        mark_move_to(self->viewport_mark, viewport_y, 0);
-    }
+    _bview_viewport_rectify_dim(cmark_wcol, self->viewport_scope_x, self->rect_buffer.w, &self->viewport_vcol);
+    _bview_viewport_rectify_dim(cmark_wrow, self->viewport_scope_y, self->rect_buffer.h, &self->viewport_wrow);
 
     return MLE_OK;
 }
@@ -405,6 +409,17 @@ int bview_destroy_listener(bview_t *self, bview_listener_t *listener) {
     return MLE_OK;
 }
 
+// Move mark to a wcoord
+int bview_mark_move_rect(bview_t *self, mark_t *mark, int rx, int ry) {
+    int rv;
+    bline_t *bline;
+    bint_t col;
+    if ((rv = _bview_rect_to_bline_col(self, rx, ry, &bline, &col)) != MLE_OK) {
+        return rv;
+    }
+    return mark_move_to_w_bline(mark, bline, col);
+}
+
 // Pop a kmap
 static int _bview_pop_kmap(bview_t *bview, kmap_t **optret_kmap, int allow_pop_root) {
     kmap_node_t *node_to_pop;
@@ -421,39 +436,39 @@ static int _bview_pop_kmap(bview_t *bview, kmap_t **optret_kmap, int allow_pop_r
     return MLE_OK;
 }
 
-// Rectify a viewport dimension. Return 1 if changed, else 0.
-static int _bview_rectify_viewport_dim(bview_t *self, bline_t *bline, bint_t vpos, int dim_scope, int dim_size, bint_t *view_vpos) {
-    int rc;
-    bint_t vpos_start;
-    bint_t vpos_stop;
-    (void)self;
-    (void)bline;
+// Given a wcoord dimension `w` (i.e., a wcol or wrow), adjust `viewport_w`
+// (i.e., viewport_vcol or viewport_wrow) such that it satisfies `scope`.
+// (See inline comments below for what `scope` means.) `size` is the relevant
+// rect dimension (i.e., rect_buffer.w or .h). Return 1 if `viewport_w` changed,
+// else 0.
+static int _bview_viewport_rectify_dim(bint_t w, int scope, int size, bint_t *inout_viewport_w) {
+    bint_t start;
+    bint_t stop;
 
     // Find bounds
-    if (dim_scope < 0) {
-        // Keep cursor at least `dim_scope` cells away from edge
-        // Remember dim_scope is negative here
-        dim_scope = MLE_MAX(dim_scope, ((dim_size / 2) * -1));
-        vpos_start = *view_vpos - dim_scope; // N in from left edge
-        vpos_stop = (*view_vpos + dim_size) + dim_scope; // N in from right edge
+    if (scope < 0) {
+        // Keep cursor at least `scope` cells away from dim boundary
+        // Remember `scope` is negative here
+        scope = MLE_MAX(scope, ((size / 2) * -1));
+        start = *inout_viewport_w - scope;         // +N from top/left
+        stop = (*inout_viewport_w + size) + scope; // -N from bottom/right
     } else {
-        // Keep cursor within `dim_scope/2` cells of midpoint
-        dim_scope = MLE_MIN(dim_scope, dim_size);
-        vpos_start = (*view_vpos + (dim_size / 2)) - (int)floorf((float)dim_scope * 0.5); // -N/2 from midpoint
-        vpos_stop = (*view_vpos + (dim_size / 2)) + (int)ceilf((float)dim_scope * 0.5); // +N/2 from midpoint
+        // Keep cursor within `scope/2` cells of midpoint
+        scope = MLE_MIN(scope, size);
+        start = (*inout_viewport_w + (size / 2)) - (int)floorf((float)scope * 0.5); // -N/2 from midpoint
+        stop = (*inout_viewport_w + (size / 2)) + (int)ceilf((float)scope * 0.5);   // +N/2 from midpoint
     }
 
     // Rectify
-    rc = 1;
-    if (vpos < vpos_start) {
-        *view_vpos -= MLE_MIN(*view_vpos, vpos_start - vpos);
-    } else if (vpos >= vpos_stop) {
-        *view_vpos += ((vpos - vpos_stop) + 1);
+    if (w < start) {
+        *inout_viewport_w -= MLE_MIN(*inout_viewport_w, start - w);
+    } else if (w >= stop) {
+        *inout_viewport_w += (w - stop) + 1;
     } else {
-        rc = 0;
+        return 0;
     }
 
-    return rc;
+    return 1;
 }
 
 // Init a bview with a buffer
@@ -481,10 +496,6 @@ static void _bview_init(bview_t *self, buffer_t *buffer) {
 
     // Add a cursor
     bview_add_cursor(self, self->buffer->first_line, 0, &cursor_tmp);
-
-    // Add viewport_mark
-    self->viewport_mark = buffer_add_mark(self->buffer, NULL, 0);
-    self->viewport_mark->lefty = 1; // Stay put at col 0
 }
 
 // Invoked once after a bview has been resized for the first time
@@ -492,7 +503,7 @@ static void _bview_init_resized(bview_t *self) {
     // Move cursor to startup line if present
     if (self->startup_linenum > 0) {
         mark_move_to(self->active_cursor->mark, self->startup_linenum, 0);
-        bview_center_viewport_y(self);
+        bview_viewport_center(self);
     }
 }
 
@@ -522,7 +533,7 @@ static void _bview_buffer_callback(buffer_t *buffer, baction_t *action, void *ud
 
     // Rectify viewport if edit was on active bview
     if (active->buffer == buffer) {
-        bview_rectify_viewport(active);
+        bview_viewport_rectify(active);
     }
 
     if (action && action->line_delta != 0) {
@@ -624,10 +635,6 @@ static void _bview_deinit(bview_t *self) {
         self->buffer = NULL;
     }
 
-    // Unset viewport_mark as it may point to a freed mark at this point if
-    // we are re-using a bview, e.g., after cmd_open_replace_file.
-    self->viewport_mark = NULL;
-
     // Free last_search
     if (self->last_search) {
         free(self->last_search);
@@ -811,7 +818,9 @@ static buffer_t *_bview_open_buffer(bview_t *self, char *opt_path, int opt_path_
 }
 
 static void _bview_draw_prompt(bview_t *self) {
-    _bview_draw_bline(self, self->buffer->first_line, 0, NULL, NULL);
+    int rect_y = 0;
+    bline_t *bline = self->buffer->first_line;
+    _bview_draw_bline(self, &bline, 0, &rect_y);
 }
 
 static void _bview_draw_status(bview_t *self) {
@@ -966,11 +975,9 @@ static void _bview_draw_edit(bview_t *self, int x, int y, int w, int h) {
     int split_h;
     int min_w;
     int min_h;
-    int rect_y;
     int fg_attr;
     int bg_attr;
     bline_t *bline;
-    bint_t viewport_y;
 
     // Handle split
     if (self->split_child) {
@@ -1018,44 +1025,46 @@ static void _bview_draw_edit(bview_t *self, int x, int y, int w, int h) {
     }
 
     // Render lines and margins
-    bline = self->viewport_mark->bline;
-    viewport_y = bline->line_index;
-    for (rect_y = 0; rect_y < self->rect_buffer.h; rect_y++) {
-        if (viewport_y + rect_y < 0 || viewport_y + rect_y >= self->buffer->line_count) {
-            // Draw pre/post blank
-            tb_printf_rect(self->rect_lines, 0, rect_y, 0, 0, "%*c", self->linenum_width, '~');
-            tb_printf_rect(self->rect_margin_left, 0, rect_y, 0, 0, "%c", ' ');
-            tb_printf_rect(self->rect_margin_right, 0, rect_y, 0, 0, "%c", ' ');
-            tb_printf_rect(self->rect_buffer, 0, rect_y, 0, 0, "%-*.*s", self->rect_buffer.w, self->rect_buffer.w, " ");
+    bint_t col;
+    int ry;
+    _bview_rect_to_bline_col(self, 0, 0, &bline, &col);
+    for (ry = 0; ry < self->rect_buffer.h; ry++) {
+        if (!bline) {
+            // Draw blank
+            tb_printf_rect(self->rect_lines,        0, ry, 0, 0, "%*c", self->linenum_width, '~');
+            tb_printf_rect(self->rect_margin_left,  0, ry, 0, 0, "%c", ' ');
+            tb_printf_rect(self->rect_margin_right, 0, ry, 0, 0, "%c", ' ');
+            tb_printf_rect(self->rect_buffer,       0, ry, 0, 0, "%-*.*s", self->rect_buffer.w, self->rect_buffer.w, " ");
         } else {
-            // Draw bline at self->rect_buffer self->viewport_mark + rect_y
-            _bview_draw_bline(self, bline, rect_y, &bline, &rect_y);
+            // Draw bline
+            _bview_draw_bline(self, &bline, col, &ry);
+            col = 0;
             bline = bline->next;
         }
     }
 }
 
-static void _bview_draw_bline(bview_t *self, bline_t *bline, int rect_y, bline_t **optret_bline, int *optret_rect_y) {
-    int rect_x;
-    bint_t char_col;
-    int fg;
-    int bg, tbg;
+static void _bview_draw_bline(bview_t *self, bline_t **inout_bline, bint_t col, int *inout_rect_y) {
+    int rect_x, rect_y, fg, bg, tbg, char_vwidth, i, j, is_cursor_line, soft_wrap_type;
     uint32_t ch;
-    int char_w;
-    bint_t viewport_col;
-    bint_t viewport_vcol;
-    int i, j;
-    int is_cursor_line;
-    int soft_wrap_type;
-    int orig_rect_y;
+    bint_t char_col, viewport_col, viewport_vcol;
     srule_t *srule;
+    bline_t *bline;
 
+    bline = *inout_bline;
     MLBUF_BLINE_ENSURE_CHARS(bline);
 
+    rect_x = 0;
+    rect_y = *inout_rect_y;
     is_cursor_line = _bview_is_cursor_line(self, bline);
     soft_wrap_type = _bview_get_soft_wrap_type(self, bline);
-    viewport_col = _bview_get_viewport_col(self, bline);
-    viewport_vcol = MLE_COL_TO_VCOL(bline, viewport_col);
+    if (col > 0) {
+        viewport_col = col;
+        viewport_vcol = MLE_COL_TO_VCOL(bline, col);
+    } else {
+        viewport_vcol = _bview_get_viewport_vcol(self, bline);
+        bline_get_col_from_vcol(bline, viewport_vcol, &viewport_col);
+    }
 
     // Render linenums and margins
     if (MLE_BVIEW_IS_EDIT(self)) {
@@ -1071,22 +1080,19 @@ static void _bview_draw_bline(bview_t *self, bline_t *bline, int rect_y, bline_t
         } else if (self->editor->linenum_type == MLE_LINENUM_REL) {
             tb_printf_rect(self->rect_lines, 0, rect_y, linenum_fg, 0, "%*d", self->rel_linenum_width, (int)labs(bline->line_index - self->active_cursor->mark->bline->line_index));
         }
-        tb_printf_rect(self->rect_margin_left, 0, rect_y, 0, 0, "%c", viewport_col > 0 && bline->char_count > 0 ? '^' : ' ');
+        tb_printf_rect(self->rect_margin_left, 0, rect_y, 0, 0, "%c", viewport_vcol > 0 && bline->char_count > 0 ? '^' : ' ');
         if (soft_wrap_type == MLE_SOFT_WRAP_NONE && bline->char_vwidth - viewport_vcol > self->rect_buffer.w) {
             tb_printf_rect(self->rect_margin_right, 0, rect_y, 0, 0, "%c", '$');
         }
     }
 
-    // Render 0 thru rect_buffer.w cell by cell
-    orig_rect_y = rect_y;
-    rect_x = 0;
-    char_col = viewport_col;
+    // Render line
     _bview_populate_isearch_ranges(self, bline);
-    while (char_col < bline->char_count) {
+    for (char_col = viewport_col; char_col < bline->char_count; char_col++) {
         ch = bline->chars[char_col].ch;
         fg = bline->chars[char_col].style.fg;
         bg = bline->chars[char_col].style.bg;
-        char_w = char_col == bline->char_count - 1
+        char_vwidth = char_col == bline->char_count - 1
             ? bline->char_vwidth - bline->chars[char_col].vcol
             : bline->chars[char_col + 1].vcol - bline->chars[char_col].vcol;
         if (ch == '\t') {
@@ -1107,10 +1113,10 @@ static void _bview_draw_bline(bview_t *self, bline_t *bline, int rect_y, bline_t
             fg = srule->style.fg;
             bg = srule->style.bg;
         }
-        // Draw char_w chars of ch
-        for (i = 0; i < char_w && rect_x + i < self->rect_buffer.w; i++) {
+        // Draw char_vwidth chars of ch
+        for (i = 0; i < char_vwidth && rect_x + i < self->rect_buffer.w; i++) {
             if (MLE_BVIEW_IS_EDIT(self)
-                && rect_y == orig_rect_y // not a soft wrapped line
+                && rect_y == *inout_rect_y // not a soft wrapped line
                 && self->editor->color_col == rect_x + i + viewport_vcol
             ) {
                 // Apply color col style
@@ -1120,15 +1126,15 @@ static void _bview_draw_bline(bview_t *self, bline_t *bline, int rect_y, bline_t
             }
             tb_set_cell(self->rect_buffer.x + rect_x + i, self->rect_buffer.y + rect_y, ch, fg, tbg);
         }
-        if (i < char_w) {
+        if (i < char_vwidth) {
             // There was not enough width to draw
             if (soft_wrap_type != MLE_SOFT_WRAP_NONE && rect_y + 1 < self->rect_buffer.h) {
                 // Soft wrap to next line
                 rect_x = 0;
                 rect_y += 1;
-                char_w -= i;
+                char_vwidth -= i;
                 // Draw remaining ch on next line
-                for (j = 0; j < char_w && rect_x + j < self->rect_buffer.w; j++) {
+                for (j = 0; j < char_vwidth && rect_x + j < self->rect_buffer.w; j++) {
                     tb_set_cell(self->rect_buffer.x + j, self->rect_buffer.y + rect_y, ch, fg, bg);
                 }
                 // Draw ellipsis for line num to indicate soft wrap
@@ -1141,14 +1147,15 @@ static void _bview_draw_bline(bview_t *self, bline_t *bline, int rect_y, bline_t
                 break;
             }
         }
-        rect_x += char_w;
-        char_col += 1;
+        rect_x += char_vwidth;
     }
-    for (i = orig_rect_y; i < rect_y && bline->next; i++) {
-        bline = bline->next;
+    if (soft_wrap_type == MLE_SOFT_WRAP_SINGLE) {
+        for (i = *inout_rect_y; i < rect_y && bline->next; i++) {
+            bline = bline->next;
+        }
     }
-    if (optret_bline) *optret_bline = bline;
-    if (optret_rect_y) *optret_rect_y = rect_y;
+    *inout_bline = bline;
+    *inout_rect_y = rect_y;
 }
 
 // Highlight matching bracket pair under mark
@@ -1187,73 +1194,144 @@ static void _bview_highlight_bracket_pair(bview_t *self, mark_t *mark) {
 
 // Find screen coordinates for a mark
 int bview_get_screen_coords(bview_t *self, mark_t *mark, int *ret_x, int *ret_y, struct tb_cell **optret_cell) {
-    int screen_x;
-    int screen_y;
-    int soft_wrap_type;
-    bint_t viewport_col;
+    bint_t wcol, wrow, vcol;
+    int screen_x, screen_y;
 
-    MLBUF_BLINE_ENSURE_CHARS(mark->bline);
+    _bview_mark_to_wcoord(self, mark, &wcol, &wrow);
 
-    soft_wrap_type = _bview_get_soft_wrap_type(self, mark->bline);
+    vcol = _bview_get_viewport_vcol(self, mark->bline);
+    screen_x = self->rect_buffer.x + (int)(wcol - vcol);
+    screen_y = self->rect_buffer.y + (int)(wrow - self->viewport_wrow);
 
-    if (soft_wrap_type != MLE_SOFT_WRAP_NONE) {
-        screen_x = self->rect_buffer.x + MLE_MARK_COL_TO_VCOL(mark) % self->rect_buffer.w;
-        screen_y = self->rect_buffer.y + (mark->bline->line_index - self->viewport_mark->bline->line_index) + (MLE_MARK_COL_TO_VCOL(mark) / self->rect_buffer.w);
-    } else {
-        viewport_col = _bview_get_viewport_col(self, mark->bline);
-        screen_x = self->rect_buffer.x + MLE_MARK_COL_TO_VCOL(mark) - MLE_COL_TO_VCOL(mark->bline, viewport_col);
-        screen_y = self->rect_buffer.y + (mark->bline->line_index - self->viewport_mark->bline->line_index);
-    }
-    if (screen_x < self->rect_buffer.x || screen_x > self->rect_buffer.x + self->rect_buffer.w
+    if (  screen_x < self->rect_buffer.x || screen_x > self->rect_buffer.x + self->rect_buffer.w
        || screen_y < self->rect_buffer.y || screen_y > self->rect_buffer.y + self->rect_buffer.h
     ) {
         // Out of bounds
         return MLE_ERR;
     }
+
     *ret_x = screen_x;
     *ret_y = screen_y;
     if (optret_cell) {
         *optret_cell = tb_cell_buffer() + (ptrdiff_t)(tb_width() * screen_y + screen_x);
     }
+
     return MLE_OK;
 }
 
 // Find bline col given a screen coordinate
 int bview_screen_to_bline_col(bview_t *self, int x, int y, bview_t **ret_bview, bline_t **ret_bline, bint_t *ret_col) {
-    bint_t line_index, vcol;
-    *ret_bview = NULL;
-    *ret_bline = NULL;
-    *ret_col = 0;
     if (   x >= self->rect_buffer.x
         && x < self->rect_buffer.x + self->rect_buffer.w
         && y >= self->rect_buffer.y
         && y < self->rect_buffer.y + self->rect_buffer.h
     ) {
-        line_index = self->viewport_mark->bline->line_index + (y - self->rect_buffer.y);
-        buffer_get_bline_w_hint(self->buffer, line_index, self->viewport_mark->bline, ret_bline);
-        if (*ret_bline) {
-            vcol = _bview_get_viewport_col(self, *ret_bline) + (x - self->rect_buffer.x);
-            bline_get_col_from_vcol(*ret_bline, vcol, ret_col);
+        if (_bview_rect_to_bline_col(self, x - self->rect_buffer.x, y - self->rect_buffer.y, ret_bline, ret_col) == MLE_OK) {
             *ret_bview = self;
             return MLE_OK;
         }
-    }
-    if (self->split_child) {
+    } else if (self->split_child) {
         return bview_screen_to_bline_col(self->split_child, x, y, ret_bview, ret_bline, ret_col);
     }
     return MLE_ERR;
 }
 
+// Find bline col given a rect coordinate
+static int _bview_rect_to_bline_col(bview_t *self, int rx, int ry, bline_t **ret_bline, bint_t *ret_col) {
+    bint_t wrow, vcol, ig, bline_wrow, line_index;
+
+    // Non-full-wrap case
+    if (self->soft_wrap_type != MLE_SOFT_WRAP_FULL) {
+        line_index = self->viewport_wrow + ry;
+        buffer_get_bline_w_hint(self->buffer, line_index, self->active_cursor->mark->bline, ret_bline);
+        vcol = _bview_get_viewport_vcol(self, *ret_bline) + rx;
+        bline_get_col_from_vcol(*ret_bline, vcol, ret_col);
+        return MLE_OK;
+    }
+
+    // Full-wrap case
+    wrow = self->viewport_wrow + ry;
+    if (_bview_wrow_to_bline(self, wrow, ret_bline, &bline_wrow, &ig) == MLE_OK) {
+        vcol = ((wrow - bline_wrow) * self->rect_buffer.w) + rx;
+        bline_get_col_from_vcol(*ret_bline, vcol, ret_col);
+        return MLE_OK;
+    }
+
+    return MLE_ERR;
+}
+
+static int _bview_wrow_to_bline(bview_t *self, bint_t wrow, bline_t **ret_bline, bint_t *ret_bline_wrow, bint_t *ret_bline_wend) {
+    bline_t *bline;
+    mark_t tmark = {0};
+    bint_t bline_wrow, bline_wend, ig;
+    bline = self->active_cursor->mark->bline;
+    while (bline) {
+        MLBUF_BLINE_ENSURE_CHARS(bline);
+        tmark.bline = bline;
+        tmark.col = 0;
+        _bview_mark_to_wcoord(self, &tmark, &ig, &bline_wrow);
+        tmark.col = bline->char_count;
+        _bview_mark_to_wcoord(self, &tmark, &ig, &bline_wend);
+        if (wrow < bline_wrow) {
+            bline = bline->prev;
+        } else if (wrow > bline_wend) {
+            bline = bline->next;
+        } else {
+            *ret_bline_wrow = bline_wrow;
+            *ret_bline_wend = bline_wend;
+            *ret_bline = bline;
+            return MLE_OK;
+        }
+    }
+    return MLE_ERR;
+}
+
+// Find wcoord for a bline col
+static int _bview_bline_col_to_wcoord(bview_t *self, bline_t *bline, bint_t col, bint_t *ret_wcol, bint_t *ret_wrow) {
+    mark_t tmp = {0};
+    tmp.bline = bline;
+    tmp.col = col;
+    return _bview_mark_to_wcoord(self, &tmp, ret_wcol, ret_wrow);
+}
+
+// Find wcoord for a mark
+static int _bview_mark_to_wcoord(bview_t *self, mark_t *mark, bint_t *ret_wcol, bint_t *ret_wrow) {
+    bint_t wcol, wrow = 0;
+    int soft_wrap_type = _bview_get_soft_wrap_type(self, mark->bline);
+    if (soft_wrap_type == MLE_SOFT_WRAP_FULL) {
+        // TODO Cache this!
+        bline_t *bline;
+        for (bline = self->buffer->first_line; bline && bline != mark->bline; bline = bline->next) {
+            if (bline->char_vwidth <= 0) {
+                wrow += 1;
+            } else {
+                wrow += (int)ceilf((float)bline->char_vwidth / (float)self->rect_buffer.w);
+            }
+        }
+    } else {
+        wrow = mark->bline->line_index;
+    }
+    if (soft_wrap_type != MLE_SOFT_WRAP_NONE) {
+        wrow += MLE_MARK_COL_TO_VCOL(mark) / self->rect_buffer.w;
+        wcol = MLE_MARK_COL_TO_VCOL(mark) % self->rect_buffer.w;
+    } else {
+        wcol = MLE_MARK_COL_TO_VCOL(mark);
+    }
+    *ret_wrow = wrow;
+    *ret_wcol = wcol;
+    return MLE_OK;
+}
 
-static bint_t _bview_get_viewport_col(bview_t *self, bline_t *bline) {
-    // Use viewport_col only when
+static bint_t _bview_get_viewport_vcol(bview_t *self, bline_t *bline) {
+    // Use viewport_vcol only when
     // - vwidth >= buffer width (gte not gt to leave room for cursor)
     // - rendering current line
     // - not soft wrapping
+    MLBUF_BLINE_ENSURE_CHARS(bline);
     return bline->char_vwidth >= self->rect_buffer.w
         && _bview_is_cursor_line(self, bline)
         && _bview_get_soft_wrap_type(self, bline) == MLE_SOFT_WRAP_NONE
-        ? self->viewport_col : 0;
+        ? self->viewport_vcol : 0;
 }
 
 static int _bview_is_cursor_line(bview_t *self, bline_t *bline) {
diff --git a/cmd.c b/cmd.c
index e3c361c..f5ea57d 100644
--- a/cmd.c
+++ b/cmd.c
@@ -187,56 +187,58 @@ int cmd_move_bol(cmd_context_t *ctx) {
         }
         mark_destroy(mark);
     }
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move cursor to end of line
 int cmd_move_eol(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR_MARK_FN_NO_ARGS(ctx->cursor, mark_move_eol);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move cursor to beginning of buffer
 int cmd_move_beginning(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR_MARK_FN_NO_ARGS(ctx->cursor, mark_move_beginning);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move cursor to end of buffer
 int cmd_move_end(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR_MARK_FN_NO_ARGS(ctx->cursor, mark_move_end);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move cursor left one char
 int cmd_move_left(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_by, -1);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move cursor right one char
 int cmd_move_right(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_by, 1);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move cursor up one line
 int cmd_move_up(cmd_context_t *ctx) {
+    // TODO Move by wrow in MLE_SOFT_WRAP_FULL
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_vert, -1);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move cursor down one line
 int cmd_move_down(cmd_context_t *ctx) {
+    // TODO Move by wrow in MLE_SOFT_WRAP_FULL
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_vert, 1);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
@@ -260,7 +262,7 @@ int cmd_move_to_line(cmd_context_t *ctx) {
     free(linestr);
     if (line < 1) line = 1;
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_to, line - 1, 0);
-    bview_center_viewport_y(ctx->bview);
+    bview_viewport_center(ctx->bview);
     return MLE_OK;
 }
 
@@ -274,7 +276,7 @@ int cmd_move_to_offset(cmd_context_t *ctx) {
     free(offsetstr);
     if (offset < 0) offset = 0;
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_offset, offset);
-    bview_center_viewport_y(ctx->bview);
+    bview_viewport_center(ctx->bview);
     return MLE_OK;
 }
 
@@ -299,28 +301,28 @@ int cmd_move_relative(cmd_context_t *ctx) {
 // Move one word forward
 int cmd_move_word_forward(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_next_re_nudge, MLE_RE_WORD_FORWARD, sizeof(MLE_RE_WORD_FORWARD)-1);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move one word back
 int cmd_move_word_back(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_prev_re, MLE_RE_WORD_BACK, sizeof(MLE_RE_WORD_BACK)-1);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move to next open bracket
 int cmd_move_bracket_forward(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_next_str_nudge, "{", 1);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
 // Move to prev open bracket
 int cmd_move_bracket_back(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_prev_str, "{", 1);
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
@@ -331,7 +333,7 @@ int cmd_move_bracket_toggle(cmd_context_t *ctx) {
             mark_move_prev_re(cursor->mark, "[\\[\\(\\{]", strlen("[\\[\\(\\{]"));
         }
     }
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
@@ -474,7 +476,7 @@ int cmd_goto_lettered_mark(cmd_context_t *ctx) {
             mark_clone_w_letter(ctx->cursor->mark, other, &mark_tmp);
             mark_join(ctx->cursor->mark, mark);
         }
-        bview_rectify_viewport(ctx->bview);
+        bview_viewport_rectify(ctx->bview);
     } else {
         mark_clone_w_letter(ctx->cursor->mark, letter, &mark);
     }
@@ -514,37 +516,37 @@ int cmd_repeat(cmd_context_t *ctx) {
 
 // Redraw screen
 int cmd_redraw(cmd_context_t *ctx) {
-    bview_center_viewport_y(ctx->bview);
+    bview_viewport_center(ctx->bview);
     editor_force_redraw(ctx->editor);
     return MLE_OK;
 }
 
 // Zero viewport y
 int cmd_viewport_top(cmd_context_t *ctx) {
-    bview_zero_viewport_y(ctx->bview);
+    bview_viewport_zero(ctx->bview);
     return MLE_OK;
 }
 
 // Center viewport y
 int cmd_viewport_mid(cmd_context_t *ctx) {
-    bview_center_viewport_y(ctx->bview);
+    bview_viewport_center(ctx->bview);
     return MLE_OK;
 }
 
 // Max viewport y
 int cmd_viewport_bot(cmd_context_t *ctx) {
-    bview_max_viewport_y(ctx->bview);
+    bview_viewport_max(ctx->bview);
     return MLE_OK;
 }
 
 // Toggle between top and mid viewport y
 int cmd_viewport_toggle(cmd_context_t *ctx) {
-    bline_t *orig;
-    bline_t *mid;
-    bline_t *top;
-    orig = ctx->bview->viewport_mark->bline;
-    cmd_viewport_mid(ctx); mid  = ctx->bview->viewport_mark->bline;
-    cmd_viewport_top(ctx); top  = ctx->bview->viewport_mark->bline;
+    bint_t orig;
+    bint_t mid;
+    bint_t top;
+                           orig = ctx->bview->viewport_wrow;
+    cmd_viewport_mid(ctx); mid  = ctx->bview->viewport_wrow;
+    cmd_viewport_top(ctx); top  = ctx->bview->viewport_wrow;
     if (mid == orig) {
         cmd_viewport_top(ctx);
     } else if (top == orig) {
@@ -552,7 +554,7 @@ int cmd_viewport_toggle(cmd_context_t *ctx) {
     } else {
         cmd_viewport_mid(ctx);
     }
-    return MLE_OK;
+    return MLE_ERR;
 }
 
 // Find next occurence of word under cursor
@@ -637,7 +639,7 @@ int cmd_anchor_by(cmd_context_t *ctx) {
     MLE_FOREACH_CURSOR(ctx->cursor) {
         cursor_select_by(cursor, ctx->static_param, 1);
     }
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
@@ -797,7 +799,7 @@ int cmd_browse(cmd_context_t *ctx) {
     if (!aproc) return MLE_ERR;
     editor_menu(ctx->editor, _cmd_menu_browse_cb, ".", 1, aproc, &menu);
     mark_move_beginning(menu->active_cursor->mark);
-    bview_zero_viewport_y(menu);
+    bview_viewport_zero(menu);
     if (strncmp(browse_path, "./", 2) == 0) {
         browse_path += 2;
     } else if (strcmp(browse_path, ".") == 0) {
@@ -849,7 +851,7 @@ int cmd_blist(cmd_context_t *ctx) {
 
     editor_menu(ctx->editor, _cmd_menu_blist_cb, blist.data, blist.len, NULL, &menu);
     if (active_lineno >= 0) mark_move_to(menu->active_cursor->mark, active_lineno, 0);
-    bview_set_viewport_y(menu, 0, 1);
+    bview_viewport_set(menu, 0, 1);
 
     str_free(&blist);
     return MLE_OK;
@@ -988,7 +990,7 @@ int cmd_move_until_forward(cmd_context_t *ctx) {
     if (!ch) return MLE_OK;
     tb_utf8_unicode_to_char(str, ch);
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_next_str_nudge, str, strlen(str));
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
@@ -1000,7 +1002,7 @@ int cmd_move_until_back(cmd_context_t *ctx) {
     if (!ch) return MLE_OK;
     tb_utf8_unicode_to_char(str, ch);
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_prev_str, str, strlen(str));
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
@@ -1153,8 +1155,7 @@ int cmd_jump(cmd_context_t *ctx) {
     bline_t *bline;
     bint_t col;
     bint_t nchars;
-    bint_t stop_line_index;
-    mark_t *mark;
+    mark_t *mark, *mark_stop;
     mark_t *jumps;
     int jumpi, jumpt, screen_x, screen_y;
     char jumpa[3];
@@ -1166,12 +1167,14 @@ int cmd_jump(cmd_context_t *ctx) {
 
     // Set boundaries
     mark_clone(ctx->cursor->mark, &mark);
+    mark_clone(ctx->cursor->mark, &mark_stop);
     if (headless) {
         mark_move_bol(mark);
-        stop_line_index = mark->bline->line_index + 1;
+        mark_move_eol(mark_stop);
     } else {
-        mark_move_to_w_bline(mark, ctx->bview->viewport_mark->bline, 0);
-        stop_line_index = ctx->bview->viewport_mark->bline->line_index + ctx->bview->rect_buffer.h;
+        bview_mark_move_rect(ctx->bview, mark, 0, 0);
+        bview_mark_move_rect(ctx->bview, mark_stop, ctx->bview->rect_buffer.w - 1, ctx->bview->rect_buffer.h - 1);
+        return MLE_ERR;
     }
 
     // Make jump map
@@ -1181,7 +1184,7 @@ int cmd_jump(cmd_context_t *ctx) {
     do {
         // Loop for words
         while (jumpi < 26*26 && mark_move_next_re_ex(mark, "\\S{2,}", strlen("\\S{2,}"), &bline, &col, &nchars) == MLBUF_OK) {
-            if (bline->line_index >= stop_line_index) break;
+            if (mark_is_gt(mark, mark_stop)) break;
             jumps[jumpi].bline = bline;
             jumps[jumpi].col = col;
             mark_move_by(mark, MLE_MAX(0, nchars - 2));
@@ -1210,6 +1213,7 @@ int cmd_jump(cmd_context_t *ctx) {
     // Cleanup
     free(jumps);
     mark_destroy(mark);
+    mark_destroy(mark_stop);
     return MLE_OK;
 }
 
@@ -1318,7 +1322,7 @@ int cmd_less(cmd_context_t *ctx) {
             break;
         }
         mark_move_to(ctx->cursor->mark, (line_top) + ctx->bview->rect_buffer.h/2, 0);
-        bview_center_viewport_y(ctx->bview);
+        bview_viewport_center(ctx->bview);
     } while(0);
 
     if (tmp_buf_fd >= 0) {
@@ -1395,7 +1399,7 @@ int cmd_show_help(cmd_context_t *ctx) {
     buffer_insert(bview->buffer, 0, h.data, (bint_t)h.len, NULL);
     bview->buffer->is_unsaved = 0;
     mark_move_beginning(bview->active_cursor->mark);
-    bview_zero_viewport_y(bview);
+    bview_viewport_zero(bview);
 
     str_free(&h);
     return MLE_OK;
@@ -1667,7 +1671,7 @@ static int _cmd_search_next(bview_t *bview, cursor_t *cursor, mark_t *search_mar
     }
 
     // Rectify viewport if needed
-    if (rc == MLE_OK) bview_rectify_viewport(bview);
+    if (rc == MLE_OK) bview_viewport_rectify(bview);
 
     return rc;
 }
@@ -1707,7 +1711,7 @@ static int _cmd_find_word_ex(cmd_context_t *ctx, int is_prev) {
         }
     }
 
-    bview_rectify_viewport(ctx->bview);
+    bview_viewport_rectify(ctx->bview);
     return MLE_OK;
 }
 
@@ -1730,7 +1734,7 @@ static void _cmd_aproc_bview_passthru_cb(aproc_t *aproc, char *buf, size_t buf_l
     mark_move_end(ins_mark);
     mark_insert_before(ins_mark, buf, buf_len);
     mark_destroy(ins_mark);
-    bview_rectify_viewport(bview);
+    bview_viewport_rectify(bview);
 
     if (is_cursor_at_zero) mark_move_beginning(active_mark);
 }
@@ -1760,7 +1764,7 @@ static void _cmd_isearch_prompt_cb(bview_t *bview_prompt, baction_t *action, voi
 
     mark_move_next_cre(bview->active_cursor->mark, bview->isearch_rule->cre);
 
-    bview_center_viewport_y(bview);
+    bview_viewport_center(bview);
 }
 
 // Callback from cmd_grep
@@ -1826,7 +1830,7 @@ static int _cmd_menu_ctag_cb(cmd_context_t *ctx) {
     editor_open_bview(ctx->editor, NULL, MLE_BVIEW_TYPE_EDIT, fname, strlen(fname), 1, 0, 0, NULL, &bview);
     asprintf(&qre2, "^%s", qre);
     mark_move_next_re(bview->active_cursor->mark, qre2, qre_len+1);
-    bview_center_viewport_y(bview);
+    bview_viewport_center(bview);
     free(line);
     free(qre);
     free(qre2);
@@ -2138,7 +2142,7 @@ static int _cmd_move_page_y(cmd_context_t *ctx, int full_y, int is_up) {
     } else {
         y = full_y;
     }
-    viewport_fn = y < full_y ? bview_rectify_viewport : bview_zero_viewport_y;
+    viewport_fn = y < full_y ? bview_viewport_rectify : bview_viewport_zero;
     if (is_up) y *= -1;
     MLE_FOREACH_CURSOR_MARK_FN(ctx->cursor, mark_move_vert, y);
     viewport_fn(ctx->bview);
diff --git a/cursor.c b/cursor.c
index 9b5c23e..4aa28e9 100644
--- a/cursor.c
+++ b/cursor.c
@@ -290,7 +290,7 @@ int cursor_replace(cursor_t *cursor, int interactive, char *opt_regex, char *opt
     bline_t *bline;
     bint_t col;
     bint_t char_count;
-    bint_t orig_viewport_y;
+    bint_t orig_viewport_wrow;
     int pcre_rc;
     PCRE2_SIZE pcre_ovector[30];
     str_t repl_backref = {0};
@@ -312,7 +312,7 @@ int cursor_replace(cursor_t *cursor, int interactive, char *opt_regex, char *opt
     all = interactive ? 0 : 1;
     num_replacements = 0;
     mark_set_pcre_capture(&pcre_rc, pcre_ovector, 30);
-    orig_viewport_y = -1;
+    orig_viewport_wrow = -1;
 
     do {
         if (!interactive) {
@@ -331,7 +331,7 @@ int cursor_replace(cursor_t *cursor, int interactive, char *opt_regex, char *opt
         search_mark_end = buffer_add_mark(cursor->bview->buffer, NULL, 0);
         mark_join(search_mark, cursor->mark);
         mark_join(orig_mark, cursor->mark);
-        orig_viewport_y = cursor->bview->viewport_mark->bline->line_index;
+        orig_viewport_wrow = cursor->bview->viewport_wrow;
         orig_mark->lefty = 1; // lefty==1 avoids moving when text is inserted at mark
         lo_mark->lefty = 1;
         if (cursor->is_anchored) {
@@ -358,7 +358,7 @@ int cursor_replace(cursor_t *cursor, int interactive, char *opt_regex, char *opt
                 } else if (interactive) {
                     highlight = srule_new_range(search_mark, search_mark_end, 0, TB_REVERSE);
                     buffer_add_srule(cursor->bview->buffer, highlight);
-                    bview_rectify_viewport(cursor->bview);
+                    bview_viewport_rectify(cursor->bview);
                     bview_draw(cursor->bview);
                     editor_prompt(cursor->bview->editor, "replace: OK to replace? (y=yes, n=no, a=all, C-c=stop)",
                         &(editor_prompt_params_t) { .kmap = cursor->bview->editor->kmap_prompt_yna }, &yn
@@ -405,10 +405,10 @@ int cursor_replace(cursor_t *cursor, int interactive, char *opt_regex, char *opt
 
     if (interactive) {
         MLE_SET_INFO(cursor->bview->editor, "replace: Replaced %d instance(s)", num_replacements);
-        if (orig_viewport_y >= 0) {
-            bview_set_viewport_y(cursor->bview, orig_viewport_y, 1);
+        if (orig_viewport_wrow >= 0) {
+            bview_viewport_set(cursor->bview, orig_viewport_wrow, 1);
         } else {
-            bview_rectify_viewport(cursor->bview);
+            bview_viewport_rectify(cursor->bview);
         }
         bview_draw(cursor->bview);
     }
diff --git a/editor.c b/editor.c
index 7da01aa..26a66bb 100644
--- a/editor.c
+++ b/editor.c
@@ -372,7 +372,7 @@ int editor_open_bview(editor_t *editor, bview_t *opt_parent, int type, char *opt
     }
     if (linenum > 0) {
         mark_move_to(bview->active_cursor->mark, linenum - 1, 0);
-        bview_center_viewport_y(bview);
+        bview_viewport_center(bview);
     }
     if (optret_bview) {
         *optret_bview = bview;
@@ -413,7 +413,7 @@ int editor_set_active(editor_t *editor, bview_t *bview) {
         editor->active_edit = bview;
         editor->active_edit_root = bview_get_split_root(bview);
     }
-    bview_rectify_viewport(bview);
+    bview_viewport_rectify(bview);
     return MLE_OK;
 }
 
@@ -833,7 +833,7 @@ static int _editor_menu_cancel(cmd_context_t *ctx) {
 static int _editor_prompt_isearch_next(cmd_context_t *ctx) {
     if (ctx->editor->active_edit->isearch_rule) {
         mark_move_next_cre_nudge(ctx->editor->active_edit->active_cursor->mark, ctx->editor->active_edit->isearch_rule->cre);
-        bview_center_viewport_y(ctx->editor->active_edit);
+        bview_viewport_center(ctx->editor->active_edit);
     }
     return MLE_OK;
 }
@@ -842,19 +842,19 @@ static int _editor_prompt_isearch_next(cmd_context_t *ctx) {
 static int _editor_prompt_isearch_prev(cmd_context_t *ctx) {
     if (ctx->editor->active_edit->isearch_rule) {
         mark_move_prev_cre(ctx->editor->active_edit->active_cursor->mark, ctx->editor->active_edit->isearch_rule->cre);
-        bview_center_viewport_y(ctx->editor->active_edit);
+        bview_viewport_center(ctx->editor->active_edit);
     }
     return MLE_OK;
 }
 
 // Invoked when user hits pgup in a prompt_isearch
 static int _editor_prompt_isearch_viewport_up(cmd_context_t *ctx) {
-    return bview_set_viewport_y(ctx->editor->active_edit, ctx->editor->active_edit->viewport_mark->bline->line_index - 5, 0);
+    return bview_viewport_set(ctx->editor->active_edit, ctx->editor->active_edit->viewport_wrow - 5, 0);
 }
 
 // Invoked when user hits pgdn in a prompt_isearch
 static int _editor_prompt_isearch_viewport_down(cmd_context_t *ctx) {
-    return bview_set_viewport_y(ctx->editor->active_edit, ctx->editor->active_edit->viewport_mark->bline->line_index + 5, 0);
+    return bview_viewport_set(ctx->editor->active_edit, ctx->editor->active_edit->viewport_wrow + 5, 0);
 }
 
 // Drops a cursor on each isearch match
@@ -881,7 +881,7 @@ static int _editor_prompt_isearch_drop_cursors(cmd_context_t *ctx) {
         bview_remove_cursor(bview, last_cursor);
     }
     bview->active_cursor = orig_cursor;
-    bview_center_viewport_y(bview);
+    bview_viewport_center(bview);
     ctx->loop_ctx->prompt_answer = NULL;
     ctx->loop_ctx->should_exit = 1;
     return MLE_OK;
diff --git a/mle.h b/mle.h
index aad28b9..ab82209 100644
--- a/mle.h
+++ b/mle.h
@@ -183,9 +183,8 @@ struct bview_s {
     bview_rect_t rect_buffer;
     bview_rect_t rect_margin_right;
     buffer_t *buffer;
-    bint_t viewport_col;
     bint_t viewport_vcol;
-    mark_t *viewport_mark;
+    bint_t viewport_wrow;
     int viewport_scope_x;
     int viewport_scope_y;
     bview_t *split_parent;
@@ -445,27 +444,28 @@ bview_t *bview_new(editor_t *editor, int type, char *opt_path, int opt_path_len,
 int bview_add_cursor_asleep(bview_t *self, bline_t *opt_bline, bint_t opt_col, cursor_t **optret_cursor);
 int bview_add_cursor(bview_t *self, bline_t *opt_bline, bint_t opt_col, cursor_t **optret_cursor);
 int bview_add_listener(bview_t *self, bview_listener_cb_t fn_callback, void *udata);
-int bview_center_viewport_y(bview_t *self);
 int bview_destroy(bview_t *self);
 int bview_destroy_listener(bview_t *self, bview_listener_t *listener);
 int bview_draw(bview_t *self);
 int bview_draw_cursor(bview_t *self, int set_real_cursor);
 int bview_get_active_cursor_count(bview_t *self);
 int bview_get_screen_coords(bview_t *self, mark_t *mark, int *ret_x, int *ret_y, struct tb_cell **optret_cell);
-int bview_max_viewport_y(bview_t *self);
+int bview_mark_move_rect(bview_t *self, mark_t *mark, int rx, int ry);
 int bview_open(bview_t *self, char *path, int path_len);
 int bview_pop_kmap(bview_t *bview, kmap_t **optret_kmap);
 int bview_push_kmap(bview_t *bview, kmap_t *kmap);
-int bview_rectify_viewport(bview_t *self);
+int bview_viewport_rectify(bview_t *self);
 int bview_remove_cursor(bview_t *self, cursor_t *cursor);
 int bview_remove_cursors_except(bview_t *self, cursor_t *one);
 int bview_resize(bview_t *self, int x, int y, int w, int h);
 int bview_screen_to_bline_col(bview_t *self, int x, int y, bview_t **ret_bview, bline_t **ret_bline, bint_t *ret_col);
 int bview_set_syntax(bview_t *self, char *opt_syntax);
-int bview_set_viewport_y(bview_t *self, bint_t y, int do_rectify);
 int bview_split(bview_t *self, int is_vertical, float factor, bview_t **optret_bview);
+int bview_viewport_center(bview_t *self);
+int bview_viewport_max(bview_t *self);
+int bview_viewport_set(bview_t *self, bint_t wrow, int do_rectify);
+int bview_viewport_zero(bview_t *self);
 int bview_wake_sleeping_cursors(bview_t *self);
-int bview_zero_viewport_y(bview_t *self);
 
 // cursor functions
 int cursor_clone(cursor_t *cursor, int use_srules, cursor_t **ret_clone);
diff --git a/uscript.inc b/uscript.inc
index 75c59c7..0bb2d9f 100644
--- a/uscript.inc
+++ b/uscript.inc
@@ -749,11 +749,11 @@ static int _uscript_func_bview_add_cursor_asleep(lua_State *L) {
     return 1;
 }
 
-static int _uscript_func_bview_center_viewport_y(lua_State *L) {
+static int _uscript_func_bview_viewport_center(lua_State *L) {
     int rv;
     bview_t *self;
     self = (bview_t *)luaL_checkpointer(L, 1);
-    rv = bview_center_viewport_y(self);
+    rv = bview_viewport_center(self);
     lua_createtable(L, 0, 1);
     lua_pushstring(L, "rv");
     lua_pushinteger(L, (lua_Integer)rv);
@@ -829,11 +829,11 @@ static int _uscript_func_bview_get_split_root(lua_State *L) {
     return 1;
 }
 
-static int _uscript_func_bview_max_viewport_y(lua_State *L) {
+static int _uscript_func_bview_viewport_max(lua_State *L) {
     int rv;
     bview_t *self;
     self = (bview_t *)luaL_checkpointer(L, 1);
-    rv = bview_max_viewport_y(self);
+    rv = bview_viewport_max(self);
     lua_createtable(L, 0, 1);
     lua_pushstring(L, "rv");
     lua_pushinteger(L, (lua_Integer)rv);
@@ -886,11 +886,11 @@ static int _uscript_func_bview_open(lua_State *L) {
 // static int _uscript_func_bview_push_kmap(lua_State *L) {
 // }
 
-static int _uscript_func_bview_rectify_viewport(lua_State *L) {
+static int _uscript_func_bview_viewport_rectify(lua_State *L) {
     int rv;
     bview_t *self;
     self = (bview_t *)luaL_checkpointer(L, 1);
-    rv = bview_rectify_viewport(self);
+    rv = bview_viewport_rectify(self);
     lua_createtable(L, 0, 1);
     lua_pushstring(L, "rv");
     lua_pushinteger(L, (lua_Integer)rv);
@@ -965,15 +965,15 @@ static int _uscript_func_bview_set_syntax(lua_State *L) {
     return 1;
 }
 
-static int _uscript_func_bview_set_viewport_y(lua_State *L) {
+static int _uscript_func_bview_viewport_set(lua_State *L) {
     int rv;
     bview_t *self;
-    bint_t y;
+    bint_t wrow;
     int do_rectify;
     self = (bview_t *)luaL_checkpointer(L, 1);
-    y = (bint_t)luaL_checkinteger(L, 2);
+    wrow = (bint_t)luaL_checkinteger(L, 2);
     do_rectify = (int)luaL_checkinteger(L, 3);
-    rv = bview_set_viewport_y(self, y, do_rectify);
+    rv = bview_viewport_set(self, wrow, do_rectify);
     lua_createtable(L, 0, 1);
     lua_pushstring(L, "rv");
     lua_pushinteger(L, (lua_Integer)rv);
@@ -1016,11 +1016,11 @@ static int _uscript_func_bview_wake_sleeping_cursors(lua_State *L) {
     return 1;
 }
 
-static int _uscript_func_bview_zero_viewport_y(lua_State *L) {
+static int _uscript_func_bview_viewport_zero(lua_State *L) {
     int rv;
     bview_t *self;
     self = (bview_t *)luaL_checkpointer(L, 1);
-    rv = bview_zero_viewport_y(self);
+    rv = bview_viewport_zero(self);
     lua_createtable(L, 0, 1);
     lua_pushstring(L, "rv");
     lua_pushinteger(L, (lua_Integer)rv);
@@ -2596,26 +2596,26 @@ static const struct luaL_Reg mle_lib[] = {
     { "buffer_write_to_file", _uscript_func_buffer_write_to_file },
     { "bview_add_cursor", _uscript_func_bview_add_cursor },
     { "bview_add_cursor_asleep", _uscript_func_bview_add_cursor_asleep },
-    { "bview_center_viewport_y", _uscript_func_bview_center_viewport_y },
     { "bview_destroy", _uscript_func_bview_destroy },
     { "bview_draw", _uscript_func_bview_draw },
     { "bview_draw_cursor", _uscript_func_bview_draw_cursor },
     { "bview_get_active_cursor_count", _uscript_func_bview_get_active_cursor_count },
     { "bview_get_split_root", _uscript_func_bview_get_split_root },
-    { "bview_max_viewport_y", _uscript_func_bview_max_viewport_y },
     { "bview_new", _uscript_func_bview_new },
     { "bview_open", _uscript_func_bview_open },
     { "bview_pop_kmap", _uscript_func_bview_pop_kmap },
     { "bview_push_kmap", _uscript_func_bview_push_kmap },
-    { "bview_rectify_viewport", _uscript_func_bview_rectify_viewport },
     { "bview_remove_cursor", _uscript_func_bview_remove_cursor },
     { "bview_remove_cursors_except", _uscript_func_bview_remove_cursors_except },
     { "bview_resize", _uscript_func_bview_resize },
     { "bview_set_syntax", _uscript_func_bview_set_syntax },
-    { "bview_set_viewport_y", _uscript_func_bview_set_viewport_y },
     { "bview_split", _uscript_func_bview_split },
+    { "bview_viewport_center", _uscript_func_bview_viewport_center },
+    { "bview_viewport_max", _uscript_func_bview_viewport_max },
+    { "bview_viewport_rectify", _uscript_func_bview_viewport_rectify },
+    { "bview_viewport_set", _uscript_func_bview_viewport_set },
+    { "bview_viewport_zero", _uscript_func_bview_viewport_zero },
     { "bview_wake_sleeping_cursors", _uscript_func_bview_wake_sleeping_cursors },
-    { "bview_zero_viewport_y", _uscript_func_bview_zero_viewport_y },
     { "cursor_clone", _uscript_func_cursor_clone },
     { "cursor_cut_copy", _uscript_func_cursor_cut_copy },
     { "cursor_destroy", _uscript_func_cursor_destroy },