diff --git a/src/option.h b/src/option.h
index f05a466..bc8d4e0 100644
--- a/src/option.h
+++ b/src/option.h
@@ -454,10 +454,11 @@
 EXTERN char_u	*p_dy;		/* 'display' */
 EXTERN unsigned	dy_flags;
 #ifdef IN_OPTION_C
-static char *(p_dy_values[]) = {"lastline", "uhex", NULL};
+static char *(p_dy_values[]) = {"lastline", "truncate", "uhex", NULL};
 #endif
 #define DY_LASTLINE		0x001
-#define DY_UHEX			0x002
+#define DY_TRUNCATE		0x002
+#define DY_UHEX			0x004
 EXTERN int	p_ed;		/* 'edcompatible' */
 #ifdef FEAT_WINDOWS
 EXTERN char_u	*p_ead;		/* 'eadirection' */
diff --git a/src/screen.c b/src/screen.c
index 1b364a4..b16bd87 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -2018,7 +2018,7 @@
 		    && wp->w_lines[idx].wl_valid
 		    && wp->w_lines[idx].wl_lnum == lnum
 		    && lnum > wp->w_topline
-		    && !(dy_flags & DY_LASTLINE)
+		    && !(dy_flags & (DY_LASTLINE | DY_TRUNCATE))
 		    && srow + wp->w_lines[idx].wl_size > wp->w_height
 #ifdef FEAT_DIFF
 		    && diff_check_fill(wp, lnum) == 0
@@ -2139,6 +2139,21 @@
 	    wp->w_filler_rows = wp->w_height - srow;
 	}
 #endif
+	else if (dy_flags & DY_TRUNCATE)	/* 'display' has "truncate" */
+	{
+	    int scr_row = W_WINROW(wp) + wp->w_height - 1;
+
+	    /*
+	     * Last line isn't finished: Display "@@@" in the last screen line.
+	     */
+	    screen_puts_len((char_u *)"@@", 2, scr_row, W_WINCOL(wp),
+							      hl_attr(HLF_AT));
+	    screen_fill(scr_row, scr_row + 1,
+		    (int)W_WINCOL(wp) + 2, (int)W_ENDCOL(wp),
+		    '@', ' ', hl_attr(HLF_AT));
+	    set_empty_rows(wp, srow);
+	    wp->w_botline = lnum;
+	}
 	else if (dy_flags & DY_LASTLINE)	/* 'display' has "lastline" */
 	{
 	    /*
diff --git a/src/version.c b/src/version.c
index 47417bf..c24cf7a 100644
--- a/src/version.c
+++ b/src/version.c
@@ -759,6 +759,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    2109,
+/**/
     2108,
 /**/
     2107,
