diff --git a/src/ring.c b/src/ring.c
index c00acda..ba160bf 100644
--- a/src/ring.c
+++ b/src/ring.c
@@ -35,8 +35,8 @@ _vte_ring_validate (VteRing * ring)
 {
 	g_assert(ring != NULL);
 	_vte_debug_print(VTE_DEBUG_RING,
-			" Delta = %lu, Length = %lu, Max = %lu, Writable = %lu.\n",
-			ring->start, ring->end - ring->start,
+			" Delta = %lu, Length = %lu, Next = %lu, Max = %lu, Writable = %lu.\n",
+			ring->start, ring->end - ring->start, ring->end,
 			ring->max, ring->end - ring->writable);
 
 	g_assert (ring->start <= ring->writable);
@@ -100,8 +100,17 @@ _vte_ring_fini (VteRing *ring)
 typedef struct _VteRowRecord {
 	gsize text_start_offset;  /* offset where text of this row begins */
 	gsize attr_start_offset;  /* offset of the first character's attributes */
+	int soft_wrapped: 1;      /* end of line is not '\n' */
+	int is_ascii: 1;          /* for rewrapping speedup: guarantees that line contains 32..126 bytes only. Can be 0 even when ascii only. */
 } VteRowRecord;
 
+/* Represents a cell position, see ../doc/rewrap.txt */
+typedef struct _VteCellTextOffset {
+	gsize text_offset;    /* byte offset in text_stream (or perhaps beyond) */
+	gint fragment_cells;  /* extra number of cells to walk within a multicell character */
+	gint eol_cells;       /* -1 if over a character, >=0 if at EOL or beyond */
+} VteCellTextOffset;
+
 static gboolean
 _vte_ring_read_row_record (VteRing *ring, VteRowRecord *record, gulong position)
 {
@@ -124,8 +133,10 @@ _vte_ring_freeze_row (VteRing *ring, gulong position, const VteRowData *row)
 
 	_vte_debug_print (VTE_DEBUG_RING, "Freezing row %lu.\n", position);
 
+	memset(&record, 0, sizeof (record));
 	record.text_start_offset = _vte_stream_head (ring->text_stream);
 	record.attr_start_offset = _vte_stream_head (ring->attr_stream);
+	record.is_ascii = 1;
 
 	g_string_set_size (buffer, 0);
 	for (i = 0, cell = row->cells; i < row->len; i++, cell++) {
@@ -171,11 +182,13 @@ _vte_ring_freeze_row (VteRing *ring, gulong position, const VteRowData *row)
 				ring->last_attr = attr;
 			}
 
+			if (cell->c < 32 || cell->c > 126) record.is_ascii = 0;
 			_vte_unistr_append_to_string (cell->c, buffer);
 		}
 	}
 	if (!row->attr.soft_wrapped)
 		g_string_append_c (buffer, '\n');
+	record.soft_wrapped = row->attr.soft_wrapped;
 
 	_vte_stream_append (ring->text_stream, buffer->str, buffer->len);
 	_vte_ring_append_row_record (ring, &record, position);
@@ -339,9 +352,6 @@ _vte_ring_freeze_one_row (VteRing *ring)
 {
 	VteRowData *row;
 
-	/* We should never even try to freeze if writable is less than a screenful from the end */
-	g_assert(ring->writable + ring->visible_rows_hint < ring->end);
-
 	if (G_UNLIKELY (ring->writable == ring->start))
 		_vte_ring_reset_streams (ring, ring->writable);
 
@@ -597,6 +607,411 @@ _vte_ring_set_visible_rows_hint (VteRing *ring, gulong rows)
 }
 
 
+/* Convert a (row,col) into a VteCellTextOffset.
+ * Requires the row to be frozen, or be outsize the range covered by the ring.
+ */
+static gboolean
+_vte_frozen_row_column_to_text_offset (VteRing *ring,
+				       gulong position,
+				       gulong column,
+				       VteCellTextOffset *offset)
+{
+	VteRowRecord records[2];
+	VteCell *cell;
+	GString *buffer = ring->utf8_buffer;
+	const VteRowData *row;
+	unsigned int i, num_chars, off;
+
+	if (position >= ring->end) {
+		offset->text_offset = _vte_stream_head (ring->text_stream) + position - ring->end;
+		offset->fragment_cells = 0;
+		offset->eol_cells = column;
+		return TRUE;
+	}
+
+	if (G_UNLIKELY (position < ring->start)) {
+		/* This happens when the marker (saved cursor position) is
+		   scrolled off at the top of the scrollback buffer. */
+		position = ring->start;
+		column = 0;
+		/* go on */
+	}
+
+	g_assert(position < ring->writable);
+	if (!_vte_ring_read_row_record (ring, &records[0], position))
+		return FALSE;
+	if ((position + 1) * sizeof (records[0]) < _vte_stream_head (ring->row_stream)) {
+		if (!_vte_ring_read_row_record (ring, &records[1], position + 1))
+			return FALSE;
+	} else
+		records[1].text_start_offset = _vte_stream_head (ring->text_stream);
+
+	g_string_set_size (buffer, records[1].text_start_offset - records[0].text_start_offset);
+	if (!_vte_stream_read (ring->text_stream, records[0].text_start_offset, buffer->str, buffer->len))
+		return FALSE;
+
+	if (G_LIKELY (buffer->len && buffer->str[buffer->len - 1] == '\n'))
+		buffer->len--;
+
+	row = _vte_ring_index(ring, position);
+
+	/* row and buffer now contain the same text, in different representation */
+
+	/* count the number of characters up to the given column */
+	offset->fragment_cells = 0;
+	offset->eol_cells = -1;
+	num_chars = 0;
+	for (i = 0, cell = row->cells; i < row->len && i < column; i++, cell++) {
+		if (G_LIKELY (!cell->attr.fragment)) {
+			if (G_UNLIKELY (i + cell->attr.columns > column)) {
+				offset->fragment_cells = column - i;
+				break;
+			}
+			num_chars += _vte_unistr_strlen(cell->c);
+		}
+	}
+	if (i >= row->len) {
+		offset->eol_cells = column - i;
+	}
+
+	/* count the number of UTF-8 bytes for the given number of characters */
+	off = 0;
+	while (num_chars > 0 && off < buffer->len) {
+		off++;
+		if ((buffer->str[off] & 0xC0) != 0x80) num_chars--;
+	}
+	offset->text_offset = records[0].text_start_offset + off;
+	return TRUE;
+}
+
+
+/* Given a row number and a VteCellTextOffset, compute the column within that row.
+   It's the caller's responsibility to ensure that VteCellTextOffset really falls into that row.
+   Requires the row to be frozen, or be outsize the range covered by the ring.
+ */
+static gboolean
+_vte_frozen_row_text_offset_to_column (VteRing *ring,
+				       gulong position,
+				       const VteCellTextOffset *offset,
+				       long *column)
+{
+	VteRowRecord records[2];
+	VteCell *cell;
+	GString *buffer = ring->utf8_buffer;
+	const VteRowData *row;
+	unsigned int i, off, num_chars, nc;
+
+	if (position >= ring->end) {
+		*column = offset->eol_cells;
+		return TRUE;
+	}
+
+	if (G_UNLIKELY (position < ring->start)) {
+		/* This happens when the marker (saved cursor position) is
+		   scrolled off at the top of the scrollback buffer. */
+		*column = 0;
+		return TRUE;
+	}
+
+	g_assert(position < ring->writable);
+	if (!_vte_ring_read_row_record (ring, &records[0], position))
+		return FALSE;
+	if ((position + 1) * sizeof (records[0]) < _vte_stream_head (ring->row_stream)) {
+		if (!_vte_ring_read_row_record (ring, &records[1], position + 1))
+			return FALSE;
+	} else
+		records[1].text_start_offset = _vte_stream_head (ring->text_stream);
+
+	g_assert(offset->text_offset >= records[0].text_start_offset && offset->text_offset < records[1].text_start_offset);
+
+	g_string_set_size (buffer, records[1].text_start_offset - records[0].text_start_offset);
+	if (!_vte_stream_read (ring->text_stream, records[0].text_start_offset, buffer->str, buffer->len))
+		return FALSE;
+
+	if (G_LIKELY (buffer->len && buffer->str[buffer->len - 1] == '\n'))
+		buffer->len--;
+
+	row = _vte_ring_index(ring, position);
+
+	/* row and buffer now contain the same text, in different representation */
+
+	/* count the number of characters for the given UTF-8 text offset */
+	off = offset->text_offset - records[0].text_start_offset;
+	num_chars = 0;
+	for (i = 0; i < off && i < buffer->len; i++) {
+		if ((buffer->str[i] & 0xC0) != 0x80) num_chars++;
+	}
+
+	/* count the number of columns for the given number of characters */
+	for (i = 0, cell = row->cells; i < row->len; i++, cell++) {
+		if (G_LIKELY (!cell->attr.fragment)) {
+			if (num_chars == 0) break;
+			nc = _vte_unistr_strlen(cell->c);
+			if (nc > num_chars) break;
+			num_chars -= nc;
+		}
+	}
+
+	/* always add fragment_cells, but add eol_cells only if we're at eol */
+	i += offset->fragment_cells;
+	if (G_UNLIKELY (offset->eol_cells >= 0 && i == row->len))
+		i += offset->eol_cells;
+	*column = i;
+	return TRUE;
+}
+
+
+/**
+ * _vte_ring_rewrap:
+ * @ring: a #VteRing
+ * @columns: new number of columns
+ * @markers: NULL-terminated array of #VteVisualPosition
+ *
+ * Reflow the @ring to match the new number of @columns.
+ * For all @markers, find the cell at that position and update them to
+ * reflect the cell's new position.
+ */
+/* See ../doc/rewrap.txt for design and implementation details. */
+void
+_vte_ring_rewrap (VteRing *ring,
+		  glong columns,
+		  VteVisualPosition **markers)
+{
+	gulong old_row_index, new_row_index;
+	int i;
+	int num_markers = 0;
+	VteCellTextOffset *marker_text_offsets;
+	VteVisualPosition *new_markers;
+	VteRowRecord old_record;
+	VteCellAttrChange attr_change;
+	VteStream *new_row_stream;
+	gsize paragraph_start_text_offset;
+	gsize paragraph_end_text_offset;
+	gsize paragraph_len;  /* excluding trailing '\n' */
+	gsize attr_offset;
+	gsize old_ring_end;
+
+	if (_vte_ring_length(ring) == 0)
+		return;
+	_vte_debug_print(VTE_DEBUG_RING, "Ring before rewrapping:\n");
+	_vte_ring_validate(ring);
+	new_row_stream = _vte_file_stream_new ();
+
+	/* Freeze everything, because rewrapping is really complicated and we don't want to
+	   duplicate the code for frozen and thawed rows. */
+	while (ring->writable < ring->end)
+		_vte_ring_freeze_one_row(ring);
+
+	/* For markers given as (row,col) pairs find their offsets in the text stream.
+	   This code requires that the rows are already frozen. */
+	while (markers[num_markers] != NULL)
+		num_markers++;
+	marker_text_offsets = g_malloc(num_markers * sizeof (marker_text_offsets[0]));
+	new_markers = g_malloc(num_markers * sizeof (new_markers[0]));
+	for (i = 0; i < num_markers; i++) {
+		/* Convert visual column into byte offset */
+		if (!_vte_frozen_row_column_to_text_offset(ring, markers[i]->row, markers[i]->col, &marker_text_offsets[i]))
+			goto err;
+		new_markers[i].row = new_markers[i].col = -1;
+		_vte_debug_print(VTE_DEBUG_RING,
+				"Marker #%d old coords:  row %ld  col %ld  ->  text_offset %ld  fragment_cells %d  eol_cells %d\n",
+				i, markers[i]->row, markers[i]->col, marker_text_offsets[i].text_offset,
+				marker_text_offsets[i].fragment_cells, marker_text_offsets[i].eol_cells);
+	}
+
+	/* Prepare for rewrapping */
+	if (!_vte_ring_read_row_record(ring, &old_record, ring->start))
+		goto err;
+	paragraph_start_text_offset = old_record.text_start_offset;
+	paragraph_end_text_offset = _vte_stream_head (ring->text_stream);  /* initialized to silence gcc */
+	new_row_index = 0;
+
+	attr_offset = old_record.attr_start_offset;
+	if (!_vte_stream_read(ring->attr_stream, attr_offset, (char *) &attr_change, sizeof (attr_change))) {
+		attr_change.attr = ring->last_attr;
+		attr_change.text_end_offset = _vte_stream_head (ring->text_stream);
+	}
+
+	old_row_index = ring->start + 1;
+	while (paragraph_start_text_offset < _vte_stream_head (ring->text_stream)) {
+		/* Find the boundaries of the next paragraph */
+		gboolean prev_record_was_soft_wrapped = FALSE;
+		gboolean paragraph_is_ascii = TRUE;
+		gsize paragraph_start_row = old_row_index - 1;
+		gsize paragraph_end_row;  /* points to beyond the end */
+		gsize text_offset = paragraph_start_text_offset;
+		VteRowRecord new_record;
+		glong col = 0;
+		_vte_debug_print(VTE_DEBUG_RING,
+				"  Old paragraph:  row %ld  (text_offset %ld)  up to (exclusive)  ",  /* no '\n' */
+				paragraph_start_row, paragraph_start_text_offset);
+		while (old_row_index <= ring->end) {
+			prev_record_was_soft_wrapped = old_record.soft_wrapped;
+			paragraph_is_ascii = paragraph_is_ascii && old_record.is_ascii;
+			if (G_LIKELY (old_row_index < ring->end)) {
+				if (!_vte_ring_read_row_record(ring, &old_record, old_row_index))
+					goto err;
+				paragraph_end_text_offset = old_record.text_start_offset;
+			} else {
+				paragraph_end_text_offset = _vte_stream_head (ring->text_stream);
+			}
+			old_row_index++;
+			if (!prev_record_was_soft_wrapped)
+				break;
+		}
+		paragraph_end_row = old_row_index - 1;
+		paragraph_len = paragraph_end_text_offset - paragraph_start_text_offset;
+		if (!prev_record_was_soft_wrapped)  /* The last paragraph can be soft wrapped! */
+			paragraph_len--;  /* Strip trailing '\n' */
+		_vte_debug_print(VTE_DEBUG_RING,
+				"row %ld  (text_offset %ld)%s  len %ld  is_ascii %d\n",
+				paragraph_end_row, paragraph_end_text_offset,
+				prev_record_was_soft_wrapped ? "  soft_wrapped" : "",
+				paragraph_len, paragraph_is_ascii);
+
+		/* Wrap the paragraph */
+		if (attr_change.text_end_offset <= text_offset) {
+			/* Attr change at paragraph boundary, advance to next attr. */
+			attr_offset += sizeof (attr_change);
+			if (!_vte_stream_read(ring->attr_stream, attr_offset, (char *) &attr_change, sizeof (attr_change))) {
+				attr_change.attr = ring->last_attr;
+				attr_change.text_end_offset = _vte_stream_head (ring->text_stream);
+			}
+		}
+		memset(&new_record, 0, sizeof (new_record));
+		new_record.text_start_offset = text_offset;
+		new_record.attr_start_offset = attr_offset;
+		new_record.is_ascii = paragraph_is_ascii;
+
+		while (paragraph_len > 0) {
+			/* Wrap one continuous run of identical attributes within the paragraph. */
+			gsize runlength;  /* number of bytes we process in one run: identical attributes, within paragraph */
+			if (attr_change.text_end_offset <= text_offset) {
+				/* Attr change at line boundary, advance to next attr. */
+				attr_offset += sizeof (attr_change);
+				if (!_vte_stream_read(ring->attr_stream, attr_offset, (char *) &attr_change, sizeof (attr_change))) {
+					attr_change.attr = ring->last_attr;
+					attr_change.text_end_offset = _vte_stream_head (ring->text_stream);
+				}
+			}
+			runlength = MIN(paragraph_len, attr_change.text_end_offset - text_offset);
+
+			if (G_UNLIKELY (attr_change.attr.s.columns == 0)) {
+				/* Combining characters all fit in the current row */
+				text_offset += runlength;
+				paragraph_len -= runlength;
+			} else {
+				while (runlength) {
+					if (col >= columns - attr_change.attr.s.columns + 1) {
+						/* Wrap now, write the soft wrapped row's record */
+						new_record.soft_wrapped = 1;
+						_vte_stream_append(new_row_stream, (const char *) &new_record, sizeof (new_record));
+						_vte_debug_print(VTE_DEBUG_RING,
+								"    New row %ld  text_offset %ld  attr_offset %ld  soft_wrapped\n",
+								new_row_index,
+								new_record.text_start_offset, new_record.attr_start_offset);
+						for (i = 0; i < num_markers; i++) {
+							if (G_UNLIKELY (marker_text_offsets[i].text_offset >= new_record.text_start_offset &&
+									marker_text_offsets[i].text_offset < text_offset)) {
+								new_markers[i].row = new_row_index;
+								_vte_debug_print(VTE_DEBUG_RING,
+										"      Marker #%d will be here in row %lu\n", i, new_row_index);
+							}
+						}
+						new_row_index++;
+						new_record.text_start_offset = text_offset;
+						new_record.attr_start_offset = attr_offset;
+						col = 0;
+					}
+					if (paragraph_is_ascii) {
+						/* Shortcut for quickly wrapping ASCII (excluding TAB) text.
+						   Don't read text_stream, and advance by a whole row of characters. */
+						int len = MIN(runlength, (gsize) (columns - col));
+						col += len;
+						text_offset += len;
+						paragraph_len -= len;
+						runlength -= len;
+					} else {
+						/* Process one character only. */
+						char textbuf[6];  /* fits at least one UTF-8 character */
+						int textbuf_len;
+						col += attr_change.attr.s.columns;
+						/* Find beginning of next UTF-8 character */
+						text_offset++; paragraph_len--; runlength--;
+						textbuf_len = MIN(runlength, sizeof (textbuf));
+						if (!_vte_stream_read(ring->text_stream, text_offset, textbuf, textbuf_len))
+							goto err;
+						for (i = 0; i < textbuf_len && (textbuf[i] & 0xC0) == 0x80; i++) {
+							text_offset++; paragraph_len--; runlength--;
+						}
+					}
+				}
+			}
+		}
+
+		/* Write the record of the paragraph's last row. */
+		/* Hard wrapped, except maybe at the end of the very last paragraph */
+		new_record.soft_wrapped = prev_record_was_soft_wrapped;
+		_vte_stream_append(new_row_stream, (const char *) &new_record, sizeof (new_record));
+		_vte_debug_print(VTE_DEBUG_RING,
+				"    New row %ld  text_offset %ld  attr_offset %ld\n",
+				new_row_index,
+				new_record.text_start_offset, new_record.attr_start_offset);
+		for (i = 0; i < num_markers; i++) {
+			if (G_UNLIKELY (marker_text_offsets[i].text_offset >= new_record.text_start_offset &&
+					marker_text_offsets[i].text_offset < paragraph_end_text_offset)) {
+				new_markers[i].row = new_row_index;
+				_vte_debug_print(VTE_DEBUG_RING,
+						"      Marker #%d will be here in row %lu\n", i, new_row_index);
+			}
+		}
+		new_row_index++;
+		paragraph_start_text_offset = paragraph_end_text_offset;
+	}
+
+	/* Update the ring. */
+	old_ring_end = ring->end;
+	g_object_unref(ring->row_stream);
+	ring->row_stream = new_row_stream;
+	ring->writable = ring->end = new_row_index;
+	ring->start = 0;
+	if (ring->end > ring->max)
+		ring->start = ring->end - ring->max;
+
+	/* Find the markers. This requires that the ring is already updated. */
+	for (i = 0; i < num_markers; i++) {
+		/* Compute the row for markers beyond the ring */
+		if (new_markers[i].row == -1)
+			new_markers[i].row = markers[i]->row - old_ring_end + ring->end;
+		/* Convert byte offset into visual column */
+		if (!_vte_frozen_row_text_offset_to_column(ring, new_markers[i].row, &marker_text_offsets[i], &new_markers[i].col))
+			goto err;
+		_vte_debug_print(VTE_DEBUG_RING,
+				"Marker #%d new coords:  text_offset %ld  fragment_cells %d  eol_cells %d  ->  row %ld  col %ld\n",
+				i, marker_text_offsets[i].text_offset, marker_text_offsets[i].fragment_cells,
+				marker_text_offsets[i].eol_cells, new_markers[i].row, new_markers[i].col);
+		markers[i]->row = new_markers[i].row;
+		markers[i]->col = new_markers[i].col;
+	}
+	g_free(marker_text_offsets);
+	g_free(new_markers);
+
+	_vte_debug_print(VTE_DEBUG_RING, "Ring after rewrapping:\n");
+	_vte_ring_validate(ring);
+	return;
+
+err:
+#ifdef VTE_DEBUG
+	_vte_debug_print(VTE_DEBUG_RING,
+			"Error while rewrapping\n");
+	g_assert_not_reached();
+#endif
+	g_object_unref(new_row_stream);
+	g_free(marker_text_offsets);
+	g_free(new_markers);
+}
+
+
 static gboolean
 _vte_ring_write_row (VteRing *ring,
 		     GOutputStream *stream,
diff --git a/src/ring.h b/src/ring.h
index bd98e4a..27a5ab9 100644
--- a/src/ring.h
+++ b/src/ring.h
@@ -32,6 +32,10 @@
 G_BEGIN_DECLS
 
 
+typedef struct _VteVisualPosition {
+	long row, col;
+} VteVisualPosition;
+
 typedef struct _VteCellAttrChange {
 	gsize text_end_offset;  /* offset of first character no longer using this attr */
 	VteIntCellAttr attr;
@@ -82,6 +86,7 @@ VteRowData *_vte_ring_insert (VteRing *ring, gulong position);
 VteRowData *_vte_ring_append (VteRing *ring);
 void _vte_ring_remove (VteRing *ring, gulong position);
 void _vte_ring_set_visible_rows_hint (VteRing *ring, gulong rows);
+void _vte_ring_rewrap (VteRing *ring, glong columns, VteVisualPosition **markers);
 gboolean _vte_ring_write_contents (VteRing *ring,
 				   GOutputStream *stream,
 				   VteTerminalWriteFlags flags,
diff --git a/src/vte-private.h b/src/vte-private.h
index b7de21f..fb75b2a 100644
--- a/src/vte-private.h
+++ b/src/vte-private.h
@@ -143,10 +143,6 @@ typedef struct _VteWordCharRange {
 	gunichar start, end;
 } VteWordCharRange;
 
-typedef struct _VteVisualPosition {
-	long row, col;
-} VteVisualPosition;
-
 /* Terminal private data. */
 struct _VteTerminalPrivate {
 	/* Emulation setup data. */
diff --git a/src/vte.c b/src/vte.c
index 0ad759d..9a50e27 100644
--- a/src/vte.c
+++ b/src/vte.c
@@ -8013,35 +8013,72 @@ vte_terminal_refresh_size(VteTerminal *terminal)
 
 /* Resize the given screen (normal or alternate) of the terminal. */
 static void
-vte_terminal_screen_set_size(VteTerminal *terminal, VteScreen *screen, glong old_columns, glong old_rows)
+vte_terminal_screen_set_size(VteTerminal *terminal, VteScreen *screen, glong old_columns, glong old_rows, gboolean do_rewrap)
 {
 	VteRing *ring = screen->row_data;
+	VteVisualPosition cursor_saved_absolute;
+	VteVisualPosition below_viewport;
+	VteVisualPosition below_current_paragraph;
+	VteVisualPosition *markers[5];
 	gboolean was_scrolled_to_top = (screen->scroll_delta == _vte_ring_delta(ring));
 	gboolean was_scrolled_to_bottom = (screen->scroll_delta == screen->insert_delta);
+	glong old_top_lines;
 	glong new_scroll_delta;
-	long cursor_saved_absolute_row = screen->insert_delta + screen->cursor_saved.row;
 
 	_vte_debug_print(VTE_DEBUG_RESIZE,
 			"Resizing %s screen\n"
-			"Old  ring_delta=%ld  ring_next=%ld\n"
-			"Old  insert_delta=%ld  scroll_delta=%ld\n",
+			"Old  insert_delta=%ld  scroll_delta=%ld\n"
+			"     cursor_current (absolute)  row=%ld  (visual line %ld)  col=%ld\n"
+			"     cursor_saved (relative to insert_delta)  row=%ld  col=%ld\n",
 			screen == &terminal->pvt->normal_screen ? "normal" : "alternate",
-			_vte_ring_delta(ring), _vte_ring_next(ring),
-			screen->insert_delta, screen->scroll_delta);
-
-	if (old_rows > terminal->row_count &&
-	    screen->insert_delta + old_rows > screen->cursor_current.row + 1) {
-		/* Shrinking the window, cursor was not at the bottom.
-		   Drop lines from the bottom as XTerm does, see bug 708213 */
-		int drop_lines = MIN(
-				old_rows - terminal->row_count,
-				(screen->insert_delta + old_rows) - (screen->cursor_current.row + 1));
-		int new_ring_next = screen->insert_delta + old_rows - drop_lines;
-		_vte_debug_print(VTE_DEBUG_RESIZE,
-				"Dropping %d rows at the bottom\n",
-				drop_lines);
-		_vte_ring_shrink(ring, new_ring_next - _vte_ring_delta(ring));
+			screen->insert_delta, screen->scroll_delta,
+			screen->cursor_current.row, screen->cursor_current.row - screen->scroll_delta + 1, screen->cursor_current.col,
+			screen->cursor_saved.row, screen->cursor_saved.col);
+
+	cursor_saved_absolute.row = screen->cursor_saved.row + screen->insert_delta;
+	cursor_saved_absolute.col = screen->cursor_saved.col;
+	below_viewport.row = screen->scroll_delta + old_rows;
+	below_viewport.col = 0;
+	below_current_paragraph.row = screen->cursor_current.row + 1;
+	while (below_current_paragraph.row < _vte_ring_next(ring)
+	    && _vte_ring_index(ring, below_current_paragraph.row - 1)->attr.soft_wrapped) {
+		below_current_paragraph.row++;
+	}
+	below_current_paragraph.col = 0;
+	markers[0] = &screen->cursor_current;
+	markers[1] = &cursor_saved_absolute;
+	markers[2] = &below_viewport;
+	markers[3] = &below_current_paragraph;
+	markers[4] = NULL;
+
+	old_top_lines = below_current_paragraph.row - screen->insert_delta;
+
+	if (do_rewrap && old_columns != terminal->column_count)
+		_vte_ring_rewrap(ring, terminal->column_count, markers);
+
+	// TODO: what to do if screen==normal_screen && normal_screen->scrolling_restricted is true?
+
+	if (_vte_ring_length(ring) > terminal->row_count) {
+		/* The content won't fit without scrollbars. Before figuring out the position, we might need to
+		   drop some lines from the ring if the cursor is not at the bottom, as XTerm does. See bug 708213.
+		   This code is really tricky, see ../doc/rewrap.txt for details! */
+		glong new_top_lines, drop1, drop2, drop3, drop;
+		screen->insert_delta = _vte_ring_next(ring) - terminal->row_count;
+		new_top_lines = below_current_paragraph.row - screen->insert_delta;
+		drop1 = _vte_ring_length(ring) - terminal->row_count;
+		drop2 = _vte_ring_length(ring) - below_current_paragraph.row;
+		drop3 = old_top_lines - new_top_lines;
+		drop = MIN(MIN(drop1, drop2), drop3);
+		if (drop > 0) {
+			int new_ring_next = screen->insert_delta + terminal->row_count - drop;
+			_vte_debug_print(VTE_DEBUG_RESIZE,
+					"Dropping %ld [== MIN(%ld, %ld, %ld)] rows at the bottom\n",
+					drop, drop1, drop2, drop3);
+			_vte_ring_shrink(ring, new_ring_next - _vte_ring_delta(ring));
+		}
 	}
+
+	/* Figure out new insert and scroll deltas */
 	if (_vte_ring_length(ring) <= terminal->row_count) {
 		/* Everything fits without scrollbars. Align at top. */
 		screen->insert_delta = _vte_ring_delta(ring);
@@ -8062,22 +8099,31 @@ vte_terminal_screen_set_size(VteTerminal *terminal, VteScreen *screen, glong old
 			_vte_debug_print(VTE_DEBUG_RESIZE,
 					"Scroll to top\n");
 		} else {
-			/* Try to scroll so that the bottom visible row stays. */
-			new_scroll_delta = screen->scroll_delta + old_rows - terminal->row_count;
+			/* Try to scroll so that the bottom visible row stays.
+			   More precisely, the character below the bottom left corner stays in that
+			   (invisible) row.
+			   So if the bottom of the screen was at a hard line break then that hard
+			   line break will stay there.
+			   TODO: What would be the best behavior if the bottom of the screen is a
+			   soft line break, i.e. only a partial line is visible at the bottom? */
+			new_scroll_delta = below_viewport.row - terminal->row_count;
 			_vte_debug_print(VTE_DEBUG_RESIZE,
 					"Scroll so bottom row stays\n");
 		}
 	}
 
-	/* Saved cursor is relative to visible part. Adjust so that it stays relative to the ring.
-	   Don't clamp yet (so that it's tracked correctly through multiple resizes), it will be clamped when restored. */
-	screen->cursor_saved.row = cursor_saved_absolute_row - screen->insert_delta;
+	/* Don't clamp, they'll be clamped when restored. Until then remember off-screen values
+	   since they might become on-screen again on subsequent resizes. */
+	screen->cursor_saved.row = cursor_saved_absolute.row - screen->insert_delta;
+	screen->cursor_saved.col = cursor_saved_absolute.col;
 
 	_vte_debug_print(VTE_DEBUG_RESIZE,
-			"New  ring_delta=%ld  ring_next=%ld\n"
-			"New  insert_delta=%ld  scroll_delta=%ld\n\n",
-			_vte_ring_delta(ring), _vte_ring_next(ring),
-			screen->insert_delta, new_scroll_delta);
+			"New  insert_delta=%ld  scroll_delta=%ld\n"
+			"     cursor_current (absolute)  row=%ld  (visual line %ld)  col=%ld\n"
+			"     cursor_saved (relative to insert_delta)  row=%ld  col=%ld\n\n",
+			screen->insert_delta, new_scroll_delta,
+			screen->cursor_current.row, screen->cursor_current.row - new_scroll_delta + 1, screen->cursor_current.col,
+			screen->cursor_saved.row, screen->cursor_saved.col);
 
 	if (screen == terminal->pvt->screen)
 		vte_terminal_queue_adjustment_value_changed (
@@ -8130,10 +8176,12 @@ vte_terminal_set_size(VteTerminal *terminal, glong columns, glong rows)
 		_vte_ring_set_visible_rows_hint(terminal->pvt->alternate_screen.row_data, terminal->row_count);
 
 		/* Always resize normal screen, even if alternate is visible: bug 415277 */
-		vte_terminal_screen_set_size(terminal, &terminal->pvt->normal_screen, old_columns, old_rows);
+		vte_terminal_screen_set_size(terminal, &terminal->pvt->normal_screen, old_columns, old_rows, TRUE);
+		/* Resize the alternate screen if it's the current one, but never rewrap it: bug 336238 comment 60 */
 		if (terminal->pvt->screen == &terminal->pvt->alternate_screen)
-			vte_terminal_screen_set_size(terminal, &terminal->pvt->alternate_screen, old_columns, old_rows);
+			vte_terminal_screen_set_size(terminal, &terminal->pvt->alternate_screen, old_columns, old_rows, FALSE);
 
+		_vte_terminal_adjust_adjustments_full (terminal);
 		gtk_widget_queue_resize_no_redraw (&terminal->widget);
 		/* Our visible text changed. */
 		vte_terminal_emit_text_modified(terminal);
